Rocky Linux 10: tutorial / Migrar servicios de Rocky Linux 9 a 10 con instalación nueva

Al pasar de Rocky Linux 9 a 10, se prepara instalando un nuevo servidor Rocky Linux 10 y migrando las configuraciones y datos necesarios. El proyecto Rocky Linux no admite oficialmente las actualizaciones en el lugar entre diferentes versiones principales. Al validar el nuevo entorno mientras se mantiene el servidor existente, es más fácil encontrar problemas antes de realizar el cambio y definir las condiciones de reversión.

Distinguir actualizaciones menores de una migración de Rocky 9 a 10

Actualizar a la última versión menor dentro de 9.x y cambiar la versión mayor de 9 a 10 son tareas diferentes. El documento oficial de migración de versiones de Rocky Linux guía a través de un flujo de instalación nueva, preparando las cuentas necesarias, repositorios, paquetes y restaurando respaldos. Simplemente cambiar los números en las direcciones de los repositorios o usar dnf --releasever=10 no se considera un método estándar de migración oficial.

El propósito de preparar un nuevo servidor no es replicar el sistema existente en su totalidad. Se trata de adaptar los datos y configuraciones requeridos por el servicio sobre las configuraciones predeterminadas y políticas de seguridad del nuevo sistema operativo. Simplemente mover el kernel, las bibliotecas y los RPM del servidor antiguo al nuevo servidor puede conducir a dependencias desajustadas y alcance de soporte inadecuado.

Destino de la Migración Tareas en el Nuevo Servidor Criterios de Verificación
Cuentas de Usuario y de Servicio Cree las cuentas necesarias y defina el UID y GID correspondientes. Las cuentas previstas deben poder leer y escribir los datos migrados.
Paquetes y Entorno de Ejecución Instale las versiones requeridas desde el repositorio de Rocky 10. Los programas y módulos de extensión deben funcionar en el nuevo entorno de ejecución.
Configuración Reaplique los cambios necesarios basándose en los nuevos archivos predeterminados. Las comprobaciones de configuración y el inicio del servicio deben tener éxito.
Archivos·Datos de DB Restaure copias de seguridad consistentes en una ruta separada. Verifique el contenido, los permisos y las funciones empresariales juntos.
Objetivos de acceso·Tareas programadas Determine el orden de conversión y los métodos para prevenir la ejecución duplicada. Las solicitudes del usuario deben ir al servidor previsto, y las tareas deben procesarse solo una vez.

Si es necesario reinstalar un solo dispositivo, no se puede mantener el servidor existente al mismo tiempo, por lo que es más importante tener copias de seguridad externas que hayan completado pruebas de restauración y medios para regresar antes de la reinstalación. Si es posible, practique primero en una nueva VM o en un servidor separado, y determine el tiempo de inactividad y los criterios de fallo para la conversión real.

Asegure la lista de configuración requerida del servidor existente

En el servidor Rocky 9 existente, primero investigue el estado de la instalación y las dependencias del servicio. Lo siguiente es un ejemplo de cómo crear un nuevo directorio de investigación desde el shell del administrador. Las listas de cuentas y la configuración de la red pueden contener información operativa, por lo que el acceso debe ser restringido y no se deben copiar directamente a registros o publicaciones públicas.

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

Esta lista no es un script de instalación para ejecutar tal cual en el nuevo servidor. Es una referencia para seleccionar los elementos requeridos por el servicio y para verificar los nombres, la disponibilidad de soporte y los paquetes alternativos en Rocky 10. Para los servicios en Rocky 9 que utilizan flujos de módulos, es particularmente necesario investigar la versión de ejecución y no asumir que la elección se puede transferir directamente al comando de módulo en Rocky 10.

Para los servicios web y de base de datos, además de las rutas de datos, verifique las cuentas de la base de datos y los métodos de volcado, archivos subidos, API externas, correo, almacenamiento, certificados, tareas programadas y tareas de respaldo. Ejecutar las mismas tareas programadas en ambos servidores, nuevo y existente, simultáneamente puede resultar en el envío duplicado de correos o en el procesamiento duplicado de datos. Las contraseñas operativas y las claves secretas deben entregarse mediante procedimientos protegidos separados y no deben copiarse innecesariamente en archivos para comparación de configuración.

Preparación del nuevo servidor y alcance de la práctica

Instale Rocky Linux 10 en el nuevo servidor, realice las actualizaciones, configure las cuentas de gestión, verifique el acceso SSH y primero verifique la configuración básica del firewall y SELinux. Si es un entorno x86-64, también verifique los requisitos de CPU para Rocky 10. No suponga que se cumplen los requisitos de la nueva versión solo porque el servidor existente esté ejecutando Rocky 9.

