IaC — Ansible e Pulumi

IaC — Ansible Roles + Pulumi

Visao Geral

A infraestrutura do CPPS usa 3 ferramentas complementares, cada uma com dominio bem definido:

┌─────────────────────────────────────────────────────────────────────┐
│                        Git (fonte unica de verdade)                 │
└──────────┬──────────────────┬────────────────────┬──────────────────┘
           │                  │                    │
           ▼                  ▼                    ▼
   ┌──────────────┐   ┌──────────────┐    ┌──────────────┐
   │   Pulumi      │   │   Ansible    │    │   Argo CD    │
   │               │   │              │    │              │
   │  Provisiona   │   │  Configura   │    │  Deploya     │
   │  o que EXISTE │   │  o que RODA  │    │  workloads   │
   │  no Proxmox   │   │  DENTRO      │    │  no K3s      │
   │               │   │              │    │              │
   │  VMs, LXCs,   │   │  Pacotes,    │    │  Helm charts,│
   │  discos, rede,│   │  servicos,   │    │  manifests,  │
   │  cloud-init   │   │  hardening,  │    │  CRDs        │
   │               │   │  LINSTOR,    │    │              │
   │  Estado:      │   │  drivers     │    │  Estado:     │
   │  Pulumi state │   │              │    │  Git + etcd  │
   │  (S3)         │   │  Estado:     │    │              │
   │               │   │  idempotente │    │              │
   └──────┬───────┘   └──────┬───────┘    └──────────────┘
          │                  │
          │   output: IP     │
          └──────────────────┘
              Pulumi cria VM → Ansible configura

Fronteira clara — nenhuma ferramenta invade o dominio da outra

Pergunta	Ferramenta
”Preciso de uma VM com 8 cores, 32G RAM, disco em LINSTOR”	Pulumi
”A VM precisa ter Docker, NVIDIA driver, NTP, hardening SSH”	Ansible
”Quero rodar Airflow no K3s com Helm chart”	Argo CD
”Preciso limpar /boot dos nodes Proxmox”	Ansible
”Quero criar uma rede/VLAN no Proxmox”	Pulumi
”Preciso instalar LINSTOR nos nodes GPU”	Ansible

Ansible — Roles e Playbooks

O que sao Roles

Uma role Ansible e um pacote reutilizavel de tarefas. Em vez de repetir os mesmos comandos em cada playbook, encapsula em uma role e reutiliza.

Analogia: uma role e como uma funcao. O playbook e o main() que chama as funcoes.

config/roles/
├── common/                    ← base para qualquer servidor
├── proxmox-cleanup-boot/      ← limpeza de kernels antigos
├── proxmox-upgrade/           ← upgrade PVE 8→9 completo
├── nvidia-driver/             ← driver GPU condicional
└── linstor/                   ← cluster storage distribuido

Estrutura de cada Role

config/roles/minha-role/
├── defaults/main.yaml    ← variaveis com valores padrao (SEMPRE documentar)
├── tasks/main.yaml       ← lista de tarefas (o que fazer)
├── handlers/main.yaml    ← acoes reativas (ex: reiniciar servico se config mudou)
└── templates/             ← arquivos Jinja2 (config files dinamicos)

• defaults/: valores que podem ser sobrescritos no inventory ou via -e
• tasks/: lista ordenada de acoes. Cada task e idempotente (rodar 2x = mesmo resultado)
• handlers/: executam so quando notificados por uma task que mudou algo
• templates/: arquivos com variaveis {{ }} que Ansible renderiza

Roles existentes

common

Baseline para qualquer servidor. Instala pacotes utilitarios, configura DNS fallback e timezone.

# Uso em playbook:
roles:
  - common

Variaveis: common_packages, common_dns_fallback, common_ntp_servers

proxmox-cleanup-boot

Limpa kernels antigos do /boot. O Proxmox acumula kernels a cada atualizacao e quando /boot enche (~920 MB tipico), novos upgrades falham.

Usa o script config/scripts/cleanup-boot.sh — copia para o node, roda dry-run, depois executa.

make pve-cleanup-boot TARGET=proxmox_sp      # todos os nodes SP
make pve-cleanup-boot TARGET=pve-ippri-31    # node especifico

proxmox-upgrade

Upgrade completo de PVE (ex: 8→9). Sequencia:

