Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Qualität und Tests

Ziel: Das notes-Modul so absichern, dass Formfehler, tote Variablen, falsche Eingaben und riskante Pläne auffallen, bevor jemand apply tippt. · Dauer: ca. 90 min · Voraussetzung: Tag 5, Tag 7

Briefing

Fünf Prüfungen, von schnell und billig bis langsam und gründlich:

Werkzeug prüft braucht
tofu fmt -check Formatierung nichts
tofu validate Syntax, Typen, Referenzen tofu init
tflint Stil, tote Variablen, fehlende Typen Regelsatz
tofu test Verhalten: Plan oder echtes Anlegen Provider, ggf. Ziel
Trivy, Conftest Sicherheit, eigene Regeln Code oder Plan als JSON
  • tflint kennt Regeln, die validate nicht prüft – etwa Variablen ohne Typ oder Variablen, die niemand nutzt.
  • tofu test führt *.tftest.hcl-Dateien aus. Jeder run-Block macht einen Plan oder ein Apply und prüft Bedingungen. Nach dem Test räumt OpenTofu alles wieder ab.
  • Trivy findet bekannte Fehlkonfigurationen in Terraform-, Kubernetes- und Helm-Dateien. Conftest prüft beliebiges JSON gegen eigene Regeln in Rego – hier den Plan.

Drill 1: Werkzeuge installieren

Alle drei Werkzeuge sind einzelne Programme. tflint und Conftest kommen nach ~/.local/bin, Trivy als Debian-Paket:

mkdir -p ~/.local/bin && cd /tmp
GH=https://github.com
curl -sSLO $GH/terraform-linters/tflint/releases/download/v0.65.0/tflint_linux_amd64.zip
unzip -o -q tflint_linux_amd64.zip -d ~/.local/bin && rm tflint_linux_amd64.zip
curl -sSLO $GH/aquasecurity/trivy/releases/download/v0.76.1/trivy_0.76.1_Linux-64bit.deb
sudo apt-get install -y -q ./trivy_0.76.1_Linux-64bit.deb >/dev/null 2>&1
rm trivy_*.deb
CT=conftest_0.71.1_Linux_x86_64.tar.gz
curl -sSLO $GH/open-policy-agent/conftest/releases/download/v0.71.1/$CT
tar -xzf $CT -C ~/.local/bin conftest && rm $CT
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/tf-lab/setup/env.sh
source ~/tf-lab/setup/env.sh
tflint --version | head -1; trivy --version | head -1; conftest --version | head -1

Erwartet:

TFLint version 0.65.0
Version: 0.76.1
Conftest: 0.71.1

GH und CT kürzen nur die langen Adressen ab. Für eine andere Version tauschst du die Versionsnummer aus.

Fortschritt speichern? Kostenlos registrieren

Drill 2: fmt, validate, tflint

Zwei typische Nachlässigkeiten im Modul – eine verrutschte Einrückung und eine Variable, die niemand braucht:

cd ~/tf-lab/module/notes-docker
printf '.terraform/\n.terraform.lock.hcl\n' > ../.gitignore
sed -i 's/^  name     = "${var.name}-api/  name = "${var.name}-api/' main.tf
printf '\nvariable "debug" {\n  default = false\n}\n' >> variables.tf
tofu fmt -check -diff -no-color .; echo "fmt: $?"
tofu init -no-color >/dev/null
tofu validate -no-color
tflint --format compact | cut -c30-
tflint >/dev/null; echo "tflint: $?"

Erwartet (gekürzt):

main.tf
--- old/main.tf
+++ new/main.tf
...
-  name = "${var.name}-api-${each.key}"
+  name     = "${var.name}-api-${each.key}"
...
fmt: 3
Success! The configuration is valid.
`debug` variable has no type (terraform_typed_variables)
variable "debug" is declared but not used (terraform_unused_declarations)
tflint: 2
  • cut -c30- schneidet nur Datei, Zeile und Stufe vorn ab, damit die Meldung in eine Zeile passt.
  • tofu fmt -check ändert nichts und meldet sich mit einem Exit-Code ungleich 0. Ohne -check formatiert es die Dateien selbst.
  • validate ist zufrieden: Syntaktisch ist alles richtig. Erst tflint findet die tote Variable.
  • tflint bringt den Regelsatz für Terraform-Code schon mit. Für AWS, Azure und Google gibt es eigene Regelsätze, die man in .tflint.hcl einträgt.

