Rocky Linux 10: guida / Migrare servizi da Rocky Linux 9 a 10 con una nuova installazione

Quando si passa da Rocky Linux 9 a 10, ci si prepara installando un nuovo server Rocky Linux 10 e migrando le configurazioni e i dati necessari. Il progetto Rocky Linux non supporta ufficialmente gli aggiornamenti in-place tra versioni principali diverse. Validando il nuovo ambiente mantenendo il server esistente, è più facile individuare problemi prima del passaggio e definire le condizioni di rollback.

Distinguere gli aggiornamenti minori dalla migrazione da Rocky 9 a 10

Aggiornare all'ultima versione minore all'interno della serie 9.x e cambiare la versione principale da 9 a 10 sono compiti diversi. Il documento ufficiale sulla migrazione delle versioni di Rocky Linux guida attraverso un flusso di installazione pulita, preparazione degli account necessari, repository, pacchetti e ripristino dei backup. Semplicemente cambiare i numeri negli indirizzi dei repository o utilizzare dnf --releasever=10 non è considerato un metodo di migrazione ufficiale standard.

Lo scopo della preparazione di un nuovo server non è replicare l'intero sistema esistente. Si tratta di adattare i dati e le impostazioni richieste dal servizio sopra le impostazioni predefinite e le politiche di sicurezza del nuovo sistema operativo. Semplicemente trasferire il kernel, le librerie e gli RPM del vecchio server sul nuovo server può portare a dipendenze non corrispondenti e a limitazioni nel supporto.

Destinazione della Migrazione Attività sul Nuovo Server Criteri di Verifica
Account Utente e di Servizio Creare gli account necessari e definire il corrispondente UID e GID. Gli account previsti devono essere in grado di leggere e scrivere i dati migrati.
Pacchetti e Ambiente di Esecuzione Installa le versioni richieste dal repository Rocky 10. I programmi e i moduli di estensione devono funzionare sul nuovo runtime.
Configurazione Riapplica le modifiche necessarie basate sui nuovi file predefiniti. I controlli di configurazione e l'avvio del servizio devono avere successo.
File·Dati DB Ripristina backup coerenti in un percorso separato. Controlla insieme contenuto, permessi e funzioni aziendali.
Accesso obiettivi·Attività programmate Determinare l'ordine di conversione e i metodi per prevenire l'esecuzione duplicata. Le richieste degli utenti devono andare al server previsto e i compiti devono essere elaborati una sola volta.

Se un singolo dispositivo deve essere reinstallato, non è possibile mantenere contemporaneamente il server esistente, quindi è più importante avere backup esterni che abbiano completato i test di ripristino e i mezzi per tornare indietro prima della reinstallazione. Se possibile, esercitarsi prima su una nuova VM o su un server separato e determinare il tempo di inattività e i criteri di fallimento per la conversione effettiva.

Assicurarsi di ottenere l'elenco di configurazione richiesto dal server esistente

Sul server Rocky 9 esistente, prima indagare sullo stato dell'installazione e sulle dipendenze dei servizi. Di seguito è riportato un esempio di creazione di una nuova directory di indagine dalla shell dell'amministratore. Elenchi di account e configurazioni di rete possono contenere informazioni operative, quindi l'accesso dovrebbe essere limitato e non copiato direttamente nei log o nei post pubblici.

sudo -i
set -euo pipefail
umask 077
test ! -e /root/migration-inventory
mkdir /root/migration-inventory
cd /root/migration-inventory
cat /etc/rocky-release > release.txt
getent passwd > users.txt
getent group > groups.txt
rpm -qa --qf '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' | sort > packages.txt
dnf repolist --enabled > repositories.txt
dnf module list --enabled > modules.txt
systemctl list-unit-files --state=enabled > enabled-units.txt
ss -lntup > listening-ports.txt
ip -br address > addresses.txt
ip route > routes.txt
exit

Questa lista non è uno script di installazione da eseguire sul nuovo server così com'è. È un riferimento per selezionare gli elementi necessari per il servizio e per controllare i nomi, la disponibilità del supporto e i pacchetti alternativi in Rocky 10. Per i servizi su Rocky 9 che utilizzano flussi di moduli, è particolarmente necessario indagare sulla versione di esecuzione e non presumere che la scelta possa essere trasferita direttamente al comando del modulo in Rocky 10.

