Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Infrastructure as Code

Ziel: Mandanten-Onboarding läuft als OpenTofu-Modul gegen kind, die LLM-VM wird per Ansible-Rolle idempotent eingerichtet – beides mit Drift-Erkennung. · Dauer: ca. 150 min · Voraussetzung: Tag 5, 6 und 7

Briefing

  • OpenTofu verwaltet Kubernetes-Objekte (kubernetes-Provider) und Helm-Releases (helm-Provider); ein Modul tenant ersetzt das YAML-Bundle aus Tag 6.
  • Bestehende Objekte werden per import-Block übernommen – nicht gelöscht und neu angelegt.
  • Ansible richtet die VM ein: Ollama mit systemd-Limits, node_exporter, ufw. Zweiter Lauf = changed=0.
  • Drift: tofu plan -detailed-exitcode (Exit 2) bzw. ansible-playbook --check --diff.
tofu-tenant/                         ansible-llm-vm/
├── main.tf        for_each tenants  ├── site.yml
├── platform.tf    helm_release      ├── inventory/{hosts,docker-test}.ini
├── terraform.tfvars                 └── roles/llm_vm/{tasks,handlers,
└── modules/tenant/  ns, quota, …        defaults,templates}

Drill 1: Das Modul tenant lesen

mkdir -p ~/sre-lab/tag12 && cd ~/sre-lab/tag12
cp -R ~/sre-lab/code/tofu-tenant ~/sre-lab/code/ansible-llm-vm .
cd tofu-tenant
grep -h '^resource' modules/tenant/*.tf
cat main.tf terraform.tfvars

Erwartet:

resource "kubernetes_namespace_v1" "this" {
resource "kubernetes_default_service_account_v1" "this" {
resource "kubernetes_role_binding_v1" "admin" {
resource "kubernetes_resource_quota_v1" "this" {
resource "kubernetes_limit_range_v1" "this" {
resource "kubernetes_network_policy_v1" "default_deny" {
resource "kubernetes_network_policy_v1" "allow_dns" {
resource "kubernetes_network_policy_v1" "same_namespace" {
resource "kubernetes_network_policy_v1" "to_gateway" {
module "tenant" {
  source   = "./modules/tenant"
  for_each = var.tenants

  name       = each.key
  team_group = each.value.team_group
  gpu_quota  = each.value.gpu_quota
}

output "namespaces" {
  value = sort([for t in module.tenant : t.namespace])
}
tenants = {
  acme   = { team_group = "team-acme", gpu_quota = 1 }
  globex = { team_group = "team-globex" }
}

Die Modul-Variablen validieren Eingaben, bevor irgendetwas den Cluster erreicht:

sed -n '/variable "gpu_quota"/,/^}/p' modules/tenant/variables.tf

Erwartet:

variable "gpu_quota" {
  description = "Maximal angeforderte GPUs (requests.nvidia.com/gpu)"
  type        = number
  default     = 0
  validation {
    condition     = var.gpu_quota >= 0 && floor(var.gpu_quota) == var.gpu_quota
    error_message = "gpu_quota muss eine ganze Zahl >= 0 sein."
  }
}

Warum _v1-Ressourcen? Die versionslosen Namen (kubernetes_namespace) sind seit Provider 2.x veraltet. Warum for_each statt count? Mit count verschiebt das Entfernen von acme die Indizes aller folgenden Mandanten – OpenTofu würde globex zerstören und neu anlegen.

Fortschritt speichern? Kostenlos registrieren

Drill 2: init und Bestand importieren

Die Namespaces aus Tag 6 und den metrics-server aus Tag 7 gibt es schon. Ein apply würde an AlreadyExists scheitern – also importieren:

tofu init
cat > imports.tf <<'EOF'
# Bestand aus Tag 6/7 übernehmen; nach erfolgreichem apply löschen
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_namespace_v1.this
  id       = "tenant-${each.key}"
}
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_default_service_account_v1.this
  id       = "tenant-${each.key}/default"
}
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_role_binding_v1.admin
  id       = "tenant-${each.key}/tenant-admin"
}
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_resource_quota_v1.this
  id       = "tenant-${each.key}/tenant-quota"
}
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_limit_range_v1.this
  id       = "tenant-${each.key}/tenant-defaults"
}
EOF
for p in default_deny:default-deny-all allow_dns:allow-dns \
         same_namespace:allow-same-namespace to_gateway:allow-egress-llm-gateway; do
cat >> imports.tf <<EOF
import {
  for_each = var.tenants
  to       = module.tenant[each.key].kubernetes_network_policy_v1.${p%%:*}
  id       = "tenant-\${each.key}/${p##*:}"
}
EOF
done
cat >> imports.tf <<'EOF'
import {
  to = helm_release.metrics_server
  id = "kube-system/metrics-server"
}
EOF
tofu fmt imports.tf
tofu plan -no-color -out=tfplan | grep -E '^  # .*updated|^Plan:'

Erwartet (gekürzt):

- Installed hashicorp/kubernetes v3.3.0 (signed, key ID 0C0AF313E5FD9F80)
- Installed hashicorp/helm v3.3.0 (signed, key ID 0C0AF313E5FD9F80)
OpenTofu has been successfully initialized!
  # helm_release.metrics_server will be updated in-place
  # module.tenant["acme"].kubernetes_namespace_v1.this will be updated in-place
  # module.tenant["acme"].kubernetes_role_binding_v1.admin will be updated in-place
  # module.tenant["globex"].kubernetes_namespace_v1.this will be updated in-place
  # module.tenant["globex"].kubernetes_role_binding_v1.admin will be updated in-place
Plan: 19 to import, 0 to add, 5 to change, 0 to destroy.

Lies jedes ~ update vor dem Apply: Beim helm_release übernimmt OpenTofu nur Repository und set-Werte in den State; beim RoleBinding ergänzt der Provider namespace = "default" am Group-Subject – für RBAC bedeutungslos. Bei den Namespaces zeigt der Plan die PSA-Labels als +, obwohl sie seit Tag 6 gesetzt sind: Der Provider (3.3.0) liest beim Import Labels mit kubernetes.io im Schlüssel offenbar nicht in den State ein. Das Apply ändert im Cluster nichts, danach ist der Plan leer.

tofu apply -no-color tfplan | grep 'Apply complete'
rm imports.tf tfplan
tofu plan -detailed-exitcode >/dev/null; echo "Exit-Code: $?"

Erwartet:

Apply complete! Resources: 19 imported, 0 added, 5 changed, 0 destroyed.
Exit-Code: 0

Achtung: Import-Blöcke mit for_each = var.tenants gelten auch für jeden neuen Mandanten. Bleibt imports.tf liegen, scheitert das Onboarding in Drill 4 mit Missing Resource Identity After Read, weil OpenTofu einen nicht existierenden Namespace importieren will.

Fortschritt speichern? Kostenlos registrieren

Drill 3: State verstehen

tofu state list | head -4
tofu state list | wc -l
tofu state show 'module.tenant["acme"].kubernetes_resource_quota_v1.this' \
  | grep -E '^#|gpu'

Erwartet:

helm_release.metrics_server
module.tenant["acme"].kubernetes_default_service_account_v1.this
module.tenant["acme"].kubernetes_limit_range_v1.this
module.tenant["acme"].kubernetes_namespace_v1.this
      19
# module.tenant["acme"].kubernetes_resource_quota_v1.this:
            "requests.nvidia.com/gpu" = "1"

Der State liegt hier lokal in terraform.tfstate – inklusive Secrets, falls Ressourcen welche enthalten. Im Team gehört er in ein Remote-Backend mit Locking und Verschlüsselung (Enterprise-Notiz).

Sicherheit: terraform.tfstate nie committen; .gitignore im Code-Ordner deckt das ab.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Drift erkennen und heilen

Jemand löscht „kurz zum Debuggen” die Default-Deny-Policy:

kubectl -n tenant-acme delete networkpolicy default-deny-all
tofu plan -no-color -detailed-exitcode > drift.txt; echo "Exit-Code: $?"
grep -E '^  # |^Plan:' drift.txt
tofu apply -auto-approve -no-color | grep 'Apply complete'

Erwartet:

networkpolicy.networking.k8s.io "default-deny-all" deleted from tenant-acme namespace
Exit-Code: 2
  # module.tenant["acme"].kubernetes_network_policy_v1.default_deny will be created
Plan: 1 to add, 0 to change, 0 to destroy.
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Exit-Codes von -detailed-exitcode: 0 keine Änderung, 1 Fehler, 2 Drift. Ein nächtlicher CI-Job mit diesem Befehl ist der einfachste Drift-Alarm.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Onboarding und Offboarding per Variable

cat > initech.auto.tfvars <<'EOF'
tenants = {
  acme    = { team_group = "team-acme", gpu_quota = 1 }
  globex  = { team_group = "team-globex" }
  initech = { team_group = "team-initech", gpu_quota = 2 }
}
EOF
tofu apply -auto-approve -no-color | grep -E '^Plan:|Apply complete'
kubectl -n tenant-initech get quota tenant-quota \
  -o jsonpath='{.spec.hard.requests\.nvidia\.com/gpu}'; echo
rm initech.auto.tfvars
tofu plan -no-color | grep '^Plan:'
tofu apply -auto-approve -no-color | grep 'Apply complete'
kubectl get ns tenant-initech

Erwartet:

Plan: 9 to add, 0 to change, 0 to destroy.
Apply complete! Resources: 9 added, 0 changed, 0 destroyed.
2
Plan: 0 to add, 0 to change, 9 to destroy.
Apply complete! Resources: 0 added, 0 changed, 9 destroyed.
Error from server (NotFound): namespaces "tenant-initech" not found

Warum *.auto.tfvars? OpenTofu lädt sie automatisch nach terraform.tfvars – spätere Dateien überschreiben frühere. In echten Setups gibt es eine Datei pro Mandant (oder ein YAML, das per yamldecode() eingelesen wird) und Onboarding ist ein Merge-Request.

Achtung: Offboarding löscht den Namespace mit allen Daten (PVCs!). In Produktion lifecycle { prevent_destroy = true } am Namespace und ein bewusster Abbau-Prozess mit Backup.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ansible-Testziel ohne VM

Ohne llm-vm dient ein Ubuntu-Container mit systemd als Ziel; die Ollama-Installation (ca. 1,5 GB Download) ersetzt ein Stub:

mkdir -p ~/sre-lab/tag12/vmimg && cd ~/sre-lab/tag12/vmimg
cat > Dockerfile <<'EOF'
FROM ubuntu:24.04
RUN apt-get update && apt-get install -y --no-install-recommends \
      systemd systemd-sysv python3 python3-apt sudo iptables \
    && rm -rf /var/lib/apt/lists/*
STOPSIGNAL SIGRTMIN+3
CMD ["/sbin/init"]
EOF
docker build -q -t sre-lab/llm-vm:24.04 .
docker run -d --name llm-vm-test --hostname llm-vm-test --privileged \
  --cgroupns=host -v /sys/fs/cgroup:/sys/fs/cgroup:rw \
  --tmpfs /run --tmpfs /run/lock sre-lab/llm-vm:24.04
sleep 5
docker exec llm-vm-test systemctl is-system-running
docker exec llm-vm-test bash -c 'apt-get update -qq
  printf "#!/bin/sh\ncase \"\$1\" in serve) exec sleep infinity;; *) exit 0;; esac\n" \
    > /usr/local/bin/ollama && chmod +x /usr/local/bin/ollama'

Erwartet (gekürzt):

sha256:87217f98…
f636322a34fe…
running

Achtung: Meldet der Container Failed to allocate manager object: Too many open files, sind die inotify-Instanzen der Docker-VM erschöpft (typisch mit kind). Abhilfe bis zum nächsten VM-Neustart: docker run --rm --privileged ubuntu:24.04 sysctl -w fs.inotify.max_user_instances=512.

Inventar fürs Testziel – der Docker-Connection-Plugin braucht kein SSH:

cd ~/sre-lab/tag12/ansible-llm-vm
cat inventory/docker-test.ini
ansible-galaxy collection install -r requirements.yml
ansible-playbook site.yml --syntax-check
ansible-lint

Erwartet (gekürzt):

[llm_vms]
llm-vm-test ansible_connection=community.docker.docker

[llm_vms:vars]
llm_vm_gateway_cidr=172.18.0.0/16
llm_vm_ollama_skip_install=true

playbook: site.yml
Passed: 0 failure(s), 0 warning(s) in 9 files processed of 12 encountered.
Last profile that met the validation criteria was 'production'.

Warum heißen alle Variablen llm_vm_…? ansible-lint (var-naming[no-role-prefix]) verlangt den Rollennamen als Präfix – sonst kollidiert gateway_cidr irgendwann mit einer anderen Rolle.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rolle anwenden, Idempotenz prüfen

Die Kernstücke der Rolle – Drop-in mit Limits und Firewall:

cat roles/llm_vm/templates/override.conf.j2
grep -A5 'Ollama nur vom Gateway' roles/llm_vm/tasks/main.yml

Erwartet:

# {{ ansible_managed }}
[Service]
Environment="OLLAMA_HOST={{ llm_vm_ollama_listen }}"
Environment="OLLAMA_MODELS={{ llm_vm_ollama_models_dir }}"
Environment="OLLAMA_KEEP_ALIVE={{ llm_vm_ollama_keep_alive }}"
MemoryMax={{ llm_vm_ollama_memory_max }}
CPUQuota={{ llm_vm_ollama_cpu_quota }}
LimitNOFILE={{ llm_vm_ollama_nofile }}
- name: UFW – Ollama nur vom Gateway
  community.general.ufw:
    rule: allow
    port: "11434"
    proto: tcp
    from_ip: "{{ llm_vm_gateway_cidr }}"

Erst Check-Mode auf dem frischen Host, dann echt, dann noch einmal:

run() { ansible-playbook -i inventory/docker-test.ini site.yml "$@" \
  | grep -E '^fatal|^llm-vm-test +:' | cut -c1-80; }
run --check
run
run

Erwartet (gekürzt):

fatal: [llm-vm-test]: FAILED! => {"changed": false, "msg": "Could not find the
llm-vm-test                : ok=8    changed=7    unreachable=0    failed=1
llm-vm-test                : ok=16   changed=14   unreachable=0    failed=0
llm-vm-test                : ok=15   changed=0    unreachable=0    failed=0

Warum scheitert der Check-Mode? Im Trockenlauf wird die Unit nie geschrieben – der systemd-Task findet keinen Dienst. Check-Mode ist ein Drift-Werkzeug für eingerichtete Hosts, kein Ersatz für einen Testlauf. changed=0 im dritten Lauf ist der Idempotenz-Beweis; ok sinkt von 16 auf 15, weil kein Handler mehr läuft.

docker exec llm-vm-test bash -c 'systemctl is-active ollama prometheus-node-exporter
  systemctl show ollama -p MemoryMax -p LimitNOFILE; ufw status | grep ALLOW'

Erwartet:

active
active
MemoryMax=6442450944
LimitNOFILE=65536
22/tcp                     ALLOW       Anywhere
11434/tcp                  ALLOW       172.18.0.0/16
9100/tcp                   ALLOW       172.18.0.0/16

Fortschritt speichern? Kostenlos registrieren

Drill 8: Drift auf der VM mit --check --diff

docker exec llm-vm-test sed -i 's/MemoryMax=6G/MemoryMax=12G/' \
  /etc/systemd/system/ollama.service.d/override.conf
ansible-playbook -i inventory/docker-test.ini site.yml --check --diff \
  | grep -E '^[-+@]|^changed|HANDLER|^llm-vm-test +:' | cut -c1-80
run

Erwartet (gekürzt):

--- before: /etc/systemd/system/ollama.service.d/override.conf
+++ after: …/override.conf.j2
@@ -3,6 +3,6 @@
-MemoryMax=12G
+MemoryMax=6G
changed: [llm-vm-test]
RUNNING HANDLER [llm_vm : Restart ollama] ****************************************
changed: [llm-vm-test]
llm-vm-test                : ok=16   changed=2    unreachable=0    failed=0
llm-vm-test                : ok=16   changed=2    unreachable=0    failed=0

Der Trockenlauf zeigt die Abweichung samt Handler, ändert aber nichts; erst der echte Lauf (run) setzt 6G zurück und startet Ollama neu.

Für die echte VM nur das Inventar tauschen (inventory/hosts.ini, IP aus multipass info llm-vm) und ansible-playbook site.yml – dann lädt die Rolle Ollama 0.40.2 und ministral-3:3b tatsächlich.

Und die VM selbst? Die erzeugt OpenTofu, z. B. bei Hetzner Cloud – nur per tofu validate geprüft:

cd ~/sre-lab/tag12/tofu-tenant/examples/llm-vm-hcloud
grep -E '^resource|server_type|source_ips|^output' main.tf
tofu init -backend=false >/dev/null && tofu validate

Erwartet:

resource "hcloud_ssh_key" "admin" {
resource "hcloud_firewall" "llm_vm" {
    source_ips = ["0.0.0.0/0", "::/0"]
    source_ips = [var.gateway_cidr]
resource "hcloud_server" "llm_vm" {
  server_type  = "ccx33" # 8 dedizierte vCPU, 32 GB RAM
output "ansible_inventory" {
Success! The configuration is valid.

Die Kette in Produktion: tofu apply (VM + Cloud-Firewall) → Output als Ansible-Inventar → ansible-playbook site.yml. Für on-prem tauscht man den Provider (dmacvicar/libvirt, vSphere, Proxmox), für AWS aws_instance mit GPU-Typ (g6.xlarge) und Security Group statt hcloud-Firewall.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/sre-lab/tag12/tofu-tenant
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "tofu validate" 'tofu validate'
check "kein Drift (Exit 0)" 'tofu plan -detailed-exitcode'
check "19 Objekte im State" '[ "$(tofu state list | wc -l)" -eq 19 ]'
check "imports.tf entfernt" '[ ! -f imports.tf ]'
check "State nicht im Git" 'grep -q tfstate ~/sre-lab/code/tofu-tenant/.gitignore'
cd ~/sre-lab/tag12/ansible-llm-vm
check "ansible-lint sauber" 'ansible-lint'
check "Idempotent (changed=0)" \
  'ansible-playbook -i inventory/docker-test.ini site.yml | grep -q "changed=0 "'
check "Ollama-Limit aktiv" \
  'docker exec llm-vm-test systemctl show ollama -p MemoryMax | grep -q 6442450944'

Challenge

Ein Mandant darf höchstens 4 GPUs bekommen – mehr nur mit eigenem Node-Pool. Erzwinge das im Root-Modul, sodass tofu plan bereits scheitert, und beweise es mit einem Mandanten hooli und 8 GPUs, ohne terraform.tfvars zu ändern.

Hinweis: Ein validation-Block in variable "tenants" kann mit alltrue([for …]) über alle Map-Einträge prüfen.

Lösung

cd ~/sre-lab/tag12/tofu-tenant
cat > variables.tf <<'EOF'
variable "kube_context" {
  type    = string
  default = "kind-sre-lab"
}

variable "tenants" {
  description = "Mandanten: Name => Einstellungen"
  type = map(object({
    team_group = string
    gpu_quota  = optional(number, 0)
  }))
  validation {
    condition     = alltrue([for t in values(var.tenants) : t.gpu_quota <= 4])
    error_message = "Maximal 4 GPUs pro Mandant – mehr nur mit eigenem Node-Pool."
  }
}
EOF
tofu plan -var 'tenants={hooli={team_group="team-hooli",gpu_quota=8}}' 2>&1 \
  | grep -E 'Error|Maximal'
tofu plan -detailed-exitcode >/dev/null; echo "Exit-Code: $?"

Erwartet:

│ Error: Invalid value for variable
│ Maximal 4 GPUs pro Mandant – mehr nur mit eigenem Node-Pool.
Exit-Code: 0

Aufräumen (optional, löscht auch die Tenant-Namespaces aus Tag 6 und den metrics-server):

cd ~/sre-lab/tag12/tofu-tenant
tofu destroy -auto-approve -no-color | grep 'Destroy complete'
docker rm -f llm-vm-test

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • Typische Frage: „Terraform oder OpenTofu?” – OpenTofu ist der MPL-lizenzierte Fork nach Terraforms BSL-Wechsel 2023, CLI- und Provider-kompatibel; Unterschiede z. B. State-Verschlüsselung und for_each in import-Blöcken bei OpenTofu. Für Kunden zählt: Lizenz, Registry, Support-Vertrag.
  • Knackig: „Onboarding ist bei mir ein Merge-Request: Mandant in tfvars, Plan im CI, Review, Apply – und ein nächtlicher plan -detailed-exitcode meldet Drift.”
  • Ansible vs. Tofu: Tofu für deklarative APIs (Cloud, Kubernetes), Ansible für den Zustand in der Maschine (Pakete, systemd, Firewall). Idempotenz beweist man mit changed=0, nicht mit Hoffnung.
  • Brücke aus deiner Praxis: OpenBao-Policies, Auth-Mounts und Namespaces hast du bereits per Terraform/OpenTofu verwaltet – inklusive Import von Altbeständen und Drift durch Klick-Änderungen in der UI.
  • Gegenfrage: Wie provisioniert Mistral Kunden-Deployments – eigene Module pro Cloud, Helm + GitOps, oder ein Operator?

Enterprise-Notiz

  • Remote-State mit Locking (S3 + DynamoDB/S3-Lockfile, GCS, Azure Blob, Postgres) und OpenTofu-State-Encryption; Zugriff nur für die CI-Identität.
  • Provider- und Modulversionen pinnen, .terraform.lock.hcl committen, Module aus internem Registry/Git mit Tags.
  • Kubernetes-Objekte langfristig per GitOps (Argo CD/Flux) statt Tofu, wenn Teams selbst deployen; Tofu für Cluster, Netze, IAM, Onboarding-Grundgerüst.
  • Ansible bei Kunden on-prem: Execution Environments (Container), Inventar aus CMDB/Tofu-Output, --check --diff als Change-Nachweis fürs CAB.
  • Air-Gap: Ollama-Binary und Modelle aus internem Mirror statt ollama.com/install.sh (Tag 14).