Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Sechs VMs mit OpenTofu

Ziel: Ein tofu apply klont aus Template 9000 die sechs RKE2-VMs mit festen IPs, SSH-Key und durchgereichter GPU und schreibt das Ansible-Inventory. · Dauer: ca. 75 min · Voraussetzung: Tag 6

Briefing

  • Provider bpg/proxmox (v0.116), Ressource proxmox_virtual_environment_vm mit clone-Block. Die neuen proxmox_vm/proxmox_cloned_vm sind laut Doku experimentell und können weder cloud-init noch Passthrough.
  • Eine Map nodes plus for_each erzeugt alle sechs VMs. Die Größen kommen aus sizes je Klasse server, agent, gpu.
  • cloud-init: IP/DNS über ip_config, Benutzer, Pakete und Hostname über eine eigene user-data-Datei (Snippet) je VM.
  • Nur rke2-gpu-1 bekommt q35 + OVMF + hostpci mit Mapping gpu0.
  • tofu output -raw ansible_inventory liefert das Inventory für Tag 8.
nodes{6} --for_each--> user-data Snippet  (local:snippets/<name>-user.yaml)
                   \--> VM-Klon von 9000   (VMID 211..231, 10.10.20.x/24)
                          rke2-gpu-1: q35, ovmf, efi_disk, hostpci0=gpu0

Drill 1: Projekt und Provider

mkdir -p ~/ki-lab/code/infra-proxmox/cloud-init
cd ~/ki-lab/code/infra-proxmox
cat > versions.tf <<'EOF'
terraform {
  required_version = ">= 1.8"

  required_providers {
    proxmox = {
      source  = "bpg/proxmox"
      version = "~> 0.116"
    }
  }
}
EOF
cat > provider.tf <<'EOF'
# Zugangsdaten nur aus der Umgebung:
#   PROXMOX_VE_ENDPOINT  = https://10.10.20.5:8006/
#   PROXMOX_VE_API_TOKEN = tofu@pve!provider=<secret>
provider "proxmox" {
  insecure = var.pve_insecure

  # Snippet-Upload (cloud-init user-data) geht nur per SSH
  ssh {
    agent    = true
    username = "tofu"
  }
}
EOF
tofu init

Erwartet:

Initializing provider plugins...
- Finding bpg/proxmox versions matching "~> 0.116"...
- Installing bpg/proxmox v0.116.0...
- Installed bpg/proxmox v0.116.0 (signed, key ID 0B3405B36193A495)
...
OpenTofu has been successfully initialized!

Endpoint und Token stehen nicht im Code. Der Provider liest PROXMOX_VE_ENDPOINT und PROXMOX_VE_API_TOKEN aus ~/ki-lab/pve.env (Tag 6). Der ssh-Block nutzt deinen ssh-agent und den Benutzer tofu – nur für den Snippet-Upload.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Variablen – sechs Nodes, drei Größen

cat > variables.tf <<'EOF'
variable "pve_node" {
  description = "Proxmox-Node mit Template und den CPU-VMs"
  type        = string
  default     = "pve1"
}

variable "gpu_pve_node" {
  description = "Proxmox-Node mit der GPU, null = pve_node"
  type        = string
  default     = null
}

variable "pve_insecure" {
  description = "Selbstsigniertes PVE-Zertifikat akzeptieren (nur Lab)"
  type        = bool
  default     = true
}

variable "template_id" {
  type    = number
  default = 9000
}

variable "vm_datastore" {
  type    = string
  default = "local-lvm"
}

variable "snippet_datastore" {
  type    = string
  default = "local"
}

variable "bridge" {
  type    = string
  default = "vmbr0"
}

variable "vlan_id" {
  description = "VLAN-Tag für das K8s-Netz, null = untagged"
  type        = number
  default     = null
}

variable "gateway" {
  type    = string
  default = "10.10.20.1"
}

variable "dns_servers" {
  type    = list(string)
  default = ["10.10.20.1"]
}

variable "domain" {
  type    = string
  default = "lab.internal"
}