Per i servizi web e DB, oltre ai percorsi dei dati, controllare gli account DB e i metodi di dump, i file caricati, le API esterne, la posta, l'archiviazione, i certificati, le attività pianificate e le attività di backup. L'esecuzione delle stesse attività pianificate contemporaneamente sia sul nuovo che sul server esistente può comportare l'invio duplicato di posta o l'elaborazione duplicata dei dati. Le password operative e le chiavi segrete devono essere consegnate tramite procedure protette separate e non devono essere copiate inutilmente in file a scopo di confronto della configurazione.

Preparazione del nuovo server e ambito di applicazione

Installa Rocky Linux 10 sul nuovo server, esegui gli aggiornamenti, configura gli account di gestione, controlla l'accesso SSH e verifica prima le impostazioni di base del firewall e di SELinux. Se si tratta di un ambiente x86-64, verifica anche i requisiti della CPU per Rocky 10. Non dare per scontato che i requisiti della nuova versione siano soddisfatti solo perché il server esistente esegue Rocky 9.

Quando trasferisci un programma reale, invece di copiare l'ambiente virtuale Python o la directory dei moduli estesi compilati così come sono, lo ricrei sul nuovo server utilizzando il runtime e le dipendenze supportate lì. Per i formati di file DB e la compatibilità dei plugin, segui le procedure di migrazione per ciascuna versione del prodotto. Non mescolare le impostazioni predefinite e i file di sistema sovrascrivendo completamente /etc, /usr e /var sul nuovo server.

Il laboratorio sorgente ha spostato un piccolo servizio di sola lettura dallo spazio utente del container Rocky 9.8 a Python su una VM Rocky 10.2 . La versione di Python sorgente era 3.9.25 e la versione di Python di destinazione era 3.12.15. Entrambi gli ambienti condividevano il kernel dell'host Rocky 10, quindi il test non ha migrato un kernel Rocky 9, il processo di avvio o systemd. Un file di indirizzi locale ha simulato il cambio della destinazione delle connessioni (cutover) e il ritorno alla destinazione precedente (rollback) senza modificare un database di produzione o il DNS pubblico.

Eseguire l'esercizio come utente normale lfstudent e richiede Podman, Python, tar e curl. Nella VM del laboratorio, UID e GID dell’account lfstudent sono entrambi 1000. Costruire un'immagine separata dall'immagine ufficiale docker.io/library/rockylinux descritta nella guida Rocky Linux Podman . I servizi di produzione reali devono gestire separatamente i cicli di vita dei container e gli effetti del logout; qui, l'esercizio viene eseguito all'interno della stessa sessione di login dall'inizio alla fine.

Preparazione dello spazio utente su Rocky 9

Eseguire i comandi nella shell di una VM pratica dedicata Rocky 10 come utente normale, non sul server esistente. Usare un nuovo percorso e un nome immagine locale separato. Se si possiedono materiali di pratica esistenti, fermarsi e verificare prima lo stato salvato.

set -euo pipefail
umask 077
test ! -e "$HOME/lf-course31"
mkdir -m 700 "$HOME/lf-course31"
cd "$HOME/lf-course31"
if podman image exists localhost/lf-course31-source9-updated:20261112; then
  printf 'The local lab image tag already exists. Stop and inspect it.\n' >&2
  exit 1
else
  image_status=$?
  test "$image_status" -eq 1
fi
podman pull docker.io/library/rockylinux:9
base=$(podman image inspect docker.io/library/rockylinux:9 \
  --format '{{index .RepoDigests 0}}')
printf '%s\n' "$base" > base.ref
printf 'FROM %s\nRUN dnf -y upgrade && dnf -y install python3 tar && dnf clean all\n' \
  "$base" > Containerfile
podman build --tag localhost/lf-course31-source9-updated:20261112 \
  --file Containerfile .
podman run --rm localhost/lf-course31-source9-updated:20261112 \
  /bin/bash -lc 'cat /etc/rocky-release; python3 --version; uname -r'