Al transferir un programa real, en lugar de copiar el entorno virtual de Python o el directorio de módulos de extensión compilados tal cual, recréelo en el nuevo servidor utilizando el runtime y las dependencias compatibles allí. Para los formatos de archivos de base de datos y la compatibilidad de plugins, siga los procedimientos de migración para cada versión del producto. No mezcle configuraciones predeterminadas y archivos del sistema sobrescribiendo completamente /etc, /usr y /var en el nuevo servidor.

El laboratorio de origen trasladó un pequeño servicio de solo lectura del espacio de usuario del contenedor Rocky 9.8 a Python en una VM Rocky 10.2 . Python de origen era 3.9.25 y Python de destino era 3.12.15. Ambos entornos compartían el kernel del host Rocky 10, por lo que la prueba no migró un kernel Rocky 9, proceso de arranque ni systemd. Un archivo de direcciones local simuló el cambio y la reversión sin modificar una base de datos de producción ni DNS público.

Ejecute el ejercicio como usuario regular lfstudent y requiere Podman, Python, tar y curl. El UID y el GID de esta cuenta de práctica eran 1000; esto no describe todas las cuentas de la VM. Construya una imagen separada a partir de la imagen oficial docker.io/library/rockylinux descrita en la guía de Podman de Rocky Linux . Los servicios de producción reales deben gestionar el ciclo de vida de los contenedores y los efectos del cierre de sesión por separado; aquí, el ejercicio se realiza dentro de la misma sesión de inicio de sesión de principio a fin.

Preparando el espacio de usuario en Rocky 9

Ejecute los comandos en la terminal de una VM de práctica dedicada de Rocky 10 como usuario regular, no en el servidor existente. Use una ruta nueva y un nombre de imagen local separado. Si tiene materiales de práctica existentes, deténgase y primero verifique el estado guardado.

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'

No asuma la versión real solo por mirar la etiqueta. La imagen basada en :9 recibida en la práctica estaba etiquetada como 9.3, y después de una actualización completa de la serie 9 dentro de la imagen fuente, el laboratorio confirmó 9.8 y Python 3.9.25. Esta actualización se realizó únicamente dentro de la imagen aislada. Registre el digest de la imagen base en base.ref , observando que la misma etiqueta más adelante puede referirse a una imagen diferente.

Dentro de un contenedor, uname -r muestra el kernel del host Rocky 10. Confirme la versión del espacio de usuario del sistema operativo usando /etc/rocky-release o /etc/os-release , y distíngala de la versión del kernel. Preparar la imagen o el primer mapeo de usuario puede tomar tiempo, así que no cree repetidamente contenedores con el mismo nombre. Si se interrumpe, primero revise el estado real usando podman ps -a y podman inspect .

Creando un servicio original de solo lectura y una copia de seguridad de migración

El siguiente programa completo utiliza un archivo JSON de configuración y un archivo JSON de datos que contiene dos elementos. /health representa el entorno de ejecución, y /items devuelve los datos que se transferirán. No se proporcionan funciones de escritura como POST, y el directorio original también está conectado como solo lectura. En un servicio de escritura real, esta parte debería cambiarse a modo de mantenimiento y a un procedimiento final de copia de seguridad consistente.

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 permite que se mantenga la ID numérica de un usuario regular incluso dentro del contenedor. :ro,Z conecta el original en modo de solo lectura y aplica una etiqueta SELinux dedicada. Este cambio de etiqueta no se aplica ampliamente a los directorios de datos públicos. Si la respuesta inicial falla, se verifican podman inspect "$source_id" y podman logs "$source_id", y se confirma la ID del contenedor registrada antes de continuar. El proceso no avanza al siguiente paso sin verificar el original en ejecución.

Si se confirma que la respuesta y el original son normales, se crea una copia de seguridad de ruta relativa dentro del contenedor y se copia al host. La copia de seguridad incluye solo este pequeño programa, la configuración y los datos.

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

La suma de verificación debería ser OK, y la lista de archivos debería mostrar app.py, config.json y data/items.json. La copia de seguridad estándar con tar en este ejemplo apunta al contenido de los archivos y permisos básicos. Si desea preservar ACLs y atributos extendidos, debería agregar verificaciones para esas opciones y atributos, como el tutorial sobre respaldo y verificación real de restauración para configuraciones y datos de usuario . En particular, las etiquetas SELinux dedicadas a contenedores no deben usarse tal cual para la política de despliegue de un nuevo servidor.

Restaurando en Rocky 10 y comparando los resultados de ejecución

