Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: count, for_each und Datenquellen

Ziel: Mehrere gleichartige Ressourcen mit count und for_each anlegen, Blöcke mit dynamic erzeugen, mit Datenquellen Informationen von außen lesen und so den kompletten notes-Stack in Docker aufbauen. · Dauer: ca. 90 min · Voraussetzung: Tag 3

Briefing

  • count = 3 legt eine Ressource dreimal an: Adressen x[0], x[1], x[2].
  • for_each nimmt eine Map oder eine Menge (set) und legt je Schlüssel eine Ressource an: x["backend"]. Schlüssel sind stabil, Zahlen nicht – Entfernen aus der Mitte einer count-Liste verschiebt alle folgenden.
  • dynamic "block" erzeugt verschachtelte Blöcke aus einer Liste oder Map.
  • Eine Datenquelle (data) liest etwas, das OpenTofu nicht verwaltet – hier den genauen Digest eines Images in der Registry.
 data docker_registry_image ─► Digest ─► docker_image (fest auf den Digest)
 docker_network for_each {backend, frontend}
   db (Postgres, Healthcheck) ◄─ migrate (einmalig) ◄─ notes-api[a|b] ◄─ proxy :8080

Drill 1: Datenquellen und for_each

mkdir -p ~/tf-lab/tag04 && cd ~/tf-lab/tag04
cat > versions.tf <<'EOF'
terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 4.6"
    }
  }
}

provider "docker" {}
EOF
cat > netze.tf <<'EOF'
resource "docker_network" "notes" {
  for_each = toset(["backend", "frontend"])
  name     = "notes-${each.key}"
}
EOF
cat > images.tf <<'EOF'
data "docker_registry_image" "postgres" {
  name = "postgres:18.6-alpine"
}

resource "docker_image" "postgres" {
  name          = data.docker_registry_image.postgres.name
  pull_triggers = [data.docker_registry_image.postgres.sha256_digest]
  keep_locally  = true
}

resource "docker_image" "nginx" {
  name         = "nginx:1.31.8-alpine"
  keep_locally = true
}

# notes-api:0.4.0 wurde an Tag 0 lokal gebaut – nur lesen
data "docker_image" "notes_api" {
  name = "notes-api:0.4.0"
}
EOF
tofu init -no-color >/dev/null
tofu apply -auto-approve -no-color | grep -E 'Apply complete'
tofu state list
tofu console <<< 'substr(data.docker_registry_image.postgres.sha256_digest, 0, 15)'

Erwartet:

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.
data.docker_image.notes_api
data.docker_registry_image.postgres
docker_image.nginx
docker_image.postgres
docker_network.notes["backend"]
docker_network.notes["frontend"]
"sha256:10a5c69a"
  • for_each = toset([...]) legt je Eintrag ein Netz an. each.key ist der Eintrag, die Adressen tragen ihn in eckigen Klammern.
  • data.docker_registry_image fragt die Registry nach dem Digest. Ändert sich das Image hinter dem Tag, ändert sich der Digest – und pull_triggers sorgt dafür, dass es neu geladen wird.
  • data "docker_image" verwaltet nichts, es liest nur. Fehlt das Image, scheitert der Plan mit einer klaren Meldung.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Datenbank und Migration

cat > db.tf <<'EOF'
resource "docker_volume" "db" {
  name = "notes-db"
}

resource "docker_container" "db" {
  name  = "notes-db"
  image = docker_image.postgres.image_id
  env = [
    "POSTGRES_USER=notes",
    "POSTGRES_PASSWORD=lab-db-pw-123",
    "POSTGRES_DB=notes",
  ]
  networks_advanced {
    name = docker_network.notes["backend"].id
  }
  volumes {
    volume_name    = docker_volume.db.name
    container_path = "/var/lib/postgresql"
  }
  healthcheck {
    test     = ["CMD-SHELL", "pg_isready -U notes -d notes"]
    interval = "2s"
    retries  = 15
  }
  wait = true
}

