Rocky Linux 10: guida / Laboratorio completo: servizio limitato, backup e recupero dei dati

La pratica completa nella gestione di un server Rocky Linux 10 non si limita ad avviare un servizio. Devi eseguirlo con un account che abbia solo i permessi necessari, effettuare il backup dei dati normali, rilevare e ripristinare corruzioni intenzionali, e controllare se i dati persistono dopo un riavvio. In questo tutorial, creiamo un servizio contatore locale e colleghiamo l'intero processo in un'unica operazione.

Obiettivi di Pratica e Ambito di Preparazione Sicura

Il servizio legge il valore corrente con una richiesta GET /counter e lo incrementa di 1 con una richiesta POST /counter. Il valore non viene mantenuto solo in memoria ma anche memorizzato in un file di stato separato. L'obiettivo è eseguire il backup del valore normale 2, danneggiare intenzionalmente i dati, ripristinare 2 dal backup, incrementarlo nuovamente a 3 e verificare se persiste dopo il riavvio del servizio.

Questo viene eseguito su una VM dedicata Rocky Linux 10. L'ambiente di laboratorio di origine era Rocky 10.2, systemd 257, Python 3.12.15, GNU tar 1.35, con SELinux Enforcing. Il server HTTP standard di Python è utilizzato per questa pratica locale, e la documentazione ufficiale del server HTTP in Python non ne consiglia l'uso in produzione. Questo esempio, privo di autenticazione e TLS, non è esposto a servizi esterni.

Di seguito è riportato il processo nella shell di amministrazione per verificare eventuali conflitti con nuovi account, percorsi e porte. Se vengono trovati elementi esistenti, non cancellarli né riutilizzarli, e fermati. L’opzione set -e della shell assicura che non prosegua dopo fallimenti imprevisti, e un separato if è utilizzato per controlli in cui il fallimento è previsto.

sudo -i
set -euo pipefail
umask 077
rpm -q python3 tar policycoreutils
test ! -e /etc/systemd/system/lf-course32.service
test ! -e /etc/lf-course32
test ! -e /srv/lf-course32
test ! -e /var/lib/lf-course32
test ! -e /var/backups/lf-course32
if getent passwd lfcourse32; then exit 1; fi
if getent group lfcourse32; then exit 1; fi
LISTENERS=$(ss -H -lnt 'sport = :18040')
test -z "$LISTENERS"
systemctl is-active sshd firewalld
getenforce

I pacchetti richiesti e i comandi curl devono essere preparati. L'accesso amministrativo esistente e i firewall sono mantenuti, e non vengono effettuate ulteriori aperture di porte o aperture di firewall esterni. Tutti i percorsi /etc/lf-course32, /srv/lf-course32, /var/lib/lf-course32 e i percorsi di backup utilizzati da ora in poi sono dedicati a questa pratica.

Separare l'account di servizio, la configurazione e lo stato

Creare un account di sistema senza accesso al login lfcourse32 in modo che il servizio non venga eseguito sotto l'amministratore o un account personale di login. Anche se la shell di login è nologin, systemd può eseguire programmi sotto questo account. L'amministratore possiede le impostazioni e i programmi, mentre il servizio li legge solo e registra i dati di lavoro solamente nella directory di stato.

useradd --system --user-group --home-dir /var/lib/lf-course32 \
  --no-create-home --shell /sbin/nologin lfcourse32
install -d -o root -g lfcourse32 -m 750 /etc/lf-course32
install -d -o root -g root -m 755 /srv/lf-course32
install -d -m 700 /var/backups/lf-course32
printf '{"bind":"127.0.0.1","port":18040,"state":"/var/lib/lf-course32/counter.json"}\n' \
  > /etc/lf-course32/app.json
chown root:lfcourse32 /etc/lf-course32/app.json
chmod 640 /etc/lf-course32/app.json

