Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Acht Störungen finden und beheben, wie sie im Alltag mit OpenTofu vorkommen, jede mit Zeitlimit. · Dauer: ca. 120 min · Voraussetzung: Tag 14

Briefing

  • Jede Runde hat eine Spielleitung: einen Block, der den Fehler einbaut. Lies ihn erst nach der Runde, sonst ist es keine Übung. Am besten tippt ihn jemand anderes.
  • Lage beschreibt, was gemeldet wird, Zeitlimit die Zeit bis zur Lösung.
  • Werkzeuge: die Fehlermeldung (ganz lesen!), tofu plan, tofu state list, git diff, docker ps, s3ls.
 Fehler ──► Wo bricht es ab? init, plan oder apply?
        ──► Was hat sich geändert? Code (git diff), State, echte Welt
        ──► Was sagt der Plan, bevor du irgendetwas anwendest?

Tagesstart – eine eigene Umgebung wk auf Port 8097, mit Remote State, Verschlüsselung und dem Modul v1.2.0. Der Code kommt ins Git, damit jede Änderung sichtbar wird:

source ~/tf-lab/setup/env.sh
mkdir -p ~/tf-lab/tag15 && cd ~/tf-lab/tag15
sed 's|tag05/terraform.tfstate|tag15/terraform.tfstate|' ~/tf-lab/tag05/backend.tf \
  > backend.tf
cp ~/tf-lab/tag05/versions.tf ~/tf-lab/tag05/encryption.tf .
cat > main.tf <<'EOF'
provider "docker" {}

variable "instanzen" {
  type    = set(string)
  default = ["a", "b"]
}

module "notes" {
  source      = "git::file:///home/ubuntu/tf-lab/module//notes-docker?ref=v1.2.0"
  name        = "wk"
  port        = 8097
  instanzen   = var.instanzen
  db_passwort = "lab-db-pw-123"
}
EOF
printf '.terraform/\n' > .gitignore
tofu init -no-color >/dev/null
tofu apply -auto-approve -no-color | tail -1
git init -q -b main && git add -A
git -c user.name=Lab -c [email protected] commit -qm "Start"
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8097/healthz

Erwartet:

Apply complete! Resources: 10 added, 0 changed, 0 destroyed.
200

Runde 1: Gesperrt

Spielleitung:

L='{"ID":"7d1c2a9e-0b6f-4c1e-9a55-3f0e8b2d4c11","Operation":"OperationTypeApply",'
L+='"Info":"","Who":"kollege@laptop","Version":"1.13.2",'
L+='"Created":"2026-11-02T07:12:00Z","Path":"tofu-state/tag15/terraform.tfstate"}'
curl -s -o /dev/null --aws-sigv4 "aws:amz:us-east-1:s3" \
  --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" -X PUT --data "$L" \
  http://127.0.0.1:7070/tofu-state/tag15/terraform.tfstate.tflock

Lage: „Mein Kollege hat heute früh ein Apply gestartet, dann ist sein Laptop abgestürzt. Seitdem geht bei mir nichts mehr.“ Zeitlimit: 10 min

cd ~/tf-lab/tag15
tofu plan -no-color -lock-timeout=5s 2>&1 | grep -E '^Error|ID:|Who:'

Erwartet:

Error: Error acquiring the state lock
  ID:        7d1c2a9e-0b6f-4c1e-9a55-3f0e8b2d4c11
  Who:       kollege@laptop

Lösung

Die Sperre aus Tag 9 liegt noch im Bucket. Erst klären, dass wirklich kein Lauf mehr aktiv ist (Kollegen fragen, CI prüfen) – dann die Sperre mit ihrer ID lösen:

s3ls 'tofu-state?list-type=2' | grep -o '<Key>tag15[^<]*</Key>'
tofu force-unlock -force 7d1c2a9e-0b6f-4c1e-9a55-3f0e8b2d4c11 -no-color | head -1
tofu plan -no-color | tail -1

Erwartet:

<Key>tag15/terraform.tfstate</Key>
<Key>tag15/terraform.tfstate.tflock</Key>
OpenTofu state has been successfully unlocked!
No changes. Your infrastructure matches the configuration.

-lock-timeout lässt OpenTofu eine Weile warten – gut gegen kurze Überschneidungen, nutzlos gegen eine verwaiste Sperre. force-unlock auf eine Sperre, hinter der noch ein Lauf steckt, kann den State zerstören.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Der Proxy kommt nicht hoch

Spielleitung:

docker rm -f wk-proxy
docker run -d --name fremd-web -p 127.0.0.1:8097:80 nginx:1.31.8-alpine

Lage: „notes auf 8097 zeigt nur noch die nginx-Willkommensseite. Ein Apply sollte das reparieren, scheitert aber.“ Zeitlimit: 10 min

