Tag 4: count, for_each und Datenquellen
Ziel: Mehrere gleichartige Ressourcen mit
countundfor_eachanlegen, Blöcke mitdynamicerzeugen, 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 = 3legt eine Ressource dreimal an: Adressenx[0],x[1],x[2].for_eachnimmt 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 einercount-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.keyist der Eintrag, die Adressen tragen ihn in eckigen Klammern.data.docker_registry_imagefragt die Registry nach dem Digest. Ändert sich das Image hinter dem Tag, ändert sich der Digest – undpull_triggerssorgt 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 = truewartet, 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 = truewartet, bis der Container fertig ist,must_run = falseerlaubt 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}}' | sortErwartet:
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: anbackendfür die Datenbank, anfrontendfü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 -lErwartet:
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/healthzErwartet:
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-alpinekann sich ändern, ein Digest nicht. Wer reproduzierbar ausrollen will, pinnt Digests – und lässt Renovate sie aktualisieren. for_eachstattcountist die Regel.countbleibt für „0 oder 1” und für wirklich gleichwertige Kopien.prevent_destroyschützt vor Versehen, nicht vor Absicht: Wer den Block entfernt, kann löschen. Datenbanken in Produktion bekommen zusätzlich Backups außerhalb von OpenTofu.