Tutorial do Rocky Linux 10 / Prática Rocky Linux 10: implantar, proteger e restaurar um serviço

A prática abrangente na operação de servidores Rocky Linux 10 não termina apenas ao iniciar um serviço. É necessário executá-lo com uma conta que tenha apenas as permissões necessárias, fazer backup dos dados normais, detectar e restaurar corrupção intencional e verificar se os dados persistem após reiniciar o serviço. Este tutorial integra essas etapas por meio de um serviço de contador local.

Objetivos de Prática e Escopo de Preparação Segura

O serviço lê o valor atual com uma solicitação GET /counter e o incrementa em 1 com uma solicitação POST /counter. O valor não é mantido apenas na memória, mas também armazenado em um arquivo de estado separado. O objetivo é fazer backup do valor normal 2, danificar os dados intencionalmente, restaurar 2 do backup, incrementá-lo novamente para 3 e verificar se ele persiste após a reinicialização do serviço.

Isto é realizado em uma VM dedicada com Rocky Linux 10. O ambiente de laboratório de origem era Rocky 10.2, systemd 257, Python 3.12.15, GNU tar 1.35, com SELinux em modo Enforcing. O servidor HTTP padrão do Python é para prática local, e a documentação oficial do servidor HTTP do Python não recomenda seu uso em produção. Este exemplo, sem autenticação e TLS, não está exposto a serviços externos.

Abaixo está o processo no shell do administrador para verificar conflitos com novas contas, caminhos e portas. Se itens existentes forem encontrados, não os apague ou reutilize, e pare. O set -e no shell garante que ele não continue após falhas inesperadas, e um if separado é usado para verificações onde a falha é esperada.

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

Os pacotes necessários e os comandos curl devem ser preparados. O acesso de administrador existente e os firewalls são mantidos, e nenhum encaminhamento de porta adicional ou abertura de firewall externo é feito. Todos /etc/lf-course32, /srv/lf-course32, /var/lib/lf-course32 e caminhos de backup usados daqui para frente são dedicados a esta prática.

Separe a conta de serviço, configuração e estado

Crie uma conta de sistema sem login lfcourse32 para que o serviço não seja executado sob a conta de administrador ou uma conta pessoal de login. Mesmo que o shell de login seja nologin, o systemd pode executar programas sob esta conta. O administrador possui as configurações e programas, enquanto o serviço os lê e grava seus dados de trabalho somente no diretório de estado.

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

O bloco a seguir contém o programa completo. Para salvar o estado, o próprio programa grava primeiro em um arquivo temporário no mesmo diretório, sincroniza-o e substitui o arquivo final por renomeação. Isso reduz a exposição de conteúdo parcialmente escrito neste exercício com um único processo; não garante transações de banco de dados, segurança para múltiplos escritores nem recuperação em todas as situações de queda de energia.

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 o arquivo de estado não existir desde o início, crie 0. Se o conteúdo de um arquivo existente estiver incorreto, retorne 503 em resposta à solicitação e não inicialize arbitrariamente. Esta configuração é para notificar o administrador de que a recuperação é necessária em vez de substituir silenciosamente dados corrompidos por novos dados durante uma falha.

No entanto, neste exemplo, a ausência de um arquivo é tratada como criação inicial, então se o arquivo for excluído e reiniciado, 0 pode ser criado. Na operação real, a primeira inicialização e a inicialização normal devem ser distinguidas, e arquivos de estado existentes ausentes devem ser tratados como um erro que requer recuperação, em vez de inicialização automática. As falhas neste exercício estão limitadas a conteúdo incorreto, não à exclusão de arquivos.

Executar como um serviço systemd restrito