1. Verifica versao e pre-requisitos (pve8to9 --full)
2. Garante DNS fallback (evitar problema de resolucao pos-reboot)
3. Atualiza repositorios (bookworm → trixie)
4. apt full-upgrade (async, ate 1h de timeout)
5. Reboot
6. Valida: versao PVE, storage, rede

make pve-upgrade TARGET=pve-ippri-33    # upgrade 1 node

Importante: o playbook usa serial: 1 no orquestrador (config/proxmox/upgrade.yaml), garantindo que faz 1 node por vez (nao derruba o cluster inteiro).

Variaveis: pve_target_suite, pve_current_suite, pve_reboot_timeout, pve_dns_fallback

nvidia-driver

Instala driver NVIDIA. So executa em nodes que tem gpu_model definido no inventory. Detecta automaticamente se a GPU esta presente e se o driver ja esta instalado.

make pve-nvidia TARGET=pve-labri-31     # node com GPU
make pve-nvidia TARGET=proxmox_franca   # todos os de Franca (so instala onde tem GPU)

Variaveis: nvidia_driver_package, nvidia_pin_kernel, nvidia_pinned_kernel_version

linstor

Instala e configura cluster LINSTOR + DRBD. Documentacao completa em linstor-sp.md.

5 fases: repositorio → storage LVM → servicos → cluster → integracao Proxmox.

make pve-linstor TARGET=linstor_sp      # cluster SP inteiro

Playbooks (orquestradores)

Os playbooks ficam em config/proxmox/ e orquestram as roles:

config/proxmox/
├── upgrade.yaml        ← cleanup-boot + upgrade + nvidia (serial: 1)
├── cleanup-boot.yaml   ← so limpeza
├── nvidia.yaml         ← so driver GPU
└── linstor.yaml        ← instala LINSTOR

Cada playbook aceita a variavel target para filtrar hosts:

# Um node
uv run ansible-playbook config/proxmox/upgrade.yaml -e target=pve-ippri-33

# Um grupo
uv run ansible-playbook config/proxmox/upgrade.yaml -e target=proxmox_sp

# Via Makefile (mais simples)
make pve-upgrade TARGET=pve-ippri-33

Inventory

O inventory define TODOS os hosts e suas variaveis:

inventory/hosts.yaml
├── routers (vyos)
├── servers (debian-proxy, vm-cpps-02, vm-cpps-03)
├── proxmox
│   ├── proxmox_franca (labri-21..33, com linstor_role e gpu_model)
│   └── proxmox_sp (ippri-11..34, com gpu_model, linstor_ip, linstor_nvme_devices)
└── linstor_sp (ippri-31, 33, 34 — vars LINSTOR especificas)

Variaveis por host:

• ansible_host: IP de conexao
• gpu_model: modelo da GPU (condiciona role nvidia-driver)
• linstor_role: papel LINSTOR (satellite, controller, combined, controller_primary)
• linstor_ip: IP na rede dedicada LINSTOR
• linstor_interface: interface de rede para LINSTOR
• linstor_nvme_devices: lista de NVMe para o pool LINSTOR

Pulumi — Provisionamento de VMs (backlog)

Estado atual

Pulumi ainda nao esta implementado. Toda criacao de VM e feita manualmente na UI do Proxmox. O plano e importar as VMs existentes e depois criar novas via codigo.

Por que Pulumi (e nao Terraform)

• Python nativo: sem aprender HCL (linguagem do Terraform). O time ja conhece Python.
• Type safety: IDE autocomplete, erros de tipo antes de executar
• Logica real: loops, condicionais, funcoes — sem hacks de DSL
• State management: backend S3 (SeaweedFS que ja temos) ou Pulumi Cloud

Estrutura planejada

infra/
└── proxmox/
    ├── Pulumi.yaml          ← config do projeto
    ├── Pulumi.dev.yaml      ← config do stack (dev/prod)
    ├── __main__.py           ← entry point
    ├── config.py             ← defaults (CPU, RAM, rede, cloud-init)
    └── vms/
        ├── vyos.py           ← definicao da VM VyOS
        ├── debian_proxy.py   ← definicao do debian-proxy
        ├── vm_cpps_02.py     ← definicao do vm-cpps-02 (K3s)
        └── vm_cpps_03.py     ← definicao do vm-cpps-03

Exemplo de como ficaria

infra/proxmox/vms/vm_cpps_02.py

import pulumi
from pulumi_proxmoxve import vm

