aula-07: README.md com tutorial completo de imagem Talos para Hetzner

2025-12-31 21:43:09 -03:00
parent 83775685ec
commit a52a1b5745
1 changed files with 257 additions and 46 deletions
--- a/aula-07/README.md
+++ b/aula-07/README.md
@@ -1,63 +1,274 @@
---
+# Aula 07 - Talos Linux: Imagem Customizada para Hetzner Cloud
 criado: 2025-12-27T01:10:54-03:00
 atualizado: 2025-12-27T02:25:34-03:00
 ---
 Criação de snapshot do Talos Linux com extensões para usar como imagem base do cluster Kubernetes.
-A Hetzner Cloud não oferece suporte ao upload de imagens personalizadas. Somente via suporte [issue 3599](https://github.com/siderolabs/talos/issues/3599#issuecomment-841172018) 
+## Por que Talos Linux?
-Workaround
+| Aspecto | Linux Tradicional | Talos Linux |
-1. Execute uma instância no modo de recuperação e substitua o sistema operacional pela imagem do Talos.
+|---------|-------------------|-------------|
-2. 🚧 De a cordo com a documentacao oficial é possivel usar [o Hashicorp Packer](https://www.packer.io/docs/builders/hetzner-cloud) para preparar uma imagem. Mas a documentação oficial foi removida dos builders. E nos meus testes deu kernel panic....
+| SSH | Sim | Não (API apenas) |
 | Shell | Bash | Não existe |
 | Gerenciador pacotes | apt/yum | Não existe |
 | Superfície de ataque | Grande | Mínima |
 | Propósito | Geral | Kubernetes only |
 | Updates | Manual/Ansible | Atômico via API |
 **Talos = Linux imutável, minimalista, projetado exclusivamente para Kubernetes.**
-Passo 1 ->  https://factory.talos.dev/
+## O Problema: Hetzner Cloud
- [ ] siderolabs/amd-ucode / siderolabs/intel-ucode
+A Hetzner não permite upload direto de imagens customizadas. Workaround:
      - Spectre / Meltdown (V1, V2, V4)
        - Predição de desvios
        -  Leitura de memória privilegiada a partir de userland
      - Zenbleed (CVE-2023-20593)
        - CPUs AMD Zen 2
        - Vazamento de registros via execução especulativa
        - Impacta **VMs e containers**
      - Speculative Return Stack Overflow (SRSO)
        - CPUs AMD modernas
        - Jailbreak
 - [ ] siderolabs/qemu-guest-agent (Hetzner usa QEMU / KVM)
 - [ ] siderolabs/stargz-snapshotter (https://github.com/containerd/stargz-snapshotter)
 - [ ] siderolabs/util-linux-tools (lsblk, mount, findmnt)
 - [ ] siderolabs/binfmt-misc (Se for usar imagem multi-arch)
 - siderolabs/tailscale OU cloudflared -> https://spot.rackspace.com/
 - zfs -> Se for Baremetal (~50% mais rapido que ext4)
-bootloader: dual-boot
+```
 1. Criar servidor temporário
 2. Bootar em Rescue Mode (Linux live)
 3. Escrever imagem Talos no disco
 4. Criar snapshot
 5. Usar snapshot como imagem para novos servidores
 ```
 ## Arquitetura
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │                    Talos Factory                            │
 │                  factory.talos.dev                          │
 │                                                             │
 │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
 │  │   Talos     │ +│  Extensões  │ =│  Imagem Customizada │ │
 │  │   v1.12.0   │  │  Selecionadas│  │  (schematic hash)  │ │
 │  └─────────────┘  └─────────────┘  └─────────────────────┘ │
 └─────────────────────────────────────────────────────────────┘
                              │
                         Download
                              │
                              ▼
 ┌─────────────────────────────────────────────────────────────┐
 │              Hetzner Cloud - Rescue Mode                    │
 │                                                             │
 │   wget talos.raw.xz                                         │
 │   xz -d -c talos.raw.xz | dd of=/dev/sda                   │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘
                              │
                          Snapshot
                              │
                              ▼
 ┌─────────────────────────────────────────────────────────────┐
 │                  Hetzner Cloud Image                        │
 │                                                             │
 │   Disponível para criar novos servidores                    │
 │   ID: 12345678 (usar na aula-08)                           │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘
 ```
 ## Extensões Selecionadas
 | Extensão | Função |
 |----------|--------|
 | `siderolabs/amd-ucode` | Patches de CPU AMD (Spectre, Meltdown, Zenbleed) |
 | `siderolabs/intel-ucode` | Patches de CPU Intel (Spectre, Meltdown) |
 | `siderolabs/qemu-guest-agent` | Integração com Hetzner Cloud (QEMU/KVM) |
 | `siderolabs/stargz-snapshotter` | Lazy pulling de imagens (startup rápido) |
 | `siderolabs/util-linux-tools` | Ferramentas: lsblk, mount, findmnt |
 | `siderolabs/binfmt-misc` | Suporte a imagens multi-arch (ARM64 em x86) |
 ### Por que Microcode Updates?
 ```
 Vulnerabilidade          │ Impacto                    │ Mitigação
 ─────────────────────────┼────────────────────────────┼──────────────
 Spectre/Meltdown         │ Leitura memória kernel     │ intel/amd-ucode
 Zenbleed (AMD Zen 2)     │ Vazamento de registros     │ amd-ucode
 SRSO (AMD moderno)       │ Bypass de isolamento       │ amd-ucode
 ```
 **Importante:** Essas vulnerabilidades afetam **VMs e containers** - não apenas bare-metal!
 ### Por que Stargz Snapshotter?
 ```
 Imagem tradicional:  Download 100% ──► Extract ──► Start container
                     [====30s====]    [==10s==]   [1s]
 Imagem eStargz:      Start container ──► Download on-demand
                     [1s]               [background]
 ```
 Containers iniciam **antes** do download completo da imagem.
 ## Passo a Passo
 ### 1. Gerar Imagem no Talos Factory
 Acesse: https://factory.talos.dev/
 Configurações:
 - **Talos Version**: 1.12.0 (ou mais recente)
 - **Platform**: Hetzner Cloud (`hcloud`)
 - **Architecture**: amd64
 - **Bootloader**: dual-boot
 Extensões (marcar todas):
 - [x] siderolabs/amd-ucode
 - [x] siderolabs/intel-ucode
 - [x] siderolabs/qemu-guest-agent
 - [x] siderolabs/stargz-snapshotter
 - [x] siderolabs/util-linux-tools
 - [x] siderolabs/binfmt-misc
 **URL gerada:**
 ```
 https://factory.talos.dev/?arch=amd64&board=undefined&bootloader=dual-boot&cmdline-set=true&extensions=-&extensions=siderolabs%2Famd-ucode&extensions=siderolabs%2Fbinfmt-misc&extensions=siderolabs%2Fintel-ucode&extensions=siderolabs%2Fqemu-guest-agent&extensions=siderolabs%2Fstargz-snapshotter&extensions=siderolabs%2Futil-linux-tools&platform=hcloud&secureboot=undefined&target=cloud&version=1.12.0
 ```
 **Schematic Hash gerado:**
 ```
 c4f17c623d4ac547a243489f1b3285afd64a76b491b1c5c24ef6363587cef55f
 ```
 ### 2. Criar Servidor Temporário na Hetzner
 ```bash
-# Testar se vc entrou em Rescue mode
+# Via hcloud CLI
-  df
+hcloud server create \
  --name talos-builder \
  --type cx22 \
  --image ubuntu-24.04 \
  --location fsn1
-  ### Resultado será tipo:
+# Anotar o IP
-  # Filesystem           1K-blocks    Used Available Use% Mounted on
+hcloud server list
-  # udev                   987432         0    987432   0% /dev
+```
  # 213.133.99.101:/nfs 308577696 247015616  45817536  85% /root/.oldroot/nfs
  # overlay                995672      8340    987332   1% /
  # tmpfs                  995672         0    995672   0% /dev/shm
  # tmpfs                  398272       572    397700   1% /run
  # tmpfs                    5120         0      5120   0% /run/lock
  # tmpfs                  199132         0    199132   0% /run/user/0
-  # Baixar a imagem do Talos
+Ou via Console Hetzner Cloud:
-  cd /tmp
+1. Criar servidor CX22 com Ubuntu
-  wget -O /tmp/talos.raw.xz https://factory.talos.dev/image/c4f17c623d4ac547a243489f1b3285afd64a76b491b1c5c24ef6363587cef55f/v1.12.0/hcloud-amd64.raw.xz
+2. Anotar IP público
-  # Escrever o sistema (Vai demorar uns 4 a 5 minutos)
+### 3. Ativar Rescue Mode
  xz -d -c /tmp/talos.raw.xz | dd of=/dev/sda && sync
-  # Desligue a instancia antes do snapshot
+```bash
-  shutdown -h now
+# Via CLI
-  ```
+hcloud server enable-rescue talos-builder --type linux64
 hcloud server reboot talos-builder
 # Aguardar ~30 segundos
 ```
 Ou via Console:
 1. Server → Rescue → Enable Rescue & Power Cycle
 2. Selecionar "linux64"
 3. Aguardar reboot
 ### 4. Conectar via SSH e Gravar Imagem
 ```bash
 # Conectar ao servidor em rescue mode
 ssh root@<IP_DO_SERVIDOR>
 # Verificar que está em rescue mode
 df
 # Deve mostrar overlay e tmpfs (não ext4 em /dev/sda)
 ```
 ```bash
 # Baixar imagem do Talos Factory
 cd /tmp
 wget -O talos.raw.xz https://factory.talos.dev/image/c4f17c623d4ac547a243489f1b3285afd64a76b491b1c5c24ef6363587cef55f/v1.12.0/hcloud-amd64.raw.xz
 # Gravar no disco (demora 4-5 minutos)
 xz -d -c talos.raw.xz | dd of=/dev/sda bs=4M status=progress && sync
 # Desligar servidor
 shutdown -h now
 ```
 ### 5. Criar Snapshot
 ```bash
 # Via CLI
 hcloud server create-image talos-builder --type snapshot --description "Talos v1.12.0 customizado"
 # Anotar o ID da imagem
 hcloud image list --type snapshot
 ```
 Ou via Console:
 1. Server → Snapshots → Create Snapshot
 2. Nome: "Talos v1.12.0 customizado"
 3. Aguardar conclusão
 ### 6. Limpar Servidor Temporário
 ```bash
 hcloud server delete talos-builder
 ```
 ### 7. Verificar Imagem
 ```bash
 # Listar imagens/snapshots
 hcloud image list --type snapshot
 # Output esperado:
 # ID        TYPE       NAME                         DESCRIPTION
 # 12345678  snapshot   Talos v1.12.0 customizado   ...
 ```
 **Anote o ID** - será usado na aula-08!
 ## Custos
 | Recurso | Tempo | Custo |
 |---------|-------|-------|
 | CX22 (temporário) | ~15 min | ~€0.01 |
 | Snapshot (20GB) | Permanente | ~€0.24/mês |
 ## Troubleshooting
 ### Rescue mode não inicia
 ```bash
 # Forçar reboot
 hcloud server reset talos-builder
 ```
 ### dd falha ou é lento
 ```bash
 # Verificar disco
 lsblk
 # Usar bs maior para performance
 xz -d -c talos.raw.xz | dd of=/dev/sda bs=64M status=progress
 ```
 ### Imagem não boota
 - Verificar se usou `hcloud` como platform no Factory
 - Verificar se `qemu-guest-agent` está nas extensões
 - Testar criar novo servidor com a imagem e ver logs no console Hetzner
 ## Extensões Opcionais
 Dependendo do seu caso de uso:
 | Extensão | Quando Usar |
 |----------|-------------|
 | `siderolabs/tailscale` | VPN mesh entre clusters |
 | `siderolabs/zfs` | Bare-metal com storage avançado |
 | `siderolabs/nvidia-*` | Workloads GPU/ML |
 | `siderolabs/iscsi-tools` | Storage iSCSI |
 ## Lições
 1. **Imutabilidade**: Talos não permite modificações - segurança by design
 2. **API-first**: Toda configuração via `talosctl`, não SSH
 3. **Extensões modulares**: Adicione apenas o necessário
 4. **Snapshots**: Forma eficiente de distribuir imagens customizadas
 5. **Microcode**: Patches de CPU são críticos mesmo em cloud
 ## Próxima Aula
 **Aula 08**: Provisionar cluster Kubernetes HA na Hetzner usando OpenTofu e a imagem Talos criada nesta aula.