tofu apply -auto-approve -no-color 2>&1 | grep -oE 'Bind for [0-9.:]+ failed: .*'

Erwartet:

Bind for 127.0.0.1:8097 failed: port is already allocated

Lösung

Ein fremder Container hält den Port. Wer?

docker ps --filter publish=8097 --format '{{.Names}} {{.Image}}'
docker rm -f fremd-web
tofu apply -auto-approve -no-color | tail -1
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8097/healthz

Erwartet:

fremd-web nginx:1.31.8-alpine
fremd-web
Apply complete! Resources: 1 added, 0 changed, 1 destroyed.
200

Der gescheiterte Proxy steht als tainted im State. Darum ersetzt das zweite Apply ihn, statt ihn nur zu starten. OpenTofu verwaltet nur, was im State steht – fremde Ressourcen sieht es nicht, auch wenn sie im Weg sind.

Fortschritt speichern? Kostenlos registrieren

Runde 3: Das Provider-Update

Spielleitung:

sed -i 's/version = "~> 4.6"/version = "~> 5.0"/' versions.tf

Lage: „Ich habe den Docker-Provider auf Version 5 gehoben, das soll schneller sein. Jetzt geht nicht einmal mehr init.“ Zeitlimit: 10 min

tofu init -no-color 2>&1 | grep -E '^Error|constraint'

Erwartet:

Error: Failed to resolve provider packages
version constraint ~> 4.6, ~> 5.0; must use tofu init -upgrade to allow

Lösung

Die Lock-Datei sagt 4.6, die Vorgabe 5.0. Der naheliegende Rat aus der Meldung führt weiter:

tofu init -upgrade -no-color 2>&1 | grep -E '^Error|no available'

Erwartet:

Error: Failed to resolve provider packages
Could not resolve provider kreuzwerker/docker: no available releases match

Eine Version 5 gibt es nicht. Zurück auf den Stand im Git:

git diff --stat
git checkout versions.tf
tofu init -no-color >/dev/null && tofu plan -no-color | tail -1

Erwartet:

 versions.tf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
Updated 1 path from the index
No changes. Your infrastructure matches the configuration.

Provider-Updates gehören in einen eigenen PR mit init -upgrade, neuer Lock-Datei und Plan. Werkzeuge wie Renovate schlagen sie automatisch vor – nur Versionen, die es gibt.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Nur ein neuer Name

Spielleitung:

sed -i 's/^module "notes" {$/module "notes_app" {/' main.tf
tofu init -no-color >/dev/null

Lage: „Reines Refactoring, nur der Modulname ist sprechender. Der Plan sieht aber seltsam aus.“ Zeitlimit: 10 min

tofu plan -no-color | grep 'Plan:'

Erwartet:

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

Lösung

Für OpenTofu ist module.notes_app ein neues Modul und module.notes ein gelöschtes. Ein Apply würde die Datenbank samt Volume neu bauen. Ein moved-Block (Tag 11) sagt, dass es dasselbe ist:

cat > moved.tf <<'EOF'
moved {
  from = module.notes
  to   = module.notes_app
}
EOF
tofu plan -no-color | grep -cE 'has moved to'
tofu apply -auto-approve -no-color | tail -1
git add -A
git -c user.name=Lab -c [email protected] commit -qm "notes_app"

Erwartet:

10
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Ein ganzes Modul zieht mit einem einzigen moved um – alle zehn Ressourcen darin gleich mit. Umbenennung und moved landen im selben Commit.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Der Geister-Container

Spielleitung:

tofu state rm module.notes_app.docker_container.db -no-color

Lage: „Ich wollte nur den State aufräumen. Jetzt will OpenTofu die Datenbank anlegen und scheitert.“ Zeitlimit: 15 min

tofu apply -auto-approve -no-color 2>&1 \
  | grep -oE 'Conflict\. The container name "[^"]*"'

Erwartet:

Conflict. The container name "/wk-db"

Lösung

Der Container läuft noch, nur der State hat ihn vergessen. Er muss zurück in den State – mit einem import-Block:

ID=$(docker ps -aq --no-trunc --filter name=^wk-db$)
cat > import.tf <<EOF
import {
  to = module.notes_app.docker_container.db
  id = "$ID"
}
EOF
tofu plan -no-color | grep 'Plan:'
tofu apply -auto-approve -no-color | tail -1
rm import.tf
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8097/healthz

Erwartet:

Plan: 1 to import, 1 to add, 0 to change, 1 to destroy.
Apply complete! Resources: 1 imported, 1 added, 0 changed, 1 destroyed.
200

Wie in Tag 11 ersetzt der Import den Container. Das ist hier vertretbar: Die Daten liegen im Volume, und das hat der State nie vergessen. Die schnellere Alternative – docker rm -f wk-db und Apply – führt zum selben Ergebnis, ist aber ein Eingriff an OpenTofu vorbei.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Mehr Instanzen

