Durante muito tempo, minha rotina de patching era: entrar via SSH numa VM, rodar apt upgrade, dar uma olhada na saída e seguir em frente. Funcionou até não funcionar, e a única vez que não funcionou foi numa atualização de kernel em uma VM que por acaso rodava DNS. Ninguém lá em casa se importa com a versão do meu kernel. Eles se importam que o Wi-Fi "parou de funcionar."
Este post cobre o playbook que estou montando para substituir essa rotina. Os objetivos são modestos. Tirar um snapshot antes de mexer em qualquer coisa. Atualizar um host por vez. Reiniciar só quando necessário. Verificar se o host voltou antes de passar para o próximo. Não uso isso há muito tempo, então trate como um rascunho funcional. Vou sinalizar as partes sobre as quais tenho dúvida.
Se você quiser ver a versão manual uma vez antes de automatizar, o lab Install Debian termina atualizando a lista de pacotes e instalando as atualizações pendentes.
Você vai praticar a aplicação de atualizações à mão em um servidor novo, que é exatamente o passo que este playbook repete.
Por que não usar só unattended-upgrades
O unattended-upgrades é uma ótima escolha, e eu ainda o uso para atualizações de segurança em algumas VMs. Minha hesitação é quanto à ordem e à visibilidade. Eles aplicam patches sempre que o timer dispara, não sabem qual VM é o meu resolver, e uma execução que falhou passa despercebida com facilidade. Um playbook roda quando eu o executo, na ordem que eu escolho, e me conta o que aconteceu.
O trade-off é óbvio: um playbook só aplica patches quando eu me lembro de rodá-lo. Essa é a mesma fraqueza da qual estou tentando escapar. Minha inclinação atual é usar os dois. Atualizações de segurança automáticas como base, e o playbook para upgrades completos em um cronograma que eu controlo. Não tenho certeza de que essa seja a divisão certa.
O inventário
O inventário carrega uma variável extra por host, o ID da VM no Proxmox, para que o playbook saiba qual snapshot tirar.
all:
children:
lab_vms:
hosts:
dns1:
vmid: 110
docker1:
vmid: 120
git1:
vmid: 130
devvm:
vmid: 140
A ordem dos hosts importa aqui. Com serial: 1, o Ansible percorre os hosts na ordem do inventário, então coloquei as VMs menos críticas primeiro. Se algo quebrar, quebra na VM de desenvolvimento e não naquela da qual a família depende.
O playbook
Aqui vai uma versão enxuta.
- name: Patch lab VMs
hosts: lab_vms
serial: 1
become: true
tasks:
- name: Snapshot the VM before patching
ansible.builtin.command: >
qm snapshot {{ vmid }}
pre_patch_{{ ansible_date_time.date | replace('-', '_') }}
delegate_to: pve1
changed_when: true
- name: Upgrade packages
ansible.builtin.apt:
update_cache: true
cache_valid_time: 3600
upgrade: dist
- name: Check whether a reboot is pending
ansible.builtin.stat:
path: /var/run/reboot-required
register: reboot_flag
- name: Reboot if needed
ansible.builtin.reboot:
reboot_timeout: 600
when: reboot_flag.stat.exists
- name: Confirm the host is healthy
ansible.builtin.command: systemctl is-system-running --wait
register: sysstate
changed_when: false
failed_when: sysstate.stdout not in ['running']
Algumas notas sobre por que cada peça está ali.
Snapshot primeiro, delegado ao node
A task de snapshot roda no node do Proxmox, não na VM, que é o que delegate_to: pve1 faz. Usei o comando simples qm snapshot para que o passo seja fácil de ler e de rodar à mão. Existe um módulo de snapshot do Proxmox na collection community.general, mas eu não o usei, então não vou garantir nada sobre ele.
A parte em que tenho dúvida: o usuário SSH do node precisa de permissão para rodar qm, e ainda não decidi se um usuário dedicado para automação é melhor do que root com chave. Além disso, become: true também vale para a task delegada, então confira se ela faz o que você espera no seu node.
Um snapshot é um ponto de rollback, não um backup. Ele fica no mesmo storage da VM. Ele também cresce conforme o disco muda, então não deixe snapshots antigos por aí. Eu os apago à mão depois de alguns dias sem nada quebrar. Automatizar essa limpeza está na minha lista.
A verificação de reboot
O Ubuntu cria /var/run/reboot-required depois de certas atualizações. O Debian puro não faz isso por padrão, até onde sei. Em hosts Debian, a verificação com stat vai dizer silenciosamente "não precisa reiniciar" para sempre, mesmo depois de uma atualização de kernel. Prefiro admitir isso a fingir que a verificação é universal. Para as VMs Debian, estou considerando reiniciar sempre, sem condição, ou comparar o kernel em execução com o mais novo instalado. Ainda não implementei nenhuma das duas.
O health check
systemctl is-system-running --wait espera o boot terminar e informa running se todas as units estiverem bem. Informa degraded se alguma unit falhou. É uma verificação grosseira, já que uma única unit de timer quebrada faz tudo falhar. Para mim isso é aceitável: uma unit com falha depois do patching é algo que eu quero olhar de qualquer jeito. Se ficar barulhento demais, troque por uma verificação que mire no serviço, como acessar uma URL de health com o módulo uri.
O que interrompe a execução
Minha leitura da documentação é que, quando um host falha em um lote serial, o Ansible aborta os lotes restantes por padrão, porque a taxa de falha excede o max_fail_percentage padrão, que é zero. Esse é o comportamento que eu quero. Se o docker1 não voltar, o playbook não deve seguir para o git1. Testei isso uma vez fazendo uma task falhar de propósito no primeiro host, e os hosts seguintes foram pulados. Um teste não é prova, então vou continuar observando.
Coisas que deliberadamente ainda não automatizo
- Atualizações de imagens de container. As stacks do Compose têm seu próprio caminho de atualização, e eu fixo as tags das imagens. Misturar isso no playbook do SO borraria o raio de impacto.
- Os próprios nodes do Proxmox. Aplicar patches no hypervisor derruba todas as VMs que estão nele. Faço isso manualmente, com um plano de para onde as VMs vão.
- O horário. Rodo em uma noite de dia de semana, quando ninguém está no meio de um filme. Rodar via cron eliminaria a verificação de "tem alguém olhando", e eu não estou pronto para abrir mão dela.
O que eu faria diferente
Se eu começasse de novo, incluiria uma execução de teste com --check na minha rotina antes da execução de verdade. Ela é imperfeita com tasks command, que não rodam em modo check a menos que você diga como, mas ainda mostra quais hosts têm upgrades pendentes.
A lição maior é que o snapshot foi a parte que mudou meu comportamento. Saber que posso fazer rollback em um minuto me deixa muito menos nervoso na hora de rodar o upgrade.
Algumas perguntas para quem atualiza mais VMs do que eu. Vocês rodam upgrades completos em um cronograma, ou só atualizações de segurança? Já fizeram rollback de um snapshot depois de uma rodada de patches, e o que quebrou? E como vocês lidam especificamente com a VM de DNS: atualizam primeiro, por último, ou à mão?
Have a question about this guide?
Create a free account to ask the community and join the discussion. Members who run the real thing answer every day.