O seguinte arquivo de unidade define a conta de execução, o escopo de acesso aos arquivos e o gerenciamento do diretório de estado juntos. StateDirectory=lf-course32 cria o /var/lib/lf-course32 para o serviço do sistema e prepara a propriedade de acordo com a conta de execução. Portanto, o programa não precisa escrever dados no diretório 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
Configuração Funções e Escopo
Usuário·Grupo Executa sob uma conta dedicada. Na VM de prática, UID·GID 994 é atribuído, e pode diferir em outros servidores.
NoNewPrivileges Restringe os caminhos pelos quais o programa executado pode obter privilégios adicionais.
CapabilityBoundingSet= Deixa vazio o escopo de permissão de serviço das capacidades do Linux, que dividem os privilégios de administrador por função.
ProtectSystem=strict Torna a maior parte do sistema de arquivos somente leitura. Exceções para diretórios graváveis, como diretórios de estado, devem ser revisadas.
StateDirectory·PrivateTmp StateDirectory fornece dados persistentes do serviço; PrivateTmp fornece diretórios temporários privados. Revise essas exceções graváveis junto com ProtectSystem=strict.
ProtectHome Impede que o serviço acesse diretórios pessoais de usuários, diretórios administrativos, etc.
RestrictAddressFamilies Limita as famílias de endereços de soquete que podem ser usadas. Isso não é uma configuração de firewall que restringe IPs de destino ou acesso à internet em si.

Aplicar restrições que não se encaixam na função de uma só vez pode causar falhas nos serviços normais. Verifique cada opção em relação ao guia de reforço de segurança do systemd do Rocky Linux e às configurações de execução do systemd 257 para a versão instalada. Esta configuração, por si só, não elimina todos os ataques ou riscos operacionais.

Verifique o estado do processo e as solicitações reais separadamente

O início bem-sucedido do Type=exec significa que o programa foi iniciado com sucesso, mas não significa que ele esteja pronto para lidar com solicitações HTTP. Durante a primeira prática, a conexão às vezes foi recusada porque a solicitação era muito rápida imediatamente após o início. Como mostrado abaixo, esperamos pela prontidão limitada às solicitações de leitura e verificamos valores normais.

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

O primeiro valor lido deve ser 0, e o valor após incrementar duas vezes deve ser 1 e 2, respectivamente. No laboratório de origem, o UID·GID do processo era 994, o valor da capacidade efetiva era 0, e NoNewPrivs era 1. O proprietário do arquivo de estado era lfcourse32, e as permissões eram 600. O resultado mostra que verificamos a resposta juntamente com o arquivo real para confirmar que o novo valor foi armazenado.

As tentativas de reenvio para aguardar a prontidão foram aplicadas apenas às solicitações de leitura. Solicitações POST que alteram valores podem ser aplicadas duas vezes se forem repetidas sem receber uma resposta. Nesses casos, verifique primeiro o valor atual para confirmar o resultado. Se a conexão ainda falhar, verifique systemctl status lf-course32.service, journalctl -u lf-course32.service, e a configuração e as permissões do arquivo.

Faça backup do serviço em funcionamento em um estado consistente

Após parar o serviço de escrita, faça backup do programa, configuração, estado e arquivos de unidade juntos. Neste programa, apenas um processo realiza a escrita, portanto, parar o serviço é o ponto de parada da escrita. Para serviços usados por vários servidores ou bancos de dados juntos, um método separado para backup consistente desse produto deve ser definido.

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

O checksum é OK, e apenas os caminhos de prática esperados devem estar na lista. O backup contém o valor correto 2. application.sha256 é usado para verificar se configurações e programas foram alterados durante corrupção de dados ou recuperação, e counter-before.sha256 é usado para confirmar que o arquivo de estado voltou exatamente igual ao ponto de backup.

Este backup é colocado na mesma VM para praticar o fluxo de recuperação. Backups operacionais reais são preservados em locais separados, considerando falha total do disco/servidor e permissões de exclusão originais. Apenas ter um checksum não prova a origem do backup nem a consistência dos dados operacionais. Métodos para verificar atributos de arquivos e restaurar para caminhos separados são abordados em detalhes no curso backup de configurações e dados do usuário com verificação de restauração .

Crie corrupção de dados e a diferencie do estado normal.

