Debian 13 : tutoriel / Créer un service HTTP avec état persistant et tester sa sauvegarde et sa restauration
Pour vérifier le fonctionnement d'un serveur Debian, vous devez vérifier non seulement si le service fonctionne, mais aussi s'il lit et écrit correctement les données, et si les nouvelles écritures sont conservées après restauration des données corrompues à partir de sauvegardes. Dans cette pratique complète, vous déploierez le service de compteur avec un compte dédié et effectuerez successivement des sauvegardes normales, une corruption limitée des données, la détection d'erreurs HTTP et une restauration réelle.
Définir l'environnement de laboratoire et les critères de réussite
Utilisez une machine virtuelle (VM) séparée avec Debian 13, Python 3.13 et systemd 257. Si Python 3, curl ou tar ne sont pas disponibles, préparez-les avec sudo apt install python3 curl tar. Exécutez avec un compte administratif disposant de privilèges sudo, et n'appliquez pas aux serveurs utilisant déjà l'un des chemins spécifiés, le compte ou le port 8086.
Le service HTTP n'accepte les requêtes qu'à 127.0.0.1:8086. GET / lit la valeur actuelle, et POST /increment sans corps incrémente la valeur de un. Ceci est pour l'apprentissage local, ce n'est pas un produit opérationnel implémentant l'authentification, la sécurité des échanges externes par TLS (Transport Layer Security) ou les écritures concurrentes par plusieurs processus. Vérifiez également le cadre de la documentation du serveur HTTP Python.
| Étapes | Critères de réussite |
|---|---|
| Déploiement et écriture | Avec un compte dédié : 0 → 1 → 2, et toujours 2 après le redémarrage du service |
| Sauvegarde normale | Générer l'archive et le hachage à l'état arrêté, restaurer des répertoires vides séparés, comparer le contenu et les permissions |
| Détection de dommages | Les processus et ports sont maintenus mais à la fois GET et POST retournent 503, les fichiers corrompus ne sont pas initialisés automatiquement |
| Opération après restauration | Restaurer 2 à partir de la sauvegarde réelle → écrire un nouveau 3 → après redémarrage 3 → écrire un nouveau 4 |
Les commandes ci-dessous sont la séquence pour exécuter une nouvelle pratique une seule fois. Vérifiez pour éviter d'écraser la même sauvegarde, et si cela échoue au milieu, vérifiez l'état et les journaux, puis résolvez d'abord la cause de l'étape échouée. Ne relancez pas le bloc initial pour forcer l'initialisation des valeurs normales.
Déployez le programme complet sous un compte dédié.
Avant l'installation, confirmez également que getent group lf-capstone36 ne trouve aucun groupe existant. Arrêtez-vous à toute étape de condition préalable ou de création échouée plutôt que de réutiliser un compte, un répertoire ou un service existant. Assurez-vous que les requêtes curl en boucle locale contournent tout proxy configuré.
Les unités de programme et de service appartiennent à root, et seul le répertoire de données est géré par un compte dédié. Dans le cadre des restrictions du système en lecture seule de l'unité, le chemin des données est autorisé pour ReadWritePaths. Dans les méthodes de stockage qui créent des fichiers temporaires et remplacent les noms, non seulement la permission d'écriture pour un seul fichier est requise, mais aussi les permissions d’écriture et d’exécution (recherche) sur le répertoire parent.
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
Les courts temps d'attente au démarrage sont des délais, pas des garanties de disponibilité. Si une requête échoue, inspectez sudo systemctl status lf-capstone36.service et sudo journalctl -u lf-capstone36.service -n 30, puis utilisez GET pour vérifier la valeur actuelle. Ne répétez pas toute la configuration ni ne réessayez POST aveuglément : une écriture peut avoir été effectuée même si sa réponse a été perdue. Si os.replace réussit puis que la synchronisation du répertoire par fsync échoue, le service peut également retourner 503 alors que la valeur a déjà changé. Lisez donc la valeur actuelle avec GET avant de décider d’un nouveau POST.
Si cela s'exécute jusqu'à la fin du bloc sans erreurs, 0 → 1 → 2 et après le redémarrage du service, le maintien de 2 est confirmé. Le compte dédié ne peut pas modifier les fichiers de code ou lire les répertoires de sauvegarde accessibles uniquement à root, et la sortie de restriction d'exécution montre ProtectSystem=strict, NoNewPrivileges=yes, mémoire 128 MiB et 32 tâches. Ces limites sont pour un petit exemple et devraient être ajustées pour correspondre aux valeurs mesurées du service réel.
Le programme utilise un analyseur JSON (JavaScript Object Notation) pour vérifier la structure, le type entier et la plage des valeurs lues. S'il rencontre un fichier invalide, il renvoie 503 au lieu de réinitialiser à 0. L'initialisation automatique à 0 pourrait faire perdre des preuves à récupérer et des valeurs existantes, et masquer des erreurs comme réponses normales.
Lors de l'enregistrement, créez un fichier temporaire dans le même répertoire de données en utilisant NamedTemporaryFile, et après flush et fsync, remplacez le nom par os.replace. Le répertoire est également synchronisé, mais cet exercice n'a pas testé les coupures de courant ou la perte du cache du disque virtuel. Ne considérez pas le remplacement atomique de nom et la durabilité contre les coupures de courant sur tous les périphériques de stockage comme offrant la même garantie.
Ce serveur HTTP traite les requêtes de manière séquentielle au sein d'un seul processus serveur. La synchronisation pour les cas où plusieurs processus modifient le même fichier ou où des outils externes écrivent simultanément n'est pas implémentée. De plus, les requêtes d'incrémentation changent la valeur à chaque fois qu'elles sont répétées, donc renvoyer aveuglément parce qu'une réponse a été manquée peut l'augmenter deux fois. Dans les opérations réelles, vous devriez envisager une méthode de stockage avec gestion des transactions et des requêtes en double.
L’exercice d’origine dans une VM Debian a vérifié l'état activé et le redémarrage du service à l'aide de systemctl. Comme le démarrage automatique après le redémarrage de la VM n'a pas été testé séparément dans cet exercice complet, avant la remise effective, effectuez également un test de démarrage tout en assurant les moyens de console et de récupération. La signification des paramètres de compte, de chemin et de protection peut être consultée dans le manuel de l’environnement d’exécution de systemd.
Sauvegarder le service arrêté et tester une restauration dans un répertoire vide
Arrêtez le service et sauvegardez le compteur lorsque sa valeur est de 2. Si l'envoi de requêtes supplémentaires modifie la valeur, vérifiez pourquoi elle a changé et définissez la valeur de référence prévue. Ne pas écraser les données avec 2 si la vérification suivante échoue.
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 est une vérification de l'intégrité de l'archive. Ensuite, comparez les octets des programmes et données extraits dans le test de restauration vide ainsi que les identifiants de l’utilisateur (UID) et du groupe (GID) et les permissions du fichier de données. C'est une vérification plus poussée que la simple existence du fichier de sauvegarde mais ce n'est pas encore une restauration après une défaillance dans le chemin de service réel. Ce processus est effectué séparément ci-dessous.
L'archive inclut uniquement les programmes, les données et les unités de cet exercice. Comme /var/backups se trouve sur le même disque, ce n'est pas une sauvegarde indépendante contre une perte totale du disque. Pour les données opérationnelles réelles, préparez également une copie stockée avec un stockage et des droits d'accès séparés et vérifiez-la à l'intervalle de restauration désigné. Vous pouvez vous référer aux options de tar dans manuel Debian de GNU tar.
Corrompre uniquement les données de laboratoire et détecter les erreurs HTTP
Le bloc suivant modifie délibérément uniquement le /var/lib/lf-capstone36/state.json que vous venez de créer pour le mettre dans un état sémantiquement invalide : JSON valide avec une chaîne à la place d'un entier requis. Exécutez ceci uniquement après avoir passé la vérification de sauvegarde normale et ne remplacez pas le chemin par des fichiers opérationnels. N'expérimentez pas avec la terminaison des processus ou le remplissage du disque.
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
Puisque count était une chaîne dans le JSON, à la fois GET et POST devraient renvoyer 503. curl -f échoue dans la réponse d'erreur, donc dans cette section, nous omettons -f et sauvegardons séparément le corps et le code de statut. Après la corruption, nous re-comparons le SHA-256 pour nous assurer que la requête d'écriture échouée n'a pas initialisé les données.
Lors de la vérification réelle, le service était actif et le port était également en ÉCOUTE, mais la requête a retourné 503. Restart=on-failure est une politique appliquée lorsqu’un processus se termine par une erreur, donc elle ne corrige pas automatiquement les données incorrectes dans un processus en cours. C'est pourquoi nous devons vérifier individuellement le processus, le socket, la réponse HTTP, et la signification des données.
Restaurer le chemin des données réelles et vérifier les nouvelles écritures
Après avoir arrêté le service, conservez les fichiers corrompus comme preuves et restaurez uniquement un fichier de données depuis l'archive vérifiée à son emplacement d'origine. Ne remplacez pas de manière indiscriminée les programmes normaux et les unités de service. Comme la restauration se fait sur la même VM ici, nous pouvons comparer directement l'UID et le GID numériques enregistrés précédemment. Si vous passez à un serveur différent, vous devez les réinitialiser en fonction du compte cible, comme dans migration de service et mappage de propriété.
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
Le hachage de l'état stocké décrit la valeur de sauvegarde 2. Comparez-le immédiatement après restauration, avant le prochain POST. Des incréments réussis à 3 et 4 modifient délibérément le fichier et son hachage ; enregistrez la nouvelle valeur attendue au lieu de traiter chaque différence de hachage ultérieure comme une corruption.
Le résultat attendu est OK pour l’archive et le hash des données, et lf-capstone36:lf-capstone36:600. Lisez d’abord la valeur restaurée 2 avec GET, puis écrivez 3 avec POST. Redémarrez le processus, lisez à nouveau 3 avec GET et effectuez un nouveau POST pour obtenir 4. Faire la distinction entre le fait que le fichier a été extrait et le fait que les opérations de lecture/écriture sont possibles après restauration.
Interpréter les vérifications échouées avant de faire des modifications
| Symptômes | Points à vérifier en premier |
|---|---|
| Échec du démarrage du service | Vérifier le fichier exécutable, l’utilisateur, les erreurs de chemin dans journalctl, et le résultat de systemd-analyze verify. |
| Processus actif, aucun port | Vérifiez le MainPID, les arguments d'exécution, l'adresse de liaison, les ports en double et les journaux juste après le démarrage. |
| GET retourne 503 | Vérifiez l'existence des fichiers, les permissions de lecture, la syntaxe JSON et les types entiers, et conservez d'abord les fichiers corrompus. |
| Lecture réussie, écriture 503 | Vérifiez les permissions du répertoire de données, ReadWritePaths, l'espace restant, l'inode et les conditions de remplacement des fichiers. |
| Les valeurs changent après le redémarrage | Vérifiez le chemin des données réel, le montage, si l'enregistrement a été réussi, et les autres processus d'écriture. |
Si la restauration est complète, enregistrez le statut du service, les ports, les réponses, les hachages de données et les valeurs normales modifiées après la restauration dans le journal de travail. S'il y avait des transactions normales ou des téléversements après le point de restauration, restaurer l'ancienne sauvegarde sur les données actuelles pourrait entraîner la perte de ces modifications plus récentes, donc décidez d'abord de l'arrêt des écritures, de la préservation séparée et des méthodes de réapplication.
Nettoyez le service du laboratoire et conservez sa sauvegarde
Le bloc ci-dessous ne fait que nettoyer les services, le code, les données et les comptes nouvellement créés dans cet article. Conservez les sauvegardes et les preuves des dommages dans un répertoire uniquement accessible au root pour comparaison. Lors de la suppression des copies après la période de conservation, sélectionnez les fichiers exacts et ne supprimez pas ensemble les sauvegardes des autres services.
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