Después de verificar nuevamente que el target preparado está vacío, restaure únicamente la copia de seguridad que usted mismo creó. Dado que la restauración se realiza con la misma cuenta general en el mismo host, la asignación numérica de propiedad en este ejemplo es la misma. Si se trata de un servidor real diferente, primero debe alinear el UID y GID de la nueva cuenta o planear las conversiones de propiedad necesarias.

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

Si los contenidos y permisos de los tres archivos son los mismos y cmp finaliza con estado 0 sin salida, las respuestas de datos en este ejemplo coinciden. En el destino /health, el nuevo espacio de usuario y la versión de tiempo de ejecución aparecieron de la siguiente manera.

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

/items La respuesta debe incluir tanto alpha como beta y tener el mismo valor site. Si la respuesta es 500, verifique target-service.log, la ruta del archivo, la sintaxis JSON y los permisos de la cuenta de ejecución. Este pequeño servidor es para práctica para verificar la funcionalidad en el loopback y no se usa como un servidor web de producción externo.

El éxito en un ejemplo pequeño no significa que todas las dependencias del servicio real sean compatibles. En un entorno de producción, se deben verificar el inicio de sesión, las operaciones de visualización/escritura, la carga de archivos, los conjuntos de caracteres de la base de datos y las zonas horarias, las tareas programadas, las integraciones externas, los certificados y las operaciones de respaldo para cada servicio. Si es posible, verifique que los mismos resultados ocurran incluso después de reiniciar el nuevo servidor, y revise en las direcciones y rutas donde los usuarios normalmente se conectan.

Pruebe cambiar el objetivo de la conexión y revertir con los mismos datos

En este ejercicio, client.url es un archivo estándar que almacena la dirección a la que se deben enviar las solicitudes. Sin cambiar el DNS público ni el tráfico real de los usuarios, puede observar la secuencia del entorno existente→nuevo entorno→entorno existente→nuevo entorno.

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

El laboratorio de origen verificó el origen 9.8/3.9.25, destino 10.2/3.12.15, y luego el origen 9.8/3.9.25 nuevamente, y la respuesta para cada dato fue la misma. Dado que el original estaba fijado como solo lectura y el nuevo entorno no tenía funcionalidad de escritura, en este ejemplo, la comparación podría revertir únicamente el objetivo de la conexión sin necesidad de fusionar los datos de nuevo.

En el servicio de escritura actual, los datos que ingresan al nuevo servidor después de la transición son cruciales. Si solo revierte la dirección sin incorporar estos datos al servidor anterior, podría perder nuevos pedidos, cargas, cambios de cuenta, etc. Antes de la migración, establezca el tiempo de suspensión de escritura, el punto de sincronización final, las condiciones bajo las cuales se permite escribir en el nuevo servidor y el método para recuperar datos en caso de retroceso. Verifique también si la restauración inversa es posible entre diferentes versiones de la base de datos.

La transición operativa cambia la configuración de DNS, proxy/balanceador de carga o conexión según el método elegido. Debido al almacenamiento en caché de DNS y a las conexiones existentes, no todos los usuarios se trasladan al nuevo servidor simultáneamente. Después de la transición, observe las tasas de error, los registros y las verificaciones clave del negocio, y no reanude escrituras ni tareas programadas de manera redundante en el servidor existente.

Limpie el laboratorio y decida cuándo retirar el servidor antiguo.

Solo termine los dos procesos iniciados en la práctica. target_pid y source_id a continuación son objetivos iniciados directamente en la sesión actual. Si la sesión se ha desconectado, verifique el ID del contenedor guardado y el proceso/puerto real para confirmar que es el mismo objetivo antes de limpiar, y no termine ningún otro proceso de Python arbitrario.

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 coloca un pequeño proceso inicial en el contenedor que es responsable de la transmisión de señales, entre otras cosas. En una verificación de terminación separada aplicada a esto, exited 143 apareció sin una advertencia de terminación forzada, y en este ejercicio, era un estado de terminación según SIGTERM. Verifique también si ambos puertos están cerrados y si la suma de verificación de respaldo es OK. La restauración del contexto de SELinux solo se aplica a la ruta original de este ejercicio que el contenedor ha terminado de usar, mientras se conserva el contenido y los permisos predeterminados.

El servidor existente se apaga después de que el nuevo servidor haya completado la verificación de las funciones del negocio, el acceso operativo, la copia de seguridad y restauración, y las tareas programadas, y después de cumplir con el período de observación establecido y las condiciones de reversión. Antes del apagado, se entregan la ubicación y el método para restaurar la última copia de seguridad, las diferencias en la configuración del nuevo servidor y los elementos que aún no se han verificado. Se juzga la finalización de la migración por el comportamiento del servicio verificado y la integridad de los datos, en lugar de por la fecha de instalación del nuevo servidor.