Spielleitung:

printf 'instanzen = "a,b,c"\n' > wk.auto.tfvars

Lage: „Ich habe eine dritte Instanz eingetragen, aber der Plan bricht ab.“ Zeitlimit: 5 min

tofu plan -no-color 2>&1 | grep -E '^Error|required'

Erwartet:

Error: Invalid value for input variable
set of string required, but have string.

Lösung

instanzen ist eine Menge, kein Text mit Kommas:

printf 'instanzen = ["a", "b", "c"]\n' > wk.auto.tfvars
tofu apply -auto-approve -no-color | tail -1
docker ps --format '{{.Names}}' | grep -c '^wk-api-'

Erwartet:

Apply complete! Resources: 2 added, 0 changed, 1 destroyed.
3

Neue Instanz plus neuer Proxy. Die Typangabe der Variablen hat den Fehler vor dem ersten Zugriff auf Docker abgefangen – genau dafür ist sie da.

Fortschritt speichern? Kostenlos registrieren

Runde 7: Unlesbar

Spielleitung:

export TF_VAR_state_passphrase=lab-state-passphrase-124

Lage: „Nach dem Rechnerwechsel kann ich den State nicht mehr lesen. Ist er kaputt?“ Zeitlimit: 10 min

tofu plan -no-color 2>&1 | grep -E '^Error'

Erwartet:

Error: error loading state: decryption failed for all provided methods

Lösung

Der State ist heil, der Schlüssel falsch. Die Passphrase kommt aus der Umgebung:

env | grep -c '^TF_VAR_state_passphrase='
grep 'TF_VAR_state_passphrase' ~/tf-lab/setup/env.sh | cut -d= -f2 | cut -c1-20
echo "$TF_VAR_state_passphrase"
source ~/tf-lab/setup/env.sh
tofu plan -no-color | tail -1

Erwartet:

1
lab-state-passphrase
lab-state-passphrase-124
No changes. Your infrastructure matches the configuration.

Eine Ziffer Unterschied, kein Zugriff – so soll Verschlüsselung sein. Im Betrieb kommt der Schlüssel darum aus einem Tresor oder KMS, nicht aus dem Gedächtnis.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Die neue Modulversion

Spielleitung:

sed -i 's/ref=v1.2.0/ref=v1.3.0/' main.tf

Lage: „Das Plattform-Team hat Modulversion 1.3.0 angekündigt. Ich habe umgestellt, aber init scheitert.“ Zeitlimit: 5 min

tofu init -no-color 2>&1 | grep -oE 'invalid ref: "[^"]*"'

Erwartet:

invalid ref: "v1.3.0"

Lösung

Angekündigt ist nicht veröffentlicht. Welche Versionen gibt es?

git -C ~/tf-lab/module tag
git checkout main.tf
tofu init -no-color >/dev/null && tofu plan -no-color | tail -1

Erwartet:

v1.0.0
v1.1.0
v1.2.0
Updated 1 path from the index
No changes. Your infrastructure matches the configuration.

git checkout holt den letzten Commit zurück – samt Umbenennung aus Runde 4. Wer eine Modulversion einträgt, prüft vorher mit git tag (oder im Release-Verzeichnis des Modul-Repositorys), ob es sie gibt.

Fortschritt speichern? Kostenlos registrieren

Auswertung

Runde Ursache Werkzeug
1 verwaiste Sperre force-unlock mit ID
2 fremder Container auf dem Port docker ps --filter publish=
3 Provider-Version gibt es nicht init -upgrade, git checkout
4 Umbenennung ohne moved moved-Block
5 Ressource aus dem State entfernt import-Block
6 falscher Typ in tfvars Typ der Variablen
7 falsche Passphrase env, env.sh
8 Modulversion nicht veröffentlicht git tag

Unter 75 Minuten für alle acht Runden: Du bist bereit für den Betrieb im Team.

Kontrollpunkt

cd ~/tf-lab/tag15 && tofu plan -no-color | tail -1

Erwartet:

No changes. Your infrastructure matches the configuration.
s3ls 'tofu-state?list-type=2' | grep -c 'tag15/terraform.tfstate.tflock'

Erwartet:

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

Erwartet:

200

Enterprise-Notiz

  • Runbooks für die Klassiker: Verwaiste Sperre, Import nach state rm, falscher Schlüssel – jede dieser Lagen gehört mit Befehlen in das Runbook des Teams.
  • state rm und force-unlock nur mit Vier-Augen-Prinzip: Beide Befehle umgehen Plan und Review. Wer sie braucht, schreibt vorher ins Team, was er vorhat.
  • Versionierte State-Buckets: Mit Objektversionen im Bucket lässt sich ein verkorkster State auf den Stand von vor einer Stunde zurückholen. Das ist die letzte Rettung, wenn alle Runden dieses Tages schiefgehen.