Beides zurücknehmen:

git checkout main.tf variables.tf
tofu fmt -check . && tflint && echo sauber

Erwartet:

sauber

Fortschritt speichern? Kostenlos registrieren

Drill 3: Eingaben prüfen und testen

Ein Port unter 1024 ist im Labor ein Fehler. Eine validation in der Variablen fängt ihn ab, ein Test beweist es:

cd ~/tf-lab/module/notes-docker
cat > variables.tf <<'EOF'
variable "name" {
  description = "Präfix für alle Namen, z. B. blau"
  type        = string
}

variable "port" {
  description = "Port des Proxys auf 127.0.0.1"
  type        = number

  validation {
    condition     = var.port >= 1024 && var.port <= 65535
    error_message = "port muss zwischen 1024 und 65535 liegen."
  }
}

variable "instanzen" {
  description = "Namen der notes-api-Instanzen"
  type        = set(string)
  default     = ["a"]
}

variable "db_passwort" {
  type      = string
  sensitive = true
}
EOF
git diff --stat

Erwartet:

 notes-docker/variables.tf | 5 +++++
 1 file changed, 5 insertions(+)

Neu ist nur der Block validation in port – git diff bestätigt, dass sonst nichts anders ist.

Jetzt die Tests. Sie liegen in tests/ neben dem Modul:

mkdir -p tests
cat > tests/plan.tftest.hcl <<'EOF'
variables {
  name        = "test"
  port        = 8199
  db_passwort = "test-pw"
}

run "url_und_eine_instanz" {
  command = plan

  assert {
    condition     = output.url == "http://127.0.0.1:8199"
    error_message = "url stimmt nicht: ${output.url}"
  }

  assert {
    condition     = length(docker_container.api) == 1
    error_message = "Standard sollte genau eine Instanz sein."
  }
}

run "proxy_nur_lokal" {
  command = plan

  assert {
    condition     = docker_container.proxy.ports[0].ip == "127.0.0.1"
    error_message = "Der Proxy darf nur auf 127.0.0.1 lauschen."
  }
}

run "port_unter_1024_abgelehnt" {
  command = plan

  variables {
    port = 80
  }

  expect_failures = [var.port]
}
EOF
tofu test -no-color

Erwartet:

tests/plan.tftest.hcl... pass
  run "url_und_eine_instanz"... pass
  run "proxy_nur_lokal"... pass
  run "port_unter_1024_abgelehnt"... pass
Success! 3 passed, 0 failed.
  • variables oben gilt für alle run-Blöcke, ein variables im Block überschreibt einzelne Werte.
  • command = plan legt nichts an. Die Tests laufen in Sekunden und brauchen nur den Provider.
  • expect_failures dreht die Logik um: Der Test besteht, weil die Validierung von var.port anschlägt. So prüfst du, dass Schutzregeln wirklich greifen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Test, der wirklich anlegt

Ein Plan beweist nicht, dass notes danach antwortet. Ein run ohne command = plan legt echte Container an. Ein kleines Hilfsmodul ruft dann /healthz auf:

mkdir -p tests/http
cat > tests/http/main.tf <<'EOF'
terraform {
  required_providers {
    http = { source = "hashicorp/http", version = "~> 3.5" }
  }
}

variable "url" {
  type = string
}

data "http" "healthz" {
  url = var.url
  retry {
    attempts = 10
  }
}
EOF
cat > tests/apply.tftest.hcl <<'EOF'
variables {
  name        = "tst"
  port        = 8198
  db_passwort = "test-pw"
}

run "anlegen" {
  assert {
    condition     = length(output.container) == 3
    error_message = "Erwartet: db, proxy und eine api."
  }
}

run "healthz" {
  module {
    source = "./tests/http"
  }

  variables {
    url = "${run.anlegen.url}/healthz"
  }

  assert {
    condition     = data.http.healthz.status_code == 200
    error_message = "healthz antwortet nicht mit 200."
  }
}
EOF
tofu init -no-color >/dev/null
tofu test -no-color -filter=tests/apply.tftest.hcl
docker ps -a --format '{{.Names}}' | grep -c '^tst-'

Erwartet:

tests/apply.tftest.hcl... pass
  run "anlegen"... pass
  run "healthz"... pass