vm_cpps_02 = vm.VirtualMachine("vm-cpps-02",
    node_name="pve-labri-21",
    vm_id=103,
    name="vm-cpps-02",
    cpu=vm.VirtualMachineCpuArgs(cores=12),
    memory=vm.VirtualMachineMemoryArgs(dedicated=32768),  # 32G
    disks=[vm.VirtualMachineDiskArgs(
        interface="scsi0",
        size=170,
        datastore_id="linstor",  # LINSTOR storage
    )],
    network_devices=[vm.VirtualMachineNetworkDeviceArgs(
        bridge="vmbr1",
    )],
    initialization=vm.VirtualMachineInitializationArgs(
        type="nocloud",
        ip_configs=[vm.VirtualMachineInitializationIpConfigArgs(
            ipv4=vm.VirtualMachineInitializationIpConfigIpv4Args(
                address="192.168.0.51/23",
                gateway="192.168.0.1",
            ),
        )],
    ),
)

Fases de adocao

1. Import: pulumi import das VMs que ja existem no Proxmox (nao recria nada)
2. Codificar: escrever definicao Python de cada VM baseado no estado importado
3. Validar: make plan (pulumi preview) mostra diferencas entre codigo e real
4. Criar novas VMs: a partir daqui, toda VM nova e criada via make apply

Fluxo Pulumi → Ansible

1. Pulumi cria VM (CPU, RAM, disco, rede, cloud-init)
     ↓ output: IP da VM
2. IP e adicionado ao inventory/hosts.yaml (manual ou via Pulumi stack output)
     ↓
3. Ansible configura a VM (pacotes, servicos, hardening)
     ↓
4. VM pronta para uso (ou para receber workloads K3s via ArgoCD)

No futuro, o passo 2 pode ser automatizado: Pulumi gera o inventory dinamicamente a partir do state. Mas por agora, manter manual e mais simples e auditavel.

Decisoes pendentes

Decisao	Opcoes	Status
State backend	SeaweedFS S3 (ja temos), Pulumi Cloud (gratis tier), local	Decidir antes do import
Provider Proxmox	pulumi-proxmoxve (community)	Unica opcao viavel
Primeiro import	Comeca por qual VM?	Sugestao: vm-cpps-03 (simples, sem dependencias)

Makefile — Interface unificada

# === VM Configuration (Ansible) ===
make configure                              # aplica configs VyOS + Traefik
make verify                                 # dry-run (nao muda nada)
make status                                 # ping em todos os hosts

# === Proxmox Operations (Ansible) ===
make pve-upgrade TARGET=<host|grupo>        # upgrade PVE 8→9
make pve-cleanup-boot TARGET=<host|grupo>   # limpar /boot
make pve-nvidia TARGET=<host|grupo>         # driver GPU
make pve-linstor TARGET=<host|grupo>        # instalar LINSTOR

# === VM Provisioning (Pulumi — futuro) ===
make plan                                   # pulumi preview
make apply                                  # pulumi up

TARGET pode ser:

• Um host: pve-ippri-33
• Um grupo: proxmox_sp, proxmox_franca, linstor_sp
• Todos: proxmox

Estrutura completa do repositorio

devops/
├── apps/                          ← workloads K3s (ArgoCD)
│   ├── airflow/
│   ├── authentik/
│   ├── argocd/                    ← 17 Application manifests
│   └── ...
│
├── config/                        ← configuracao (Ansible)
│   ├── roles/                     ← roles reutilizaveis
│   │   ├── common/
│   │   ├── proxmox-cleanup-boot/
│   │   ├── proxmox-upgrade/
│   │   ├── nvidia-driver/
│   │   └── linstor/
│   ├── proxmox/                   ← playbooks Proxmox
│   │   ├── upgrade.yaml
│   │   ├── cleanup-boot.yaml
│   │   ├── nvidia.yaml
│   │   └── linstor.yaml
│   ├── vyos/playbook.yaml         ← firewall/router
│   ├── traefik/playbook.yaml      ← reverse proxy
│   └── scripts/cleanup-boot.sh
│
├── infra/                         ← provisionamento (Pulumi — futuro)
│   └── proxmox/
│
├── inventory/hosts.yaml           ← todos os hosts e variaveis
├── ansible.cfg
├── Makefile                       ← interface unificada
│
├── docs/
│   ├── infraestrutura.md
│   ├── proxmox-inventario.md
│   ├── linstor-sp.md
│   ├── iac-ansible-pulumi.md      ← este documento
│   └── ...
│
└── roadmap/
    ├── iac.md
    ├── gpu-platform.md
    ├── data-platform.md
    └── execucao.md