Di seguito è riportato il programma completo. Quando salva lo stato, il programma scrive prima in un file temporaneo nella stessa directory e poi sostituisce il file di stato tramite rename. Questo è un modo per ridurre la possibilità di esporre contenuti intermedi in questo esercizio a processo singolo e non si tratta di un dispositivo di archiviazione che garantisce transazioni DB o persistenza in tutte le situazioni di interruzione di corrente.

cat > /srv/lf-course32/app.py <<'PY'
import json, os, sys, tempfile
from pathlib import Path
from http.server import BaseHTTPRequestHandler, HTTPServer
config = json.loads(Path(sys.argv[1]).read_text())
state = Path(config['state'])
def save(value):
    fd, name = tempfile.mkstemp(dir=state.parent, prefix='.counter-')
    try:
        with os.fdopen(fd, 'w') as stream:
            json.dump({'count': value}, stream)
            stream.write('\n')
            stream.flush()
            os.fsync(stream.fileno())
        os.replace(name, state)
    finally:
        if os.path.exists(name):
            os.unlink(name)
if not state.exists():
    save(0)
class Handler(BaseHTTPRequestHandler):
    def respond(self, increment=False):
        if self.path != '/counter':
            self.send_error(404)
            return
        try:
            count = json.loads(state.read_text())['count']
            if type(count) is not int or count < 0:
                raise ValueError('Invalid counter')
            if increment:
                count += 1
                save(count)
            body = (json.dumps({'count': count}) + '\n').encode()
            self.send_response(200)
        except (OSError, ValueError, KeyError):
            body = b'{"error":"Counter data unavailable"}\n'
            self.send_response(503)
        self.send_header('Content-Type', 'application/json')
        self.end_headers()
        self.wfile.write(body)
    def do_GET(self):
        self.respond()
    def do_POST(self):
        self.respond(True)
HTTPServer((config['bind'], config['port']), Handler).serve_forever()
PY
chmod 644 /srv/lf-course32/app.py

Se il file di stato non esiste dall'inizio, creare 0. Se il contenuto di un file esistente è errato, restituire 503 in risposta alla richiesta e non inizializzare arbitrariamente. Questa configurazione è per notificare all'amministratore che è necessario il recupero invece di sostituire silenziosamente i dati corrotti con nuovi dati durante un guasto.

Tuttavia, in questo esempio, l'assenza di un file è trattata come creazione iniziale, quindi se il file viene eliminato e riavviato, 0 può essere creato. Nel funzionamento reale, la prima inizializzazione e l'avvio normale dovrebbero essere distinti, e i file di stato esistenti mancanti dovrebbero essere considerati un errore che richiede recupero invece di un'inizializzazione automatica. I fallimenti in questo esercizio sono limitati a contenuti errati, non alla cancellazione dei file.

Eseguire come servizio systemd con restrizioni

Il seguente file di unità imposta insieme l'account di esecuzione, l'ambito di accesso ai file e la gestione della directory dello stato. StateDirectory=lf-course32 crea lo /var/lib/lf-course32 per il servizio di sistema e prepara la proprietà in base all'account di esecuzione. Pertanto, il programma non deve scrivere dati nella directory home.

cat > /etc/systemd/system/lf-course32.service <<'UNIT'
[Unit]
Description=Course32 counter recovery lab
After=network.target
[Service]
Type=exec
User=lfcourse32
Group=lfcourse32
ExecStart=/usr/bin/python3 /srv/lf-course32/app.py /etc/lf-course32/app.json
StateDirectory=lf-course32
StateDirectoryMode=0750
UMask=0077
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
CapabilityBoundingSet=
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
Restart=on-failure
RestartSec=2
[Install]
WantedBy=multi-user.target
UNIT
restorecon -RF /etc/lf-course32 /srv/lf-course32 \
  /etc/systemd/system/lf-course32.service
