Tutorial de Debian 13 / Proyecto práctico: servicio con estado, copia de seguridad y recuperación

Para verificar el funcionamiento de un servidor Debian, necesita comprobar no solo si el servicio está en funcionamiento, sino también si lee y escribe datos correctamente, y si las nuevas escrituras se mantienen después de restaurar datos corruptos a partir de copias de seguridad. En esta práctica integral, desplegará el servicio de contador con una cuenta dedicada y realizará secuencialmente copias de seguridad normales, corrupción de datos limitada, detección de errores HTTP y restauración real.

Defina el entorno del laboratorio y los criterios de éxito

Use una máquina virtual (VM) separada con Debian 13, Python 3.13 y systemd 257. Si Python 3, curl o tar no están disponibles, prepárelos con sudo apt install python3 curl tar. Ejecute con una cuenta administrativa que tenga privilegios sudo, y no aplique a servidores que ya utilicen alguna de las rutas especificadas, la cuenta o el puerto 8086.

El servicio HTTP solo acepta solicitudes en 127.0.0.1:8086. GET / lee el valor actual, y POST /increment sin cuerpo incrementa el valor en uno. Esto es para aprendizaje local, no un producto operativo que implemente autenticación, seguridad de la capa de transporte (TLS, Transport Layer Security) externa, o escrituras concurrentes por múltiples procesos. También revise el alcance de la documentación del servidor HTTP de Python.

Pasos Criterios de Éxito
Despliegue y Escritura Con una cuenta dedicada: 0 → 1 → 2, y todavía 2 después del reinicio del servicio
Copia de Seguridad Normal Generar archivo y hash en estado detenido, restaurar directorios vacíos separados, comparar contenidos y permisos
Detección de Daños Los procesos y puertos se mantienen pero tanto GET como POST retornan 503, los archivos corruptos no se inicializan automáticamente
Operación después de la Restauración Restaurar el valor 2 de la copia verificada → escribir nuevo 3 → después del reinicio 3 → escribir nuevo 4

Los siguientes comandos son la secuencia para ejecutar una nueva práctica una vez. Verifique para evitar sobrescribir la misma copia de seguridad, y si falla a la mitad, revise el estado y los registros, luego resuelva primero la causa del paso fallido. No ejecute nuevamente el bloque inicial para forzar la inicialización de valores normales.

Despliegue el programa completo con una cuenta dedicada

Antes de la configuración, también confirme que getent group lf-capstone36 no encuentre ningún grupo existente. Deténgase ante cualquier paso de requisito previo o creación fallido en lugar de reutilizar una cuenta, directorio o servicio existente. Asegúrese de que las solicitudes curl de loopback omitan cualquier proxy configurado.

El programa y la unidad de servicio pertenecen a root, y solo el directorio de datos es gestionado por una cuenta dedicada. Dentro de las restricciones del sistema de solo lectura de la unidad, se permite la ruta de datos para ReadWritePaths. En métodos de almacenamiento que crean archivos temporales y reemplazan nombres, no solo se requiere permiso de escritura para un solo archivo, sino también permisos de escritura y ejecución (búsqueda) en el directorio padre.

sudo bash <<'ROOT'
set -euo pipefail
for p in /opt/lf-capstone36 /var/lib/lf-capstone36 /var/backups/lf-capstone36 /etc/systemd/system/lf-capstone36.service; do test ! -e "$p"; done
if getent passwd lf-capstone36 >/dev/null; then exit 1; fi
test -z "$(ss -H -ltn 'sport = :8086')"
useradd --system --user-group --home-dir /var/lib/lf-capstone36 --no-create-home --shell /usr/sbin/nologin lf-capstone36
install -d -m 755 /opt/lf-capstone36
install -d -m 750 -o lf-capstone36 -g lf-capstone36 /var/lib/lf-capstone36
install -d -m 700 /var/backups/lf-capstone36
cat > /opt/lf-capstone36/app.py <<'PY'
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path
import json
import os
import tempfile

DATA = Path('/var/lib/lf-capstone36/state.json')

