Tutorial do Debian 13 / Projeto prático: serviço HTTP persistente com segurança, backup e recuperação
Para verificar o funcionamento de um servidor Debian, você precisa checar não apenas se o serviço está em execução, mas também se ele lê e grava dados corretamente, e se novas gravações são mantidas após a restauração de dados corrompidos a partir de backups. Nesta prática abrangente, você irá implantar o serviço de contagem com uma conta dedicada e, sequencialmente, realizar backups normais, corrupção de dados limitada, detecção de erros HTTP e restauração real.
Definir o ambiente do laboratório e os critérios de sucesso
Use uma máquina virtual (VM) separada com Debian 13, Python 3.13 e systemd 257. Se Python 3, curl ou tar não estiverem disponíveis, prepare-os com sudo apt install python3 curl tar. Execute com uma conta administrativa que possua privilégios de sudo e não aplique em servidores que já estejam usando quaisquer dos caminhos especificados, a conta ou a porta 8086.
O serviço HTTP aceita solicitações apenas em 127.0.0.1:8086. GET / lê o valor atual, e POST /increment sem corpo incrementa o valor em um. Isto é para aprendizado local, não um produto operacional implementando autenticação, segurança externa por TLS (Transport Layer Security) ou escritas concorrentes por múltiplos processos. Também verifique o escopo da documentação do servidor HTTP Python.
| Passos | Critérios de Sucesso |
|---|---|
| Implantação e Escrita | Com uma conta dedicada: 0 → 1 → 2, e ainda 2 após a reinicialização do serviço |
| Backup Normal | Gerar arquivo e hash com o estado parado, restaurar diretórios vazios separados, comparar conteúdos e permissões |
| Detecção de Danos | Processos e portas são mantidos, mas ambos GET e POST retornam 503, arquivos corrompidos não são inicializados automaticamente |
| Operação após Restauração | Restaurar o valor 2 do backup verificado → escrever novo 3 → após reinicialização 3 → escrever novo 4 |
Os comandos abaixo são a sequência para executar uma nova prática uma vez. Verifique para evitar sobrescrever o mesmo backup e, se falhar no meio, verifique o estado e os logs, e então resolva primeiro a causa da etapa que falhou. Não execute o bloco inicial novamente para inicializar forçadamente valores normais.
Implantar o programa completo com uma conta dedicada
Antes da configuração, também confirme que getent group lf-capstone36 não encontra nenhum grupo existente. Pare em qualquer etapa de pré-requisito ou criação que falhar, em vez de reutilizar uma conta, diretório ou serviço existente. Certifique-se de que as solicitações curl de loopback contornem qualquer proxy configurado.
O programa e a unidade de serviço pertencem a root, e apenas o diretório de dados é gerenciado por uma conta dedicada. Dentro das restrições do sistema somente leitura da unidade, o caminho de dados é permitido para ReadWritePaths. Em métodos de armazenamento que criam arquivos temporários e substituem nomes, são necessárias permissões de escrita e execução (busca) no diretório pai, além das permissões aplicáveis ao arquivo.
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
As pequenas esperas na inicialização são atrasos, não garantias de prontidão. Se uma solicitação falhar, inspecione sudo systemctl status lf-capstone36.service e sudo journalctl -u lf-capstone36.service -n 30, depois use GET para verificar o valor atual. Não repita toda a configuração nem tente POST às cegas: uma gravação pode ter sido concluída mesmo se a resposta foi perdida. Se os.replace tiver sucesso e a sincronização do diretório com fsync falhar em seguida, o serviço também pode retornar 503 depois de alterar o valor. Leia o valor atual com GET antes de decidir por outro POST.
Se ele executar até o final do bloco sem erros, 0 → 1 → 2 e, após reiniciar o serviço, a manutenção de 2 é confirmada. A conta dedicada não pode modificar arquivos de código ou ler diretórios de backup somente para root, e a saída de restrição de execução mostra ProtectSystem=strict, NoNewPrivileges=yes, memória 128 MiB e 32 tarefas. Esses limites são para um pequeno exemplo e devem ser ajustados para coincidir com os valores medidos do serviço real.
O programa usa um analisador JSON (JavaScript Object Notation) para verificar a estrutura, o tipo inteiro e o intervalo dos valores lidos. Se encontrar um arquivo inválido, retorna 503 em vez de resetar para 0. Inicializar automaticamente para 0 poderia perder evidências para recuperar valores existentes e esconder erros como respostas normais.
Ao salvar, crie um arquivo temporário no mesmo diretório de dados usando NamedTemporaryFile, e após flush e fsync, substitua o nome por os.replace. O diretório também é sincronizado, mas este exercício não testou faltas de energia ou perda de cache de disco virtual. Não considere a substituição de nome atômica e a durabilidade contra falha de energia em todos os dispositivos de armazenamento como fornecendo a mesma garantia.
Este HTTPServer lida com requisições sequencialmente dentro de um processo de servidor. A sincronização para casos em que múltiplos processos modificam o mesmo arquivo ou ferramentas externas escrevem simultaneamente não está implementada. Além disso, requisições de incremento alteram o valor cada vez que são repetidas, então reenviar cegamente porque uma resposta foi perdida pode aumentá-lo duas vezes. Em operações reais, você deve considerar um método de armazenamento com manipulação de transações e requisições duplicadas.
O exercício original em uma VM Debian verificou o estado habilitado e o reinício do serviço usando systemctl. Como a inicialização automática após o reboot da VM não foi testada separadamente neste exercício abrangente, antes da entrega real, também execute um teste de inicialização garantindo meios de console e recuperação. O significado das configurações de conta, caminho e proteção pode ser verificado no manual do ambiente de execução systemd.
Fazer backup do serviço parado e testar a restauração em um diretório vazio
Pare o serviço e faça backup do contador enquanto seu valor for 2. Se enviar solicitações adicionais alterar o valor, verifique o motivo da mudança e defina o valor de referência pretendido. Não sobrescreva os dados com 2 se a verificação seguinte falhar.
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 é uma verificação de integridade do arquivo. Em seguida, compare os bytes dos programas e dados extraídos no teste de restauração vazio, assim como os identificadores de usuário (UID) e grupo (GID) e as permissões do arquivo de dados. Esta é uma verificação mais robusta do que apenas a existência do arquivo de backup, mas ainda não é uma restauração a partir de uma falha no caminho de serviço real. Esse processo é realizado separadamente abaixo.
O arquivo inclui apenas os programas, dados e unidades deste exercício. Como /var/backups está no mesmo disco, não é um backup independente contra perda total do disco. Para dados operacionais reais, também prepare uma cópia armazenada com armazenamento e direitos de acesso separados e verifique-a no intervalo de restauração designado. Você pode consultar as opções de tar no Manual do GNU tar Debian.
Corromper apenas os dados do laboratório e detectar erros HTTP
O bloco a seguir altera deliberadamente apenas o /var/lib/lf-capstone36/state.json que você acabou de criar para um estado semanticamente inválido: JSON válido com uma string onde um inteiro é necessário. Execute isso apenas após passar a verificação normal de backup e não substitua o caminho por arquivos operacionais. Não experimente encerrar processos ou preencher o disco.
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
Como count era uma string no JSON, tanto GET quanto POST devem retornar 503. curl -f falha na resposta de erro, então nesta seção, omitimos -f e salvamos separadamente o corpo e o código de status. Após a corrupção, re-comparamos o SHA-256 para garantir que a solicitação de gravação falhada não tenha inicializado os dados.
Na verificação original, o serviço estava ativo e a porta também estava em LISTEN, mas a requisição retornou 503. Restart=on-failure é uma política para quando um processo sai com falha, então não corrige automaticamente dados incorretos em um processo em execução. É por isso que precisamos verificar o processo, o socket, a resposta HTTP e o significado dos dados individualmente.
Restaurar os dados no caminho real e verificar novas gravações
Após parar o serviço, mantenha os arquivos corrompidos como evidência e restaure apenas um arquivo de dados do arquivo verificado para seu local original. Não substitua indiscriminadamente os programas normais e unidades de serviço. Como a restauração ocorre na mesma VM aqui, podemos comparar diretamente o UID e GID numéricos registrados anteriormente. Se estiver migrando para um servidor diferente, será necessário redefini-los com base na conta de destino, como em migração de serviço e mapeamento de propriedade.
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
O hash do estado armazenado descreve o valor de backup 2. Compare-o imediatamente após a restauração, antes do próximo POST. Incrementos bem-sucedidos para 3 e 4 alteram deliberadamente o arquivo e seu hash; registre o novo valor esperado em vez de tratar toda diferença de hash posterior como corrupção.
O resultado esperado é OK para o arquivo e o hash de dados, e lf-capstone36:lf-capstone36:600. Após ler o valor restaurado 2, registre 3 via POST, reinicie o processo, leia 3 novamente e verifique a escrita mais uma vez para obter 4. Diferencie o fato de que o arquivo foi extraído do fato de que operações de leitura/escrita são possíveis após a restauração.
Interpretar falhas das verificações antes de fazer alterações
| Sintomas | Pontos a verificar primeiro |
|---|---|
| Falha ao iniciar o serviço | Verifique o arquivo executável, usuário, erros de caminho no journalctl, e o resultado de systemd-analyze verify. |
| Processo ativo, sem porta | Verifique o MainPID, os argumentos de execução, o endereço de ligação, portas duplicadas e os logs logo após o início. |
| GET retorna 503 | Verifique a existência do arquivo, permissões de leitura, sintaxe JSON e tipos inteiros, e preserve arquivos corrompidos primeiro. |
| Leitura bem-sucedida, escrita 503 | Verifique as permissões do diretório de dados, ReadWritePaths, espaço restante, inode e condições de substituição de arquivos. |
| Valores mudam após reinício | Verifique o caminho de dados real, montagem, se a gravação foi bem-sucedida e outros processos de escrita. |
Se a restauração estiver completa, registre no diário de trabalho o status do serviço, portas, respostas, hashes de dados e valores normais alterados após a restauração. Se houver transações ou uploads normais após o ponto de restauração, restaurar o backup antigo sobre os dados atuais pode fazer com que essas alterações mais recentes sejam perdidas, então decida primeiro sobre interromper gravações, preservação separada e métodos de reaplicação.
Limpar o serviço do laboratório e conservar seu backup
O bloco abaixo apenas limpa serviços, códigos, dados e contas criados recentemente neste artigo. Mantenha backups e evidências de danos em um diretório de acesso apenas para root para comparação. Ao deletar cópias após o período de retenção, selecione os arquivos exatos e não exclua backups de outros serviços junto.
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