Success! 2 passed, 0 failed.
0
  • run.anlegen.url greift auf die Ausgänge eines früheren Laufs zu.
  • Nach dem letzten run zerstört OpenTofu alles, was der Test angelegt hat – darum zählt grep am Ende 0 Container.
  • Apply-Tests sind langsam und brauchen ein echtes Ziel. Viele Teams lassen sie nur nachts oder vor einem Release laufen, Plan-Tests bei jedem Commit.

Die neue Modulversion festhalten:

cd ~/tf-lab/module && git add -A
git -c user.name=Lab -c [email protected] commit -qm "Tests"
git tag v1.2.0 && git tag

Erwartet:

v1.0.0
v1.1.0
v1.2.0

Fortschritt speichern? Kostenlos registrieren

Drill 5: Trivy als Sicherheits-Gate

Trivy prüft Code auf bekannte Fehlkonfigurationen. Für die Docker-Ressourcen des Moduls hat es keine Regeln, für das Helm-Chart aus Tag 7 schon. Du prüfst eine Kopie:

mkdir -p ~/tf-lab/tag13 && cd ~/tf-lab/tag13
rm -rf chart && cp -r ~/tf-lab/code/charts/notes chart
trivy config --quiet --severity HIGH,CRITICAL chart \
  | grep -oE '^(Failures: .*|KSV-[0-9]+ \([A-Z]+\))'
trivy config --quiet --severity HIGH,CRITICAL --exit-code 1 chart >/dev/null
echo "Gate: $?"

Erwartet:

Failures: 3 (HIGH: 3, CRITICAL: 0)
KSV-0014 (HIGH)
KSV-0118 (HIGH)
KSV-0118 (HIGH)
Gate: 1
  • KSV-0014: Das Dateisystem des Containers ist beschreibbar. KSV-0118: Pod und Container laufen mit dem Standard-Sicherheitskontext, also möglicherweise als root.
  • --exit-code 1 macht aus dem Bericht ein Gate: In einer Pipeline bricht der Job ab.

Die Lösung ist ein securityContext für den Pod und für jeden Container. sed … r fügt eine Datei nach der passenden Zeile ein:

cat > pod-sc.yaml <<'EOF'
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532
        seccompProfile:
          type: RuntimeDefault
EOF
cat > container-sc.yaml <<'EOF'
          securityContext:
            readOnlyRootFilesystem: true
            allowPrivilegeEscalation: false
            capabilities:
              drop: ["ALL"]
EOF
D=chart/templates/deployment.yaml
sed -i '/^    spec:$/r pod-sc.yaml' $D
sed -i '/^          imagePullPolicy:/r container-sc.yaml' $D
grep -c 'securityContext' $D
trivy config --quiet --severity HIGH,CRITICAL --exit-code 1 chart >/dev/null
echo "Gate: $?"

Erwartet:

3
Gate: 0

Drei Treffer: einer für den Pod, je einer für den Migrations- und den API-Container.

Ohne --severity zeigt Trivy weiter drei Hinweise der Stufe LOW. Welche Stufe ein Gate auslöst, entscheidet das Team – und schreibt die Ausnahmen mit Begründung in eine .trivyignore.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Eigene Regeln für den Plan mit Conftest

Manche Regeln kennt kein Werkzeug, weil sie nur für euch gelten: „Kein Port auf 0.0.0.0“ und „Nichts löschen ohne Freigabe“. Conftest prüft sie gegen den Plan als JSON.

mkdir -p ~/tf-lab/policy
cat > ~/tf-lab/policy/plan.rego <<'EOF'
package main

deny contains msg if {
    some rc in input.resource_changes
    "delete" in rc.change.actions
    msg := sprintf("%s löscht – Freigabe nötig", [rc.address])
}

deny contains msg if {
    some rc in input.resource_changes
    rc.type == "docker_container"
    some p in rc.change.after.ports
    p.ip != "127.0.0.1"
    msg := sprintf("%s veröffentlicht Port %d auf %s", [rc.address, p.external, p.ip])
}
EOF
conftest fmt --check ~/tf-lab/policy && echo "Rego formatiert"

Erwartet:

Rego formatiert
  • input.resource_changes ist die Liste aller geplanten Änderungen. Jede hat eine Adresse, einen Typ und change.actions – etwa ["create"] oder ["delete", "create"] für eine Ersetzung.
  • Jede deny-Regel, die zutrifft, liefert eine Meldung. Eine Meldung reicht, damit Conftest mit Fehler endet.