Non presumere la versione effettiva solo guardando il tag. L'immagine basata su :9 ricevuta in pratica era etichettata 9.3, e dopo un aggiornamento completo della serie 9 all'interno dell'immagine sorgente, il laboratorio ha confermato 9.8 e Python 3.9.25. Questo aggiornamento è stato effettuato solo all'interno dell'immagine isolata. Registra il digest dell'immagine base in base.ref, notando che lo stesso tag potrebbe in seguito riferirsi a un'immagine diversa.

All'interno di un container, uname -r mostra il kernel dell'host Rocky 10. Conferma la versione dello spazio utente del sistema operativo utilizzando /etc/rocky-release o /etc/os-release, e distinguila dalla versione del kernel. Preparare l'immagine o la prima mappatura utente può richiedere tempo, quindi non creare ripetutamente container con lo stesso nome. Se interrotto, verifica prima lo stato effettivo utilizzando podman ps -a e podman inspect.

Creazione di un servizio originale in sola lettura e backup di migrazione

Quanto segue è un programma pratico completo che fornisce un file di configurazione JSON e un file di dati JSON contenente due elementi. /health rappresenta l'ambiente di esecuzione e /items restituisce i dati da trasferire. Funzioni di scrittura come POST non sono fornite, e la directory originale è collegata anche in sola lettura. In un servizio di scrittura reale, questa parte dovrebbe essere modificata in modalità di manutenzione e applicare una procedura finale di backup coerente.

SOURCE_LISTENERS=$(ss -H -lnt 'sport = :18031')
TARGET_LISTENERS=$(ss -H -lnt 'sport = :18032')
test -z "$SOURCE_LISTENERS"
test -z "$TARGET_LISTENERS"
mkdir -m 700 source target
mkdir -m 700 source/data
printf '{"site":"LF31 migration lab"}\n' > source/config.json
printf '[{"id":1,"name":"alpha"},{"id":2,"name":"beta"}]\n' > source/data/items.json
cat > source/app.py <<'PY'
import json, platform, sys
from pathlib import Path
from http.server import BaseHTTPRequestHandler, HTTPServer
root = Path(sys.argv[1])
class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        try:
            if self.path == '/health':
                release = dict(line.split('=', 1) for line in
                    Path('/etc/os-release').read_text().splitlines() if '=' in line)
                data = {'os': release['VERSION_ID'].strip('"'),
                        'python': platform.python_version()}
            elif self.path == '/items':
                config = json.loads((root/'config.json').read_text())
                data = {'site': config['site'],
                        'items': json.loads((root/'data/items.json').read_text())}
            else:
                self.send_error(404)
                return
            body = (json.dumps(data, sort_keys=True) + '\n').encode()
            self.send_response(200)
            content_type = 'application/json'
        except (OSError, ValueError, KeyError):
            body = b'Cannot read migration data\n'
            self.send_response(500)
            content_type = 'text/plain; charset=utf-8'
        self.send_header('Content-Type', content_type)
        self.end_headers()
        self.wfile.write(body)
HTTPServer((sys.argv[2], int(sys.argv[3])), Handler).serve_forever()
PY
chmod 640 source/app.py source/config.json source/data/items.json
uid=$(id -u)
gid=$(id -g)
source_id=$(podman run -d --init --name lf-course31-source --label lf.course=31 \
  --userns=keep-id --user "$uid:$gid" \
  -p 127.0.0.1:18031:8080 -v "$PWD/source:/work:ro,Z" \
  localhost/lf-course31-source9-updated:20261112 \
  python3 /work/app.py /work 0.0.0.0 8080)
printf '%s\n' "$source_id" > source-container.id
sleep 2
podman exec "$source_id" id
curl --fail --silent --max-time 10 http://127.0.0.1:18031/health
curl --fail --silent --max-time 10 http://127.0.0.1:18031/items > source-response.json

--userns=keep-id permette che l'ID numerico di un utente normale venga mantenuto anche all'interno del contenitore. :ro,Z connette l'originale in modalità di sola lettura e applica un'etichetta SELinux dedicata. Questa modifica dell'etichetta non viene applicata in modo esteso alle directory dati pubbliche. Se la risposta iniziale fallisce, vengono verificati podman inspect "$source_id" e podman logs "$source_id", e si controlla l'ID del contenitore registrato prima di riprendere. Il processo non procede al passaggio successivo senza verificare l'originale in esecuzione.

