# Aula 07 - Talos Linux: Imagem Customizada para Hetzner Cloud

Criação de snapshot do Talos Linux com extensões para usar como imagem base do cluster Kubernetes.

## Por que Talos Linux?

| Aspecto | Linux Tradicional | Talos Linux |
|---------|-------------------|-------------|
| 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.**

## O Problema: Hetzner Cloud

A Hetzner não permite upload direto de imagens customizadas. Workaround:

```
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=auto&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.2
```

**Schematic Hash gerado:**
```
b4467681fe5ae0d920133249037c6bb221e27f7e3ea9434fa7ec691be304598f
```

### 2. Criar Servidor Temporário na Hetzner

```bash
# Via hcloud CLI
hcloud server create \
  --name talos-builder \
  --type cx22 \
  --image ubuntu-24.04 \
  --location fsn1

# Anotar o IP
hcloud server list
```

Ou via Console Hetzner Cloud:
1. Criar servidor CX22 com Ubuntu
2. Anotar IP público

### 3. Ativar Rescue Mode

```bash
# 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/b4467681fe5ae0d920133249037c6bb221e27f7e3ea9434fa7ec691be304598f/v1.12.2/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.