systemd-analyze verify /etc/systemd/system/lf-course32.service
systemctl daemon-reload
systemctl start lf-course32.service
Configurazione Ruoli e Ambito
User · Group Viene eseguito sotto un account dedicato. Nella VM di pratica, viene assegnato UID·GID 994, e potrebbe differire su altri server.
NoNewPrivileges Limita i percorsi attraverso i quali il programma eseguito può ottenere privilegi aggiuntivi.
CapabilityBoundingSet= Lascia vuoto l'ambito dei permessi del servizio delle capacità Linux, che suddividono i privilegi dell'amministratore per funzione.
ProtectSystem=strict Rende la maggior parte del filesystem di sola lettura. Le eccezioni per le directory scrivibili, come le directory di stato, dovrebbero essere riviste.
StateDirectory·PrivateTmp StateDirectory fornisce dati di servizio persistenti; PrivateTmp fornisce directory temporanee private. Rivedere queste eccezioni scrivibili insieme a ProtectSystem=strict.
ProtectHome Impedisce al servizio di accedere alle home degli utenti, alle home degli amministratori, ecc.
RestrictAddressFamilies Limita le famiglie di indirizzi dei socket che possono essere usate. Questa non è un'impostazione del firewall che restringe gli IP di destinazione o l'accesso a Internet di per sé.

Applicare restrizioni che non si adattano alla funzione tutte in una volta può causare il fallimento dei servizi normali. Verificare ogni opzione rispetto alla guida all’hardening di systemd di Rocky Linux e alle impostazioni di esecuzione di systemd 257 per la versione installata. Questa impostazione da sola non elimina tutti gli attacchi o i rischi operativi.

Controllare separatamente lo stato del processo e le richieste effettive

L'avvio riuscito di Type=exec significa che il programma è stato avviato correttamente, ma non implica che sia pronto a gestire le richieste HTTP. Durante la prima pratica, la connessione veniva talvolta rifiutata perché la richiesta era troppo veloce subito dopo l'avvio. Come mostrato di seguito, attendiamo la disponibilità limitata alle richieste di lettura e verifichiamo i valori normali.

systemctl show lf-course32.service -p User -p Group \
  -p NoNewPrivileges -p ProtectSystem -p StateDirectory -p MainPID
pid=$(systemctl show lf-course32.service -p MainPID --value)
grep -E '^(Uid|Gid|CapEff|NoNewPrivs):' "/proc/$pid/status"
curl --retry 5 --retry-connrefused --retry-delay 1 --max-time 3 \
  --fail --silent http://127.0.0.1:18040/counter
curl --fail --silent -X POST http://127.0.0.1:18040/counter
curl --fail --silent -X POST http://127.0.0.1:18040/counter
stat -c '%U %G %a %n' /var/lib/lf-course32/counter.json

Il primo valore letto dovrebbe essere 0, e il valore dopo due incrementi dovrebbe essere rispettivamente 1 e 2. Nel laboratorio di origine, l'UID·GID del processo era 994, il valore della capacità effettiva era 0, e NoNewPrivs era 1. Il proprietario del file di stato era lfcourse32, e i permessi erano 600. Nel laboratorio sorgente la risposta è stata confrontata con il file effettivo per confermare che il nuovo valore era stato memorizzato.

I tentativi di ripetizione per attendere la prontezza sono stati applicati solo alle richieste di lettura. Le richieste POST che modificano i valori possono essere applicate due volte se vengono ripetute incondizionatamente senza ricevere risposta. In tali casi, controllare prima il valore corrente per verificarne il risultato. Se la connessione fallisce ancora, controllare systemctl status lf-course32.service, journalctl -u lf-course32.service, e la configurazione e i permessi dei file.

Eseguire un backup coerente dopo l’arresto del servizio

Dopo aver fermato il servizio di scrittura, eseguire il backup del programma, della configurazione, dello stato e dei file di unità insieme. In questo programma, solo un processo scrive, quindi fermare il servizio è il punto di arresto della scrittura. Per i servizi utilizzati da più server o database insieme, deve essere definito un metodo separato per il backup coerente di quel prodotto.