variable "ssh_public_key_file" {
  type    = string
  default = "~/.ssh/id_ed25519.pub"
}

variable "gpu_mapping" {
  description = "PCI-Resource-Mapping aus Tag 6"
  type        = string
  default     = "gpu0"
}

variable "nodes" {
  description = "Die sechs Cluster-VMs: VMID, IP, Klasse"
  type = map(object({
    vmid  = number
    ip    = string
    class = string # server | agent | gpu
  }))
  default = {
    "rke2-cp-1"  = { vmid = 211, ip = "10.10.20.11", class = "server" }
    "rke2-cp-2"  = { vmid = 212, ip = "10.10.20.12", class = "server" }
    "rke2-cp-3"  = { vmid = 213, ip = "10.10.20.13", class = "server" }
    "rke2-wk-1"  = { vmid = 221, ip = "10.10.20.21", class = "agent" }
    "rke2-wk-2"  = { vmid = 222, ip = "10.10.20.22", class = "agent" }
    "rke2-gpu-1" = { vmid = 231, ip = "10.10.20.31", class = "gpu" }
  }
}

variable "sizes" {
  description = "Ressourcen je Klasse (memory in MiB, disk in GiB)"
  type = map(object({
    cores  = number
    memory = number
    disk   = number
  }))
  default = {
    server = { cores = 4, memory = 8192, disk = 60 }
    agent  = { cores = 8, memory = 16384, disk = 100 }
    gpu    = { cores = 8, memory = 32768, disk = 200 }
  }
}
EOF

Warum class statt Größen pro Node? Ein dritter Worker ist dann eine Zeile, und die Regeln „GPU-VM bekommt q35“ hängen an class == "gpu" statt an einem Namen.

Tipp: Liegt die GPU in einem zweiten Proxmox-Host (Tag 0), setzt du gpu_pve_node = "pve2". Der Klon entsteht dann auf pve1 und wird migriert – das dauert bei 200 GB ohne Shared Storage einige Minuten.

Fortschritt speichern? Kostenlos registrieren

Drill 3: cloud-init user-data

cat > cloud-init/user-data.yaml.tftpl <<'EOF'
#cloud-config
hostname: ${hostname}
fqdn: ${hostname}.${domain}
manage_etc_hosts: true
timezone: Europe/Berlin
users:
  - name: ubuntu
    groups: [sudo]
    shell: /bin/bash
    sudo: ALL=(ALL) NOPASSWD:ALL
    lock_passwd: true
    ssh_authorized_keys:
      - ${ssh_key}
package_update: true
packages:
  - qemu-guest-agent
  - open-iscsi
  - nfs-common
  - curl
runcmd:
  - systemctl enable --now qemu-guest-agent iscsid
EOF

qemu-guest-agent meldet Proxmox die IP zurück (Provider wartet darauf). open-iscsi und nfs-common braucht Longhorn an Tag 9. Swap ist im Cloud-Image ohnehin aus, RKE2 ist zufrieden.

Achtung: user_data_file_id ersetzt die von Proxmox generierte user-data komplett – deshalb stehen Hostname, Benutzer und SSH-Key hier und nicht in user_account. Netz (ip_config) und DNS generiert Proxmox weiterhin selbst.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die VMs mit for_each

cat > main.tf <<'EOF'
locals {
  ssh_key  = trimspace(file(pathexpand(var.ssh_public_key_file)))
  gpu_host = coalesce(var.gpu_pve_node, var.pve_node)
  host = {
    for k, v in var.nodes : k => v.class == "gpu" ? local.gpu_host : var.pve_node
  }
}

# Eine user-data-Datei pro VM (Hostname steckt darin)
resource "proxmox_virtual_environment_file" "user_data" {
  for_each     = var.nodes
  content_type = "snippets"
  datastore_id = var.snippet_datastore
  node_name    = local.host[each.key]

  source_raw {
    file_name = "${each.key}-user.yaml"
    data = templatefile("${path.module}/cloud-init/user-data.yaml.tftpl", {
      hostname = each.key
      domain   = var.domain
      ssh_key  = local.ssh_key
    })
  }
}

