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
applytippt. · 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
validatenicht prüft – etwa Variablen ohne Typ oder Variablen, die niemand nutzt. tofu testführt*.tftest.hcl-Dateien aus. Jederrun-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 -1Erwartet:
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-checkformatiert es die Dateien selbst.validateist 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.hcleinträgt.
Beides zurücknehmen:
git checkout main.tf variables.tf
tofu fmt -check . && tflint && echo sauberErwartet:
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 --statErwartet:
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-colorErwartet:
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.
variablesoben gilt für allerun-Blöcke, einvariablesim Block überschreibt einzelne Werte.command = planlegt nichts an. Die Tests laufen in Sekunden und brauchen nur den Provider.expect_failuresdreht die Logik um: Der Test besteht, weil die Validierung vonvar.portanschlä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.urlgreift auf die Ausgänge eines früheren Laufs zu.- Nach dem letzten
runzerstört OpenTofu alles, was der Test angelegt hat – darum zähltgrepam 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 tagErwartet:
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 1macht 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_changesist die Liste aller geplanten Änderungen. Jede hat eine Adresse, einen Typ undchange.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 -1Erwartet:
1
No changes. Your infrastructure matches the configuration.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cd ~/tf-lab/module/notes-docker && tofu test -no-color | tail -1Erwartet: drei Plan-Tests und zwei Apply-Tests.
Success! 5 passed, 0 failed.
cd ~/tf-lab/module && git tag --points-at HEADErwartet:
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 -jsonenthält sensible Werte im Klartext. In CI gehört es in ein geschütztes Artefakt mit kurzer Aufbewahrung, nie in ein öffentliches Log.