systemctl stop lf-course32.service
tar --acls --xattrs --selinux --numeric-owner \
  -cpf /var/backups/lf-course32/backup.tar -C / \
  etc/lf-course32 srv/lf-course32 var/lib/lf-course32 \
  etc/systemd/system/lf-course32.service
cd /var/backups/lf-course32
sha256sum backup.tar > backup.tar.sha256
sha256sum -c backup.tar.sha256
tar -tvf backup.tar
sha256sum /etc/lf-course32/app.json /srv/lf-course32/app.py \
  /etc/systemd/system/lf-course32.service > application.sha256
sha256sum /var/lib/lf-course32/counter.json > counter-before.sha256

Il checksum è OK, e nella lista dovrebbero comparire solo i percorsi di pratica previsti. Il backup contiene il valore corretto 2. application.sha256 viene utilizzato per verificare se le impostazioni e i programmi sono stati modificati durante la corruzione dei dati o il ripristino, e counter-before.sha256 viene utilizzato per confermare che il file di stato sia tornato esattamente allo stesso punto del backup.

Questo backup è collocato sulla stessa VM per esercitarsi nel flusso di ripristino. I backup operativi effettivi sono conservati in posizioni separate, considerando il guasto totale del disco/server e le autorizzazioni di cancellazione originali. Avere semplicemente un checksum non dimostra la fonte del backup o la coerenza dei dati operativi. I metodi per verificare gli attributi dei file e ripristinarli in percorsi separati sono trattati in dettaglio nel corso Impostazioni/Backup dei dati utente e verifica del ripristino effettivo .

Crea una corruzione dei dati e distinguila dallo stato normale.

Riavvia il servizio e leggi prima normalmente il valore 2. Poi, modifica solo questo file di stato specifico per la pratica con contenuto errato. Non modificare i dati operativi effettivi o altri file del servizio.

systemctl start lf-course32.service
curl --retry 5 --retry-connrefused --retry-delay 1 --max-time 3 \
  --fail --silent http://127.0.0.1:18040/counter
printf 'broken counter data\n' > /var/lib/lf-course32/counter.json
curl --silent --output failure-response.txt --write-out 'HTTP %{http_code}\n' \
  http://127.0.0.1:18040/counter
cat failure-response.txt
systemctl is-active lf-course32.service
journalctl -u lf-course32.service -n 20 --no-pager

La risposta prevista è HTTP 503 e il seguente JSON.

{"error":"Counter data unavailable"}

In questo momento, systemctl is-active era ancora active. Il programma non si è terminato perché i dati per gestire la richiesta erano errati. Restart=on-failure è un'impostazione di riavvio per un’uscita anomala del processo e non ripristina automaticamente i dati di lavoro corrotti a un backup normale. Ecco perché sono necessari controlli su processo, porta, risposta HTTP e dati.

I log consentono il confronto tra risposte 200 e 503 per la stessa richiesta di percorso. Nei fallimenti reali, vengono esaminati insieme l'orario di modifica, l'ultima risposta normale e la proprietà, i permessi e il formato dei dati. I dati non vengono inizializzati prima di confermare se la causa dell’illeggibilità sia un problema di permessi o un contenuto errato.

Conservare i dati corrotti e ripristinarli ai valori normali

Interrompere il servizio per prevenire scritture durante il ripristino e conservare i dati corrotti con un nome separato. Estrarre solo il file di stato del contatore dedicato dal backup affidabile creato in questo laboratorio . Non aggiungere altri percorsi né estrarre un archivio non verificato con privilegi di amministratore.

systemctl stop lf-course32.service
test ! -e counter-corrupt.saved
cp -a /var/lib/lf-course32/counter.json counter-corrupt.saved
sha256sum -c backup.tar.sha256
tar --acls --xattrs --selinux --numeric-owner \
  --same-owner --same-permissions -xpf backup.tar -C / \
  var/lib/lf-course32/counter.json