Reinicie o serviço e primeiro leia o valor 2 normalmente. Em seguida, altere apenas este arquivo de estado específico da prática para um conteúdo incorreto. Não altere dados operacionais reais ou outros arquivos do serviço.

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

A resposta esperada é HTTP 503 e o seguinte JSON.

{"error":"Counter data unavailable"}

Neste momento, systemctl is-active ainda estava active. O programa não terminou porque os dados para processar a requisição estavam incorretos. Restart=on-failure é uma configuração de reinício para falha de terminação e não restaura automaticamente os dados de trabalho corrompidos para um backup normal. É por isso que verificações no processo, porta, resposta HTTP e dados são todas necessárias.

Os logs permitem comparação de respostas 200 e 503 para a mesma requisição de caminho. Em falhas reais, o tempo de modificação, a última resposta normal, a propriedade, permissões e formato dos dados são examinados juntos. Os dados não são inicializados antes de confirmar se a causa da não leitura é um problema de permissões ou conteúdo incorreto.

Preservar a cópia corrompida e restaurar o estado normal

Pare o serviço para evitar gravações durante a restauração e mantenha os dados corrompidos com um nome separado. Extraia apenas o arquivo de estado do contador dedicado do backup confiável criado neste laboratório . Não adicione outros caminhos nem extraia um arquivo não verificado com privilégios de administrador.

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

O checksum do arquivo de estado deve ser OK , o proprietário deve ser lfcourse32 , as permissões devem ser 600, e o valor de resposta deve retornar 2. Distinga e verifique entre o resultado de simplesmente reiniciar o serviço e o resultado de realmente restaurar um backup normal.

Após a restauração, incremente o valor uma vez para verificar se as gravações funcionam, depois reinicie o serviço e leia-o novamente.

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

Imediatamente após o aumento e após a reinicialização, {"count": 3} apareceu, e os checksums do programa, das configurações e dos arquivos da unidade permaneceram inalterados. Este resultado confirma a persistência dos arquivos após a reinicialização do serviço e não reflete os resultados do teste de inicialização automática da VM para novas contas/serviços ou recuperação de queda de energia neste exercício abrangente.

Registre o escopo verificado e as informações de entrega

Esta prática iniciou o serviço manualmente sem ativar a inicialização automática. Após a verificação ser concluída, pare-o e verifique o estado inativo e as portas fechadas. Mantenha a conta dedicada sem login, o programa, a configuração, o estado e o backup para revisão e futuros exercícios de restauração. Outras contas ou serviços existentes não estão sujeitos à limpeza.

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

Na VM de origem, a unidade terminou com disabled e não havia listener na porta 18040. O acesso administrativo e o firewall foram mantidos, e o SELinux estava em modo Enforcing. As verificações da fonte encontraram o fstab original, o perfil de rede e o firewall inalterados. As entradas de contas e grupos existentes foram preservadas, enquanto a conta e o grupo de serviço dedicado foram adicionados.

Para a transferência operacional, deixe os conteúdos e o escopo realmente verificados conforme abaixo.

  • Arquivo executável, configuração, caminho do estado, conta de execução, nome do serviço, endereço de recebimento e porta
  • Como verificar solicitações normais, resultados reais da gravação de dados e prontidão para inicialização
  • Localização, checksum, ponto no tempo do backup utilizado e a sequência para parar serviços
  • Preservação de dados danificados, restauração, verificação de funcionalidade após retomada e métodos de resposta em caso de falha
  • Condições como conexões externas não verificadas, reinicialização, múltiplas gravações, quedas de energia e pessoal adicional para confirmação

Os procedimentos operacionais podem ser usados apenas se os serviços estiverem funcionando, os privilégios de execução forem restritos, os backups forem recuperáveis e a verificação real da funcionalidade estiver conectada. Registrar o status de sucesso de cada etapa separadamente permite avaliar com precisão cenários como 'em execução, mas a solicitação falha' ou 'arquivo restaurado, mas a gravação não funciona'.