def load_count():
    value = json.loads(DATA.read_text(encoding='utf-8'))
    if (type(value) is not dict or set(value) != {'count'}
            or type(value['count']) is not int or value['count'] < 0):
        raise ValueError('invalid state')
    return value['count']

def save_count(count):
    temporary = None
    try:
        with tempfile.NamedTemporaryFile(
                mode='w', encoding='utf-8', dir=DATA.parent,
                prefix='state.', delete=False) as stream:
            temporary = Path(stream.name)
            json.dump({'count': count}, stream, separators=(',', ':'))
            stream.write('\n')
            stream.flush()
            os.fsync(stream.fileno())
        os.replace(temporary, DATA)
        descriptor = os.open(DATA.parent, os.O_RDONLY | os.O_DIRECTORY)
        try:
            os.fsync(descriptor)
        finally:
            os.close(descriptor)
    finally:
        if temporary is not None:
            temporary.unlink(missing_ok=True)

class Handler(BaseHTTPRequestHandler):
    def reply(self, status, value):
        body = (json.dumps(value, separators=(',', ':')) + '\n').encode()
        self.send_response(status)
        self.send_header('Content-Type', 'application/json; charset=utf-8')
        self.send_header('Content-Length', str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path != '/':
            self.reply(404, {'error': 'not found'})
            return
        try:
            count = load_count()
        except (OSError, ValueError):
            self.reply(503, {'error': 'state unavailable'})
            return
        self.reply(200, {'count': count})

    def do_POST(self):
        if self.path != '/increment':
            self.reply(404, {'error': 'not found'})
            return
        if self.headers.get('Content-Length', '0') != '0':
            self.reply(400, {'error': 'empty body required'})
            return
        try:
            count = load_count() + 1
            save_count(count)
        except (OSError, ValueError):
            self.reply(503, {'error': 'state unavailable'})
            return
        self.reply(200, {'count': count})

HTTPServer(('127.0.0.1', 8086), Handler).serve_forever()
PY
cat > /etc/systemd/system/lf-capstone36.service <<'UNIT'
[Unit]
Description=LF capstone counter 36
After=network.target

[Service]
Type=exec
User=lf-capstone36
Group=lf-capstone36
WorkingDirectory=/opt/lf-capstone36
ExecStart=/usr/bin/python3 -B /opt/lf-capstone36/app.py
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
ReadWritePaths=/var/lib/lf-capstone36
MemoryMax=128M
TasksMax=32
Restart=on-failure
RestartSec=2s

[Install]
WantedBy=multi-user.target
UNIT
chmod 644 /opt/lf-capstone36/app.py /etc/systemd/system/lf-capstone36.service
printf '{"count":0}\n' > /var/lib/lf-capstone36/state.json
chown lf-capstone36:lf-capstone36 /var/lib/lf-capstone36/state.json
chmod 600 /var/lib/lf-capstone36/state.json
systemd-analyze verify /etc/systemd/system/lf-capstone36.service
systemctl daemon-reload
systemctl enable --now lf-capstone36.service
sleep .4
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":0}'
test "$(curl -fsS -X POST http://127.0.0.1:8086/increment)" = '{"count":1}'
test "$(curl -fsS -X POST http://127.0.0.1:8086/increment)" = '{"count":2}'
systemctl restart lf-capstone36.service
sleep .3
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":2}'
systemctl is-enabled lf-capstone36.service
pid=$(systemctl show -p MainPID --value lf-capstone36.service)
ps -o user=,group=,args= -p "$pid"
if runuser -u lf-capstone36 -- test -w /opt/lf-capstone36/app.py; then echo CODE_WRITABLE >&2; exit 1; fi
if runuser -u lf-capstone36 -- test -r /var/backups/lf-capstone36; then echo BACKUP_READABLE >&2; exit 1; fi
systemctl show lf-capstone36.service -p NoNewPrivileges -p ProtectSystem -p ReadWritePaths -p MemoryMax -p TasksMax
echo COUNTER0_TO1_TO2_AND_RESTART_PERSISTENCE_LEAST_PRIVILEGE_PASSED
ROOT

Las breves pausas de inicio son retrasos, no garantías de disponibilidad. Si una solicitud falla, inspeccione sudo systemctl status lf-capstone36.service y sudo journalctl -u lf-capstone36.service -n 30, luego use GET para verificar el valor actual. No repita toda la configuración ni reintente POST a ciegas: una escritura puede haberse completado aunque la respuesta se haya perdido. Además, según el orden del código, si os.replace tiene éxito y después falla fsync del directorio, el servicio puede devolver 503 tras cambiar el valor. Lea el valor actual mediante GET antes de decidir si envía otro POST.

Si se ejecuta hasta el final del bloque sin errores, 0 → 1 → 2 y después de reiniciar el servicio, se confirma que se mantiene 2. La cuenta dedicada no puede modificar archivos de código ni leer directorios de respaldo solo para root, y la salida de restricción de ejecución muestra ProtectSystem=strict, NoNewPrivileges=yes, memoria 128 MiB y 32 tareas. Estos límites son para un ejemplo pequeño y deberían ajustarse para coincidir con los valores medidos del servicio real.

El programa utiliza un analizador JSON (JavaScript Object Notation) para verificar la estructura, el tipo entero y el rango de los valores leídos. Si encuentra un archivo inválido, devuelve 503 en lugar de reiniciar a 0. Inicializar automáticamente a 0 podría destruir valores existentes y evidencias necesarias para recuperarlos, y ocultar errores como respuestas normales.

Al guardar, crea un archivo temporal en el mismo directorio de datos usando NamedTemporaryFile, y después de flush y fsync, reemplaza el nombre con os.replace. El directorio también está sincronizado, pero este ejercicio no probó cortes de energía ni pérdida de caché de disco virtual. No considere que el reemplazo atómico de nombres y la durabilidad contra fallos de energía en todos los dispositivos de almacenamiento proporcionen la misma garantía.

Este servidor HTTP maneja las solicitudes de manera secuencial dentro de un mismo proceso del servidor. No se implementa la sincronización en los casos en que múltiples procesos modifican el mismo archivo o herramientas externas escriben simultáneamente. Además, las solicitudes de incremento cambian el valor cada vez que se repiten, por lo que reenviarlas ciegamente porque se perdió una respuesta puede incrementarlo dos veces. En operaciones reales, se debe considerar un método de almacenamiento con manejo de transacciones y solicitudes duplicadas.

La prueba original en una VM Debian verificó el estado habilitado y el reinicio del servicio utilizando systemctl. Dado que el inicio automático después del reinicio de la VM no se probó por separado en este ejercicio integral, antes de la entrega real, también realice una prueba de arranque asegurando los medios de consola y recuperación. El significado de la cuenta, la ruta y la configuración de protección se puede consultar en el manual del entorno de ejecución de systemd.

Respalde el servicio detenido y pruebe la restauración en un directorio vacío

Detenga el servicio y haga una copia de seguridad del contador mientras su valor es 2. Si enviar solicitudes adicionales cambia el valor, verifique por qué cambió y configure el valor de referencia previsto. No sobrescriba los datos con 2 si la verificación siguiente falla.

sudo bash <<'ROOT'
set -euo pipefail
dest=/var/backups/lf-capstone36
test ! -e "$dest/service.tar"
systemctl stop lf-capstone36.service
test "$(cat /var/lib/lf-capstone36/state.json)" = '{"count":2}'
sha256sum /var/lib/lf-capstone36/state.json > "$dest/state-before.sha256"
stat -c '%u:%g:%a' /var/lib/lf-capstone36/state.json > "$dest/state-mode.txt"
tar --acls --xattrs --numeric-owner -cpf "$dest/service.tar" -C / opt/lf-capstone36 var/lib/lf-capstone36 etc/systemd/system/lf-capstone36.service
cd "$dest"
sha256sum service.tar > service.sha256
sha256sum -c service.sha256
mkdir -m 700 restore-test
tar --acls --xattrs --numeric-owner --same-owner -xpf service.tar -C restore-test
cmp /opt/lf-capstone36/app.py restore-test/opt/lf-capstone36/app.py
cmp /var/lib/lf-capstone36/state.json restore-test/var/lib/lf-capstone36/state.json
test "$(stat -c '%u:%g:%a' restore-test/var/lib/lf-capstone36/state.json)" = "$(cat state-mode.txt)"
systemctl start lf-capstone36.service
sleep .3
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":2}'
echo STOPPED_BACKUP_CHECKSUM_AND_EMPTY_DIRECTORY_RESTORE_PASSED
ROOT

service.tar: OK es una verificación de integridad del archivo. Luego, compare los bytes de los programas y datos extraídos en la prueba de restauración vacía, así como los identificadores de usuario (UID) y grupo (GID) y los permisos del archivo de datos. Esta es una verificación más fuerte que simplemente la existencia del archivo de respaldo, pero aún no es una restauración después de una falla en la ruta de servicio real. Ese proceso se lleva a cabo por separado más abajo.

El archivo incluye solo los programas, datos y unidades de este ejercicio. Debido a que /var/backups está en el mismo disco, no es una copia de seguridad independiente contra la pérdida total del disco. Para datos operativos reales, también prepare una copia almacenada con almacenamiento y derechos de acceso separados y verifíquela en el intervalo de restauración designado. Puede consultar las opciones de tar en Manual de GNU tar de Debian.

Corrompa solo los datos del laboratorio y detecte los errores HTTP

El siguiente bloque cambia deliberadamente solo el /var/lib/lf-capstone36/state.json que acaba de crear a un estado semánticamente inválido: JSON válido con una cadena donde se requiere un entero. Ejecute esto solo después de pasar la verificación de copia de seguridad normal y no sustituya la ruta con archivos operativos. No experimente con matar procesos ni llenar el disco.

sudo bash <<'ROOT'
set -euo pipefail
dest=/var/backups/lf-capstone36
printf '{"count":"broken"}\n' > /var/lib/lf-capstone36/state.json
sha256sum /var/lib/lf-capstone36/state.json > "$dest/broken-state.sha256"
test "$(curl -sS -o "$dest/broken-get.txt" -w '%{http_code}' http://127.0.0.1:8086/)" = 503
test "$(curl -sS -X POST -o "$dest/broken-post.txt" -w '%{http_code}' http://127.0.0.1:8086/increment)" = 503
sha256sum -c "$dest/broken-state.sha256"
test "$(cat "$dest/broken-get.txt")" = '{"error":"state unavailable"}'
systemctl is-active lf-capstone36.service
ss -ltn 'sport = :8086'
journalctl -u lf-capstone36.service -n 8 --no-pager
echo ACTIVE_PROCESS_OPEN_PORT_BUT_GET_AND_POST_503_BROKEN_DATA_UNCHANGED
ROOT

Dado que count era una cadena en el JSON, tanto GET como POST deberían devolver 503. curl -f falla en la respuesta de error, por lo que en esta sección omitimos -f y guardamos por separado el cuerpo y el código de estado. Después de la corrupción, volvemos a comparar el SHA-256 para asegurarnos de que la solicitud de escritura fallida no haya inicializado los datos.

En la verificación real, el servicio estaba activo y el puerto también estaba en LISTEN, pero la solicitud devolvió 503. Restart=on-failure es una política para cuando un proceso termina con fallo, por lo que no corrige automáticamente datos incorrectos en un proceso en ejecución. Por eso necesitamos verificar el proceso, el socket, la respuesta HTTP y el significado de los datos individualmente.

Restaure los datos en su ruta real y verifique nuevas escrituras

Después de detener el servicio, conserve los archivos corruptos como evidencia y restaure solo un archivo de datos del archivo verificado a su ubicación original. No sobrescriba indiscriminadamente los programas normales y las unidades de servicio. Dado que la restauración ocurre en la misma máquina virtual aquí, podemos comparar directamente el UID y GID numéricos registrados previamente. Si se transfiere a un servidor diferente, deberá restablecerlos según la cuenta de destino, como en migración del servicio y asignación de propiedad.

sudo bash <<'ROOT'
set -euo pipefail
dest=/var/backups/lf-capstone36
systemctl stop lf-capstone36.service
cp -a /var/lib/lf-capstone36/state.json "$dest/broken-state.json"
cd "$dest"
sha256sum -c service.sha256
tar --acls --xattrs --numeric-owner --same-owner -xpf service.tar -C / var/lib/lf-capstone36/state.json
sha256sum -c state-before.sha256
test "$(stat -c '%u:%g:%a' /var/lib/lf-capstone36/state.json)" = "$(cat state-mode.txt)"
systemctl start lf-capstone36.service
sleep .3
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":2}'
test "$(curl -fsS -X POST http://127.0.0.1:8086/increment)" = '{"count":3}'
systemctl restart lf-capstone36.service
sleep .3
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":3}'
test "$(curl -fsS -X POST http://127.0.0.1:8086/increment)" = '{"count":4}'
test "$(curl -fsS http://127.0.0.1:8086/)" = '{"count":4}'
stat -c '%U:%G:%a' /var/lib/lf-capstone36/state.json
echo ACTUAL_RESTORE_COUNT2_NEW_WRITE3_RESTART3_NEW_WRITE4_PASSED
ROOT

El hash del estado almacenado describe el valor de respaldo 2. Compárelo inmediatamente después de la restauración, antes del siguiente POST. Los incrementos exitosos a 3 y 4 cambian deliberadamente el archivo y su hash; registre el nuevo valor esperado en lugar de tratar cada diferencia de hash posterior como corrupción.

El resultado esperado es OK para el archivo y el hash de datos, y lf-capstone36:lf-capstone36:600. Después de leer el valor restaurado 2, registrar 3 vía POST, reiniciar el proceso, leer 3 nuevamente y verificar la escritura una vez más para obtener 4. Distinguir entre el hecho de que el archivo fue extraído y el hecho de que las operaciones de lectura/escritura son posibles después de la restauración.

Interprete las comprobaciones fallidas antes de hacer cambios

Síntomas Puntos a verificar primero
Fallo en el inicio del servicio Verifique el archivo ejecutable, el usuario, los errores de ruta en journalctl y el resultado de systemd-analyze verify.
Proceso activo, sin puerto Verifique el MainPID, los argumentos de ejecución, la dirección de enlace, los puertos duplicados y los registros justo después de iniciar.
GET devuelve 503 Verifique la existencia del archivo, los permisos de lectura, la sintaxis JSON y los tipos de enteros, y primero preserve los archivos dañados.
Éxito de lectura, escribir 503 Verifique los permisos del directorio de datos, ReadWritePaths, el espacio restante, inode y las condiciones de reemplazo de archivos.
Los valores cambian después del reinicio Verifique la ruta de datos real, el montaje, si el guardado tuvo éxito y otros procesos de escritura.

Si la restauración está completa, registre el estado del servicio, los puertos, las respuestas, los hashes de datos y los valores normales cambiados después de la restauración en el registro de trabajo. Si hubo transacciones normales o cargas después del punto de restauración, restaurar la copia de seguridad antigua sobre los datos actuales podría hacer perder esos cambios más recientes, así que primero decida sobre la detención de escrituras, la preservación separada y los métodos de reaplicación.

Limpie el servicio del laboratorio y conserve la copia de seguridad

El bloque a continuación solo limpia servicios, código, datos y cuentas recién creados en este artículo. Mantenga copias de seguridad y evidencia de daños en un directorio solo para root para comparación. Al eliminar copias después del período de retención, seleccione los archivos exactos y no borre copias de seguridad de otros servicios junto con ellos.

sudo bash <<'ROOT'
set -euo pipefail
systemctl disable --now lf-capstone36.service
rm -- /etc/systemd/system/lf-capstone36.service /opt/lf-capstone36/app.py /var/lib/lf-capstone36/state.json
rmdir /opt/lf-capstone36 /var/lib/lf-capstone36
systemctl daemon-reload
userdel lf-capstone36
test -z "$(ss -H -ltn 'sport = :8086')"
echo OWN_SAMPLE_REMOVED_VALID_BACKUP_AND_BROKEN_EVIDENCE_RETAINED
ROOT