Zuerst ein Plan ohne Änderung, dann einer, der in dev eine Instanz entfernt:

cd ~/tf-lab/tag10/envs/dev
tofu plan -no-color -out=ok.plan >/dev/null
tofu show -json ok.plan > ok.json
conftest test -p ~/tf-lab/policy ok.json --no-color
sed -i 's/^instanzen = \["a", "c"\]$/instanzen = ["a"]/' dev.auto.tfvars
tofu plan -no-color -out=weg.plan >/dev/null
tofu show -json weg.plan > weg.json
conftest test -p ~/tf-lab/policy weg.json --no-color; echo "Gate: $?"

Erwartet:

2 tests, 2 passed, 0 warnings, 0 failures, 0 exceptions
FAIL - weg.json - main - module.notes.docker_container.api["c"] löscht – Freigabe nötig
FAIL - weg.json - main - module.notes.docker_container.proxy löscht – Freigabe nötig
2 tests, 0 passed, 0 warnings, 2 failures, 0 exceptions
Gate: 1

Die zweite Meldung ist lehrreich: Der Proxy wird ersetzt (seine Konfiguration ändert sich), und eine Ersetzung enthält ein delete. Die Regel fängt also auch Ersetzungen – genau die, die in Tag 11 beinahe durchgerutscht wäre.

Aufräumen – die Plandateien enthalten sensible Werte im Klartext:

sed -i 's/^instanzen = \["a"\]$/instanzen = ["a", "c"]/' dev.auto.tfvars
grep -c 'lab-db-pw-123' weg.json
rm ok.plan ok.json weg.plan weg.json
tofu plan -no-color | tail -1

Erwartet:

1
No changes. Your infrastructure matches the configuration.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/tf-lab/module/notes-docker && tofu test -no-color | tail -1

Erwartet: drei Plan-Tests und zwei Apply-Tests.

Success! 5 passed, 0 failed.
cd ~/tf-lab/module && git tag --points-at HEAD

Erwartet:

v1.2.0
trivy config --quiet --severity HIGH,CRITICAL --exit-code 1 ~/tf-lab/tag13/chart \
  >/dev/null; echo $?

Erwartet:

0

Challenge

Schreibe einen Plan-Test zwei_instanzen: Mit instanzen = ["a", "b"] muss der Ausgang instanzen den Wert 2 haben und die nginx-Konfiguration beide Instanzen enthalten.

Hinweis: Die nginx-Konfiguration steht im Plan unter docker_container.proxy.upload. strcontains(text, teil) prüft, ob ein Text einen anderen enthält.

Lösung

cd ~/tf-lab/module/notes-docker
cat >> tests/plan.tftest.hcl <<'EOF'

run "zwei_instanzen" {
  command = plan

  variables {
    instanzen = ["a", "b"]
  }

  assert {
    condition     = output.instanzen == 2
    error_message = "Erwartet 2 Instanzen."
  }

  assert {
    condition = alltrue([
      for n in ["test-api-a", "test-api-b"] :
      strcontains(one(docker_container.proxy.upload).content, n)
    ])
    error_message = "nginx kennt nicht beide Instanzen."
  }
}
EOF
tofu test -no-color -filter=tests/plan.tftest.hcl | grep -E 'zwei_instanzen|Success'

Erwartet:

  run "zwei_instanzen"... pass
Success! 4 passed, 0 failed.

one() holt das einzige Element aus der Menge der upload-Blöcke. Ohne one() müsstest du einen Index raten – Mengen haben keinen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Prüfungen in der Reihenfolge der Kosten: fmt und tflint in Sekunden vor jedem Commit (pre-commit-Hook), Plan-Tests und Conftest in jedem Pull-Request, Apply-Tests nachts in einer eigenen Test-Umgebung.
  • Policy as Code zentral: Rego-Regeln liegen in einem eigenen Repository mit eigenen Reviews. Alle Pipelines ziehen dieselbe Version – wie ein Modul.
  • Plan-JSON ist ein Secret: tofu show -json enthält sensible Werte im Klartext. In CI gehört es in ein geschütztes Artefakt mit kurzer Aufbewahrung, nie in ein öffentliches Log.