sha256sum -c counter-before.sha256
stat -c '%U %G %a %n' /var/lib/lf-course32/counter.json
systemctl start lf-course32.service
curl --retry 5 --retry-connrefused --retry-delay 1 --max-time 3 \
  --fail --silent http://127.0.0.1:18040/counter

Il checksum del file di stato dovrebbe essere OK , il proprietario dovrebbe essere lfcourse32 , i permessi dovrebbero essere 600 e il valore di risposta dovrebbe restituire 2. Distinguere e verificare tra il risultato di un semplice riavvio del servizio e il risultato del reale ripristino da un backup normale.

Dopo il ripristino, incrementare il valore una volta per verificare che le scritture funzionino, quindi riavviare il servizio e leggerlo di nuovo.

curl --fail --silent -X POST http://127.0.0.1:18040/counter
systemctl restart lf-course32.service
curl --retry 5 --retry-connrefused --retry-delay 1 --max-time 3 \
  --fail --silent http://127.0.0.1:18040/counter
sha256sum -c application.sha256

Immediatamente dopo l'aumento e dopo il riavvio, {"count": 3} è apparso, e i checksum del programma, delle impostazioni e dei file dell'unità sono rimasti invariati. Questo risultato conferma la persistenza dei file dopo il riavvio del servizio e non riflette i risultati dei test di avvio automatico della VM per nuovi account/servizi o del recupero da interruzione di corrente in questo esercizio completo.

Registrare l'ambito verificato e le informazioni per il passaggio di consegne

Questa pratica ha avviato il servizio manualmente senza abilitare l'avvio automatico all'accensione. Dopo che la verifica è completata, interromperlo e controllare lo stato inattivo e le porte chiuse. Conservare l'account dedicato senza accesso, il programma, la configurazione, lo stato e il backup per la revisione e le ulteriori esercitazioni di ripristino. Altri account o servizi esistenti non sono soggetti alla pulizia.

systemctl stop lf-course32.service
systemctl is-enabled lf-course32.service || true
ss -lnt 'sport = :18040'
cd /var/backups/lf-course32
sha256sum -c /var/backups/lf-course32/backup.tar.sha256
systemctl is-active sshd firewalld
getenforce
exit

Nella VM sorgente, l'unità terminava con disabled e nessun listener sulla porta 18040. L'accesso amministrativo e il firewall sono stati mantenuti e SELinux era Enforcing. I controlli sulla sorgente hanno riscontrato che il fstab originale, il profilo di rete e il firewall non sono stati modificati. Gli account e i gruppi esistenti sono stati preservati mentre si aggiungeva l'account di servizio dedicato e il gruppo.

Per il trasferimento operativo, lasciare i contenuti e l'ambito effettivamente verificati come segue.

  • File eseguibile, configurazione, percorso stato, account di esecuzione, nome del servizio, indirizzo di ricezione e porta
  • Come verificare le richieste normali, i risultati effettivi della scrittura dei dati e la prontezza per l'avvio
  • Posizione, checksum, punto temporale del backup utilizzato e la sequenza per fermare i servizi
  • Conservazione dei dati danneggiati, ripristino, verifica della funzionalità dopo la ripresa e metodi di risposta in caso di guasto
  • Condizioni come connessioni esterne non verificate, riavvio, scritture multiple, interruzioni di corrente e personale aggiuntivo per conferma

Le procedure operative possono essere utilizzate solo se sono collegati servizi funzionanti, privilegi di esecuzione limitati, backup recuperabili e verifica effettiva della funzionalità. Registrare lo stato di successo di ciascun passaggio separatamente consente di valutare con precisione scenari come 'in esecuzione ma la richiesta fallisce' o 'file ripristinato ma la scrittura non funziona'.