resource "proxmox_virtual_environment_vm" "node" {
  for_each  = var.nodes
  name      = each.key
  vm_id     = each.value.vmid
  node_name = local.host[each.key]
  tags      = ["rke2", each.value.class]
  on_boot   = true

  clone {
    vm_id     = var.template_id
    node_name = var.pve_node # Template liegt hier
    full      = true
    retries   = 3
  }

  # GPU-VM: q35 + UEFI, damit die Karte als PCIe-Gerät erscheint
  machine = each.value.class == "gpu" ? "q35" : "pc"
  bios    = each.value.class == "gpu" ? "ovmf" : "seabios"

  dynamic "efi_disk" {
    for_each = each.value.class == "gpu" ? [1] : []
    content {
      datastore_id = var.vm_datastore
      type         = "4m"
    }
  }

  cpu {
    type  = "host"
    cores = var.sizes[each.value.class].cores
  }

  memory {
    dedicated = var.sizes[each.value.class].memory
    floating  = 0 # kein Ballooning (Pflicht bei Passthrough)
  }

  agent {
    enabled = true
  }

  scsi_hardware = "virtio-scsi-single" # Voraussetzung für iothread

  disk {
    datastore_id = var.vm_datastore
    interface    = "scsi0"
    size         = var.sizes[each.value.class].disk
    discard      = "on"
    iothread     = true
  }

  network_device {
    bridge  = var.bridge
    vlan_id = var.vlan_id
  }

  dynamic "hostpci" {
    for_each = each.value.class == "gpu" ? [var.gpu_mapping] : []
    content {
      device  = "hostpci0"
      mapping = hostpci.value
      pcie    = true
      rombar  = true
    }
  }

  initialization {
    datastore_id = var.vm_datastore
    dns {
      domain  = var.domain
      servers = var.dns_servers
    }
    ip_config {
      ipv4 {
        address = "${each.value.ip}/24"
        gateway = var.gateway
      }
    }
    user_data_file_id = proxmox_virtual_environment_file.user_data[each.key].id
  }
}
EOF
tofu fmt -check && tofu validate

Erwartet:

Success! The configuration is valid.

Warum so?

  • clone.full = true: unabhängige Disks, das Template darf später neu gebaut werden.
  • disk.size vergrößert die 3,5-GB-Disk des Templates. cloud-init (growpart) zieht das Dateisystem beim ersten Boot nach.
  • memory.floating = 0 schaltet Ballooning ab. Bei Passthrough muss der RAM ohnehin komplett fest zugewiesen sein (DMA), für etcd ist es ebenfalls besser.
  • cpu.type = "host": vLLM und PyTorch wollen AVX2/AVX-512 sehen, x86-64-v2-AES (Proxmox-Default) reicht dafür nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die GPU-VM im Plan prüfen

Eine terraform.tfvars für deine Abweichungen (Node-Name, Storage, VLAN):

cat > terraform.tfvars.example <<'EOF'
pve_node            = "pve1"
vm_datastore        = "local-lvm"
snippet_datastore   = "local"
bridge              = "vmbr0"
# vlan_id           = 20
ssh_public_key_file = "~/.ssh/id_ed25519.pub"
gpu_mapping         = "gpu0"
EOF
cp -n terraform.tfvars.example terraform.tfvars

Dann der Plan:

source ~/ki-lab/pve.env
ssh-add -l >/dev/null || ssh-add ~/.ssh/id_ed25519
tofu plan -out=tag07.plan | tail -1
tofu show -no-color tag07.plan \
  | sed -n '/node\["rke2-gpu-1"\] will be created/,/^$/p' \
  | grep -E ' (bios|machine|name|vm_id|mapping|pcie|dedicated|floating) '

Erwartet (gegen einen Dummy-Endpoint erzeugt, Reihenfolge kann abweichen):

Plan: 12 to add, 0 to change, 0 to destroy.
      + bios                                 = "ovmf"
      + machine                              = "q35"
      + name                                 = "rke2-gpu-1"
      + vm_id                                = 231
          + mapping = "gpu0"
          + pcie    = true
          + dedicated      = 32768
          + floating       = 0