Se la risposta e l'originale sono confermati normali, viene creato un backup tramite percorso relativo all'interno del contenitore e copiato sull'host. Il backup include solo questo piccolo programma, le impostazioni e i dati.

podman exec "$source_id" tar --numeric-owner -cpf /tmp/lf31-migration.tar -C /work .
podman cp "$source_id":/tmp/lf31-migration.tar backup.tar
sha256sum backup.tar > backup.tar.sha256
sha256sum -c backup.tar.sha256
tar --numeric-owner -tvf backup.tar

Il checksum dovrebbe essere OK, e la lista dei file dovrebbe mostrare app.py, config.json e data/items.json. Il backup tar standard in questo esempio riguarda i contenuti dei file e i permessi di base. Se vuoi preservare ACL e attributi estesi, dovresti aggiungere controlli per quelle opzioni e attributi come nel tutorial sul backup e sulla verifica del ripristino di configurazioni e dati utente. In particolare, le etichette SELinux dedicate ai container non dovrebbero essere usate così come sono per la policy di deployment di un nuovo server.

Ripristino su Rocky 10 e confronto dei risultati di esecuzione

Dopo aver verificato nuovamente che lo target preparato sia vuoto, ripristina solo il backup che hai creato tu stesso. Poiché il ripristino viene effettuato con lo stesso account generale sullo stesso host, la mappatura numerica della proprietà in questo esempio è la stessa. Se si tratta di un server reale diverso, è necessario prima allineare UID e GID del nuovo account oppure pianificare le conversioni di proprietà necessarie.

TARGET_ENTRIES=$(find target -mindepth 1 -print -quit)
test -z "$TARGET_ENTRIES"
sha256sum -c backup.tar.sha256
tar -xpf backup.tar -C target
python3 - <<'PY'
from pathlib import Path
import hashlib, stat
source, target = Path('source'), Path('target')
for p in sorted(source.rglob('*')):
    if not p.is_file():
        continue
    q = target/p.relative_to(source)
    if p.read_bytes() != q.read_bytes():
        raise SystemExit('FAIL: content differs')
    if (p.stat().st_uid != q.stat().st_uid or
        p.stat().st_gid != q.stat().st_gid or
        stat.S_IMODE(p.stat().st_mode) != stat.S_IMODE(q.stat().st_mode)):
        raise SystemExit('FAIL: owner or mode differs')
    print(p.relative_to(source), hashlib.sha256(q.read_bytes()).hexdigest())
print('PASS: file content, numeric ownership and modes match')
PY
python3 target/app.py "$PWD/target" 127.0.0.1 18032 > target-service.log 2>&1 &
target_pid=$!
sleep 1
curl --fail --silent --max-time 10 http://127.0.0.1:18032/health
curl --fail --silent --max-time 10 http://127.0.0.1:18032/items > target-response.json
cmp source-response.json target-response.json

Se il contenuto e i permessi dei tre file sono gli stessi e cmp termina con stato 0 senza output, le risposte dei dati in questo esempio corrispondono. Sulla destinazione /health, il nuovo spazio utente e la versione di runtime sono apparsi come segue.

{"os": "10.2", "python": "3.12.15"}

/items La risposta dovrebbe includere sia alpha che beta e avere lo stesso valore site. Se la risposta è 500, controlla target-service.log, il percorso del file, la sintassi JSON e i permessi dell'account di esecuzione. Questo piccolo server serve per esercitarsi a verificare la funzionalità sul loopback e non viene utilizzato come server web di produzione esterno.

Il successo in un piccolo esempio non significa che tutte le dipendenze del servizio reale siano compatibili. In un ambiente di produzione, login, operazioni di visualizzazione/scrittura, caricamenti di file, set di caratteri del DB e fusi orari, attività pianificate, integrazioni esterne, certificati e operazioni di backup devono essere controllati per ciascun servizio. Se possibile, verificare che si ottengano gli stessi risultati anche dopo il riavvio del nuovo server e controllare agli indirizzi e percorsi dove gli utenti si connettono normalmente.

Testare la modifica del target di connessione e il rollback con gli stessi dati

In questo esercizio, client.url è un file di riferimento che memorizza l'indirizzo a cui inviare le richieste. Senza modificare il DNS pubblico o il traffico effettivo dell'utente, è possibile osservare la sequenza dall'ambiente esistente→nuovo ambiente→ambiente esistente→nuovo ambiente.