resource "docker_container" "migrate" {
  name     = "notes-migrate"
  image    = data.docker_image.notes_api.id
  command  = ["migrate"]
  env      = ["NOTES_DB_URL=postgres://notes:lab-db-pw-123@notes-db:5432/notes"]
  must_run = false
  attach   = true
  logs     = true
  networks_advanced {
    name = docker_network.notes["backend"].id
  }
  depends_on = [docker_container.db]
}
EOF
tofu apply -auto-approve -no-color | grep -E 'Creation complete|Apply complete'
docker logs notes-migrate 2>&1 | grep -o 'msg="migration complete".*'

Erwartet (IDs und Zeiten weichen ab):

docker_volume.db: Creation complete after 0s [id=notes-db]
docker_container.db: Creation complete after 5s [id=2c7e…]
docker_container.migrate: Creation complete after 1s [id=9a41…]
Apply complete! Resources: 3 added, 0 changed, 0 destroyed.
msg="migration complete" table=notes
  • wait = true wartet, bis der Healthcheck „healthy” meldet. Erst dann ist die Ressource fertig – und erst dann startet die Migration.
  • depends_on: Die Migration verweist auf die Datenbank nur über einen Hostnamen in einem Text. OpenTofu kann darin keine Abhängigkeit erkennen, also steht sie ausdrücklich da.
  • attach = true wartet, bis der Container fertig ist, must_run = false erlaubt ihm, danach beendet zu sein.

Fortschritt speichern? Kostenlos registrieren

Drill 3: notes-api mehrfach und der Proxy

cat > api.tf <<'EOF'
variable "instanzen" {
  description = "Namen der notes-api-Instanzen"
  type        = set(string)
  default     = ["a", "b"]
}

resource "docker_container" "api" {
  for_each = var.instanzen
  name     = "notes-api-${each.key}"
  image    = data.docker_image.notes_api.id
  env = [
    "NOTES_API_KEY=lab-api-key-123",
    "NOTES_DB_URL=postgres://notes:lab-db-pw-123@notes-db:5432/notes",
  ]
  dynamic "networks_advanced" {
    for_each = docker_network.notes
    content {
      name = networks_advanced.value.id
    }
  }
  depends_on = [docker_container.migrate]
}
EOF
cat > nginx.conf.tftpl <<'EOF'
upstream notes_api {
%{ for name in instanzen ~}
  server ${name}:8080;
%{ endfor ~}
}
server {
  listen 80;
  location / {
    proxy_pass http://notes_api;
  }
}
EOF
cat > proxy.tf <<'EOF'
resource "docker_container" "proxy" {
  name  = "notes-proxy"
  image = docker_image.nginx.image_id
  ports {
    internal = 80
    external = 8080
    ip       = "127.0.0.1"
  }
  networks_advanced {
    name = docker_network.notes["frontend"].id
  }
  upload {
    file = "/etc/nginx/conf.d/default.conf"
    content = templatefile("${path.module}/nginx.conf.tftpl", {
      instanzen = [for c in docker_container.api : c.name]
    })
  }
}

output "url" {
  value = "http://127.0.0.1:8080"
}
EOF
tofu apply -auto-approve -no-color | grep 'Apply complete'
U=$(tofu output -raw url)
curl -s -X POST -H "X-API-Key: $NOTES_API_KEY" -H 'Content-Type: application/json' \
  -d '{"text":"aus OpenTofu"}' "$U/notes" | jq -r .text
curl -s "$U/notes" | jq length
docker ps --filter name=notes- --format '{{.Names}}' | sort

Erwartet:

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.
aus OpenTofu
1
notes-api-a
notes-api-b
notes-db
notes-db-tag03
notes-proxy
notes-web-dev

notes-db-tag03 und notes-web-dev stammen aus Tag 2 und 3 – sie laufen in eigenen States weiter.

  • dynamic "networks_advanced" hängt jede API-Instanz an beide Netze: an backend für die Datenbank, an frontend für den Proxy. Die Datenbank sieht der Proxy nicht.
  • [for c in docker_container.api : c.name] macht aus allen Instanzen eine Liste von Namen für die nginx-Konfiguration – kommt eine Instanz dazu, ändert sich die Konfiguration von selbst.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Skalieren – und die Falle mit count

tofu plan -no-color -var 'instanzen=["a","b","c"]' | grep -E '^  # |Plan:'
tofu plan -no-color -var 'instanzen=["a","c"]' | grep -E '^  # |Plan:'