Zwölf Ressourcen: sechs Snippets, sechs VMs. Warum q35 + OVMF nur hier? pcie = true gibt es nur mit q35, und moderne NVIDIA-Karten brauchen für große BARs (16–48 GB VRAM) einen UEFI-Gast. Die anderen VMs bleiben bei SeaBIOS – weniger bewegliche Teile.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Apply

tofu apply tag07.plan

Erwartet (gekürzt, nicht live getestet, Dauer hängt vom Storage ab):

proxmox_virtual_environment_file.user_data["rke2-cp-1"]: Creation complete after 1s
...
proxmox_virtual_environment_vm.node["rke2-gpu-1"]: Creation complete after 3m12s
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.

Auf dem Proxmox-Host gegenprüfen:

qm list | grep rke2
qm config 231 | grep -E '^(bios|machine|hostpci0|efidisk0|memory|balloon):'

Erwartet (gekürzt, kann je nach Version abweichen):

       211 rke2-cp-1            running    8192              60.00 4321
       ...
       231 rke2-gpu-1           running    32768            200.00 4377
balloon: 0
bios: ovmf
efidisk0: local-lvm:vm-231-disk-1,efitype=4m,size=4M
hostpci0: mapping=gpu0,pcie=1
machine: q35
memory: 32768

Achtung: Startet rke2-gpu-1 mit „IOMMU group not viable“ oder „device is in use“, stimmt etwas aus Tag 6 nicht (Drill 6/7). dmesg | grep vfio auf dem Host zeigt den Grund.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Outputs und Ansible-Inventory

cat > outputs.tf <<'EOF'
output "nodes" {
  description = "Name -> IP aller VMs"
  value       = { for k, v in var.nodes : k => v.ip }
}

# Ansible-Inventory für Tag 8:
#   tofu output -raw ansible_inventory > ../infra-rke2/inventory.yaml
output "ansible_inventory" {
  value = yamlencode({
    all = {
      vars = { ansible_user = "ubuntu" }
      children = {
        rke2_servers = {
          hosts = {
            for k, v in var.nodes : k => { ansible_host = v.ip }
            if v.class == "server"
          }
        }
        rke2_agents = {
          hosts = {
            for k, v in var.nodes : k => { ansible_host = v.ip }
            if v.class != "server"
          }
        }
        gpu_nodes = {
          hosts = {
            for k, v in var.nodes : k => { ansible_host = v.ip }
            if v.class == "gpu"
          }
        }
      }
    }
  })
}
EOF
tofu apply -auto-approve | grep '^Apply'
mkdir -p ../infra-rke2
tofu output -raw ansible_inventory > ../infra-rke2/inventory.yaml
cat ../infra-rke2/inventory.yaml

Erwartet:

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.
"all":
  "children":
    "gpu_nodes":
      "hosts":
        "rke2-gpu-1":
          "ansible_host": "10.10.20.31"
    "rke2_agents":
      "hosts":
        "rke2-gpu-1":
          "ansible_host": "10.10.20.31"
        "rke2-wk-1":
          "ansible_host": "10.10.20.21"
        "rke2-wk-2":
          "ansible_host": "10.10.20.22"
    "rke2_servers":
      "hosts":
        "rke2-cp-1":
          "ansible_host": "10.10.20.11"
        "rke2-cp-2":
          "ansible_host": "10.10.20.12"
        "rke2-cp-3":
          "ansible_host": "10.10.20.13"
  "vars":
    "ansible_user": "ubuntu"

yamlencode setzt alle Schlüssel in Anführungszeichen – für Ansible egal. Jetzt der erste Kontakt:

cd ../infra-rke2
ANSIBLE_HOST_KEY_CHECKING=False \
  ansible all -i inventory.yaml -m ansible.builtin.ping -o
ssh [email protected] 'ip -br link; lspci -nn | grep -i nvidia'

Erwartet (gekürzt, nicht live getestet):