printf 'http://127.0.0.1:18031\n' > client.url
curl --fail --silent --max-time 10 "$(cat client.url)/health"
printf 'http://127.0.0.1:18032\n' > client.url
curl --fail --silent --max-time 10 "$(cat client.url)/health"
curl --fail --silent --max-time 10 "$(cat client.url)/items" | cmp - source-response.json
printf 'http://127.0.0.1:18031\n' > client.url
curl --fail --silent --max-time 10 "$(cat client.url)/health"
curl --fail --silent --max-time 10 "$(cat client.url)/items" | cmp - source-response.json
printf 'http://127.0.0.1:18032\n' > client.url
curl --fail --silent --max-time 10 "$(cat client.url)/items" | cmp - source-response.json

Il laboratorio di origine ha verificato l'origine 9.8/3.9.25, la destinazione 10.2/3.12.15, e poi nuovamente l'origine 9.8/3.9.25, e la risposta per ciascun dato era la stessa. Poiché l'originale era impostato come sola lettura e il nuovo ambiente non aveva funzionalità di scrittura, in questo esempio, il confronto poteva ripristinare solo l'obiettivo della connessione senza la necessità di unire nuovamente i dati.

Nel servizio di scrittura effettivo, i dati che entrano nel nuovo server dopo la transizione sono cruciali. Se cambi solo l'indirizzo senza riflettere questo nel server esistente, potresti perdere nuovi ordini, caricamenti, modifiche agli account, ecc. Prima della migrazione, imposta il tempo di sospensione della scrittura, il punto di sincronizzazione finale, le condizioni in cui è consentita la scrittura sul nuovo server e il metodo per recuperare i dati in caso di rollback. Verifica anche se è possibile un ripristino inverso tra diverse versioni del DB.

La transizione operativa modifica DNS, proxy/load balancer o impostazioni di connessione in base al metodo scelto. A causa della memorizzazione nella cache del DNS e delle connessioni esistenti, non tutti gli utenti passano al nuovo server contemporaneamente. Dopo la transizione, osservare i tassi di errore, i log e i controlli chiave del business, e non riprendere scritture o attività programmate ridondanti sul server esistente.

Ripulire il laboratorio e decidere quando ritirare il vecchio server

Terminare solo i due processi avviati nella pratica. target_pid e source_id di seguito sono obiettivi avviati direttamente nella sessione corrente. Se la sessione è stata disconnessa, controllare l'ID del container salvato e il processo/porta reale per confermare che sia lo stesso obiettivo prima della pulizia, e non terminare altri processi Python arbitrari.

kill "$target_pid"
wait "$target_pid" || test "$?" = 143
podman stop "$source_id"
podman inspect "$source_id" --format '{{.State.Status}} {{.State.ExitCode}}'
podman rm "$source_id"
ss -lnt 'sport = :18031'
ss -lnt 'sport = :18032'
sudo restorecon -RF "$HOME/lf-course31/source"
sha256sum -c backup.tar.sha256

--init posiziona un piccolo processo iniziale nel contenitore che è responsabile, tra le altre cose, della trasmissione dei segnali. In un controllo di terminazione separato applicato a questo, exited 143 è apparso senza un avviso di terminazione forzata, e in questo esercizio era uno stato di terminazione secondo SIGTERM. Controlla inoltre se entrambe le porte sono chiuse e se il checksum di backup è OK. Il ripristino del contesto SELinux si applica solo al percorso originale di questo esercizio che il contenitore ha finito di usare, mantenendo il contenuto e i permessi predefiniti.

Il server effettivamente esistente viene spento dopo che il nuovo server ha completato la verifica delle funzioni aziendali, dell'accesso operativo, del backup e del ripristino, e dei task pianificati, e dopo aver rispettato il periodo di osservazione stabilito e le condizioni di rollback. Prima dello spegnimento, vengono consegnati il luogo e il metodo per ripristinare l'ultimo backup, le differenze nella configurazione del nuovo server e gli elementi non ancora verificati. La conclusione della migrazione deve essere giudicata in base al comportamento dei servizi verificati e all'integrità dei dati, piuttosto che dalla data di installazione del nuovo server.