Erwartet:

  # docker_container.api["c"] will be created
  # docker_container.proxy must be replaced
Plan: 2 to add, 0 to change, 1 to destroy.
  # docker_container.api["b"] will be destroyed
  # (because key ["b"] is not in for_each map)
  # docker_container.api["c"] will be created
  # docker_container.proxy must be replaced
Plan: 2 to add, 0 to change, 2 to destroy.

Mit for_each betrifft eine Änderung genau die Instanz mit diesem Schlüssel. Mit count wäre es anders – hätte die Liste ["a","b","c"] als Index 0, 1, 2 gedient, würde das Entfernen von b aus „c auf Platz 2” ein „c auf Platz 1” machen: OpenTofu würde [1] ersetzen und [2] löschen. count nimmt man darum nur für wirklich gleiche Kopien oder als Schalter: count = var.mit_proxy ? 1 : 0.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Aufräumen mit Ziel

Die Datenbank-Daten sollen ein destroy überleben – ein Schutz direkt im Code:

printf '  lifecycle {\n    prevent_destroy = true\n  }\n' > schutz.txt
sed -i '/^resource "docker_volume" "db" {$/r schutz.txt' db.tf
tofu destroy -auto-approve -no-color 2>&1 | grep -E '^Error|prevent_destroy set'
docker ps --filter name=notes- --format '{{.Names}}' | wc -l

Erwartet:

Error: Resource instance cannot be destroyed
Resource instance docker_volume.db has prevent_destroy set, but the plan
6

OpenTofu verweigert den ganzen Lauf – nichts wurde gelöscht, auch nicht die Container. Der Stack bleibt stehen; Tag 5 baut ihn zu einem Modul um.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/healthz

Erwartet:

200
tofu state list | grep -c 'docker_container.api\['

Erwartet:

2
tofu plan -detailed-exitcode -no-color >/dev/null; echo "Exit: $?"

Erwartet:

Exit: 0

Challenge

Die API-Instanzen sollen zusätzliche Umgebungsvariablen aus einer Map bekommen, z. B. { LOG_LEVEL = "debug" }. Ohne die Map soll sich nichts ändern.

Hinweis: concat(liste1, liste2) und [for k, v in map : "${k}=${v}"].

Lösung

cat > api.tf <<'EOF'
variable "instanzen" {
  description = "Namen der notes-api-Instanzen"
  type        = set(string)
  default     = ["a", "b"]
}

variable "extra_env" {
  type    = map(string)
  default = {}
}

resource "docker_container" "api" {
  for_each = var.instanzen
  name     = "notes-api-${each.key}"
  image    = data.docker_image.notes_api.id
  env = concat([for k, v in var.extra_env : "${k}=${v}"], [
    "NOTES_API_KEY=lab-api-key-123",
    "NOTES_DB_URL=postgres://notes:lab-db-pw-123@notes-db:5432/notes",
  ])
  dynamic "networks_advanced" {
    for_each = docker_network.notes
    content {
      name = networks_advanced.value.id
    }
  }
  depends_on = [docker_container.migrate]
}
EOF
tofu validate -no-color
tofu plan -no-color -detailed-exitcode >/dev/null; echo "ohne Map: Exit $?"
tofu plan -no-color -var 'extra_env={LOG_LEVEL="debug"}' | grep -E 'LOG_LEVEL|Plan:'

Erwartet:

Success! The configuration is valid.
ohne Map: Exit 0
          + "LOG_LEVEL=debug",
          + "LOG_LEVEL=debug",
Plan: 2 to add, 0 to change, 2 to destroy.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Images per Digest: Ein Tag wie 18.6-alpine kann sich ändern, ein Digest nicht. Wer reproduzierbar ausrollen will, pinnt Digests – und lässt Renovate sie aktualisieren.
  • for_each statt count ist die Regel. count bleibt für „0 oder 1” und für wirklich gleichwertige Kopien.
  • prevent_destroy schützt vor Versehen, nicht vor Absicht: Wer den Block entfernt, kann löschen. Datenbanken in Produktion bekommen zusätzlich Backups außerhalb von OpenTofu.