rke2-cp-1 | SUCCESS => {"changed": false,"ping": "pong"}
...
rke2-gpu-1 | SUCCESS => {"changed": false,"ping": "pong"}
lo               UNKNOWN        00:00:00:00:00:00 <LOOPBACK,UP,LOWER_UP>
eth0             UP             bc:24:11:5e:0a:31 <BROADCAST,MULTICAST,UP,LOWER_UP>
01:00.0 3D controller [0302]: NVIDIA Corporation AD104GL [L4] [10de:27b8] (rev a1)

Warum heißt das Interface eth0? Die von Proxmox erzeugte cloud-init-Netzkonfiguration benennt die NIC per MAC-Match um. kube-vip und Cilium (Tag 8/9) verlassen sich darauf. Heißt es bei dir anders, passt du rke2_vip_interface an.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/ki-lab/code/infra-proxmox
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "6 VMs im State" \
  '[ "$(tofu state list | grep -c proxmox_virtual_environment_vm)" -eq 6 ]'
check "Inventory hat 3 Server" \
  '[ "$(grep -c "rke2-cp-" ../infra-rke2/inventory.yaml)" -eq 3 ]'
for ip in 11 12 13 21 22 31; do
  check "SSH 10.10.20.$ip" "ssh -o BatchMode=yes -o ConnectTimeout=5 \
    [email protected].$ip true"
done
check "GPU in rke2-gpu-1 sichtbar" \
  'ssh [email protected] "lspci -nn | grep -q 10de:"'
check "guest agent auf cp-1" \
  'ssh [email protected] "systemctl is-active qemu-guest-agent"'

Erwartet:

✔ 6 VMs im State
✔ Inventory hat 3 Server
✔ SSH 10.10.20.11
✔ SSH 10.10.20.12
✔ SSH 10.10.20.13
✔ SSH 10.10.20.21
✔ SSH 10.10.20.22
✔ SSH 10.10.20.31
✔ GPU in rke2-gpu-1 sichtbar
✔ guest agent auf cp-1

Challenge

Ersetze rke2-wk-2 gezielt durch eine frische VM, ohne die anderen fünf anzufassen, und zeige vorher im Plan, dass genau zwei Ressourcen neu entstehen.

Hinweis: tofu plan -replace=ADRESSE lässt sich mehrfach angeben, die Snippet-Ressource gehört dazu.

Lösung

cd ~/ki-lab/code/infra-proxmox
tofu plan \
  -replace='proxmox_virtual_environment_vm.node["rke2-wk-2"]' \
  -replace='proxmox_virtual_environment_file.user_data["rke2-wk-2"]' \
  -out=replace.plan | tail -1
tofu apply replace.plan
ssh-keygen -R 10.10.20.22

Erwartet (gekürzt):

Plan: 2 to add, 0 to change, 2 to destroy.

Ist der Cluster aus Tag 8 schon da, vorher kubectl drain rke2-wk-2 --ignore-daemonsets --delete-emptydir-data und danach kubectl delete node rke2-wk-2, dann die Rolle rke2_agent erneut nur für diesen Host laufen lassen (--limit rke2-wk-2).

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • State gehört in ein Remote-Backend mit Locking und Verschlüsselung (OpenTofu encryption-Block, S3/MinIO oder GitLab-HTTP-Backend), nicht auf den Laptop.
  • Snippets per SSH sind ein zweiter Zugangsweg mit eigener Angriffsfläche. Alternative: cloud-init-ISO außerhalb erzeugen oder Images mit Packer vorbacken, dann reicht die API.
  • insecure = true nur im Lab. In Produktion bekommt Proxmox ein Zertifikat der internen CA, und der Provider prüft es.
  • IPs nicht hart im Code: IPAM (NetBox, phpIPAM) als Datenquelle und DNS-Einträge im selben Lauf anlegen.
  • Pro Umgebung ein eigener Workspace/Ordner und eigene Tokens. prevent_destroy für Control-Plane-VMs verhindert, dass ein falsches apply etcd löscht.