Tag 2: Variablen, Outputs, locals
Ziel: Eine Konfiguration mit Variablen von außen steuern, Werte prüfen, mit
localsund Ausdrücken rechnen, Ergebnisse als Outputs ausgeben und Dateien aus Vorlagen erzeugen. · Dauer: ca. 75 min · Voraussetzung: Tag 1
Briefing
variableist der Eingang einer Konfiguration: mit Typ, Standardwert, Beschreibung und Prüfung (validation). Gelesen wird sie alsvar.name.- Werte kommen aus
-var, aus*.tfvars-Dateien oder aus UmgebungsvariablenTF_VAR_name. localssind Zwischenergebnisse innerhalb der Konfiguration (local.name),outputder Ausgang: Werte, die nachapplyangezeigt und von anderen genutzt werden.- HCL kennt Ausdrücke:
"${var.a}-x",var.p ? 1 : 2,[for k, v in map : …], Funktionen wieupper,join,merge,templatefile.
-var / *.tfvars / TF_VAR_* ─► variable ─► locals ─► resource ─► output
└ validation └ templatefile("index.html.tftpl")
Drill 1: Variablen
mkdir -p ~/tf-lab/tag02 && cd ~/tf-lab/tag02
cat > versions.tf <<'EOF'
terraform {
required_version = ">= 1.13.0"
required_providers {
docker = {
source = "kreuzwerker/docker"
version = "~> 4.6"
}
}
}
provider "docker" {}
EOF
cat > variables.tf <<'EOF'
variable "umgebung" {
description = "Name der Umgebung, Teil aller Namen"
type = string
default = "dev"
validation {
condition = contains(["dev", "test", "prod"], var.umgebung)
error_message = "umgebung muss dev, test oder prod sein."
}
}
variable "port" {
description = "Port auf 127.0.0.1, unter dem die Seite erreichbar ist"
type = number
default = 8082
validation {
condition = var.port >= 1024 && var.port <= 65535
error_message = "port muss zwischen 1024 und 65535 liegen."
}
}
variable "nginx_version" {
type = string
default = "1.31.8-alpine"
}
variable "team" {
description = "Wer für die Umgebung verantwortlich ist"
type = map(string)
default = { name = "Plattform", kontakt = "[email protected]" }
}
EOF
cat > main.tf <<'EOF'
locals {
name = "notes-web-${var.umgebung}"
labels = {
umgebung = var.umgebung
team = var.team.name
verwaltet_von = "opentofu"
}
}
resource "docker_image" "nginx" {
name = "nginx:${var.nginx_version}"
keep_locally = true
}
resource "docker_container" "web" {
name = local.name
image = docker_image.nginx.image_id
ports {
internal = 80
external = var.port
ip = "127.0.0.1"
}
dynamic "labels" {
for_each = local.labels
content {
label = labels.key
value = labels.value
}
}
}
EOF
tofu init -no-color >/dev/null && tofu fmt && tofu validate -no-color
tofu plan -no-color | grep -E 'notes-web|external|Plan:'Erwartet:
main.tf
Success! The configuration is valid.
+ name = "notes-web-dev"
+ external = 8082
Plan: 2 to add, 0 to change, 0 to destroy.
tofu fmthatmain.tfumformatiert: Es richtet die=inlabelsaneinander aus. Es gibt aus, welche Dateien es geändert hat.dynamic "labels"erzeugt für jedes Element der Map einenlabels-Block – mehr dazu an Tag 4.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Woher die Werte kommen
tofu plan -no-color -var umgebung=prod | grep 'notes-web'
echo 'umgebung = "test"' > test.tfvars
tofu plan -no-color -var-file=test.tfvars | grep 'notes-web'
TF_VAR_port=9090 tofu plan -no-color | grep 'external'
tofu plan -no-color -var umgebung=staging 2>&1 | grep -A2 'Invalid value'
tofu plan -no-color -var port=80 2>&1 | grep -E 'port muss'Erwartet:
+ name = "notes-web-prod"
+ name = "notes-web-test"
+ external = 9090
Error: Invalid value for variable
on variables.tf line 1:
port muss zwischen 1024 und 65535 liegen.
| Quelle | Vorrang |
|---|---|
default in der Variable |
niedrigster |
TF_VAR_name |
|
terraform.tfvars, *.auto.tfvars
(automatisch geladen) |
|
-var-file=… |
|
-var name=… |
höchster |
Die Prüfungen laufen, bevor OpenTofu irgendetwas plant – ein falscher Wert kommt nie bei Docker an.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Outputs
cat > outputs.tf <<'EOF'
output "url" {
description = "Adresse der Seite"
value = "http://127.0.0.1:${var.port}/"
}
output "container" {
value = {
name = docker_container.web.name
id = substr(docker_container.web.id, 0, 12)
labels = local.labels
}
}
EOF
tofu apply -auto-approve -no-color | grep -A12 '^Outputs:'
curl -s -o /dev/null -w '%{http_code}\n' "$(tofu output -raw url)"
tofu output -json container | jq -c '.labels'Erwartet (die ID weicht ab):
Outputs:
container = {
"id" = "6efb27a9be25"
"labels" = {
"team" = "Plattform"
"umgebung" = "dev"
"verwaltet_von" = "opentofu"
}
"name" = "notes-web-dev"
}
url = "http://127.0.0.1:8082/"
200
{"team":"Plattform","umgebung":"dev","verwaltet_von":"opentofu"}
tofu output -raw liefert einen Text ohne
Anführungszeichen – genau richtig für Skripte. -json gibt
Maps und Listen so aus, dass jq sie lesen kann.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Ausdrücke und Vorlagen
tofu console kennt im Projektordner alle Variablen,
locals und Ressourcen:
cat <<'EOF' | tofu console
local.name
upper(var.team.name)
var.umgebung == "prod" ? "streng" : "locker"
[for k, v in local.labels : "${k}=${v}"]
join(",", sort(keys(local.labels)))
EOFErwartet:
"notes-web-dev"
"PLATTFORM"
"locker"
[
"team=Plattform",
"umgebung=dev",
"verwaltet_von=opentofu",
]
"team,umgebung,verwaltet_von"
Jetzt bekommt die Seite einen eigenen Inhalt aus einer Vorlage:
cat > index.html.tftpl <<'EOF'
<h1>notes – ${upper(umgebung)}</h1>
<p>Verantwortlich: ${team.name} (${team.kontakt})</p>
%{ for k in sort(keys(labels)) ~}
<p>${k}: ${labels[k]}</p>
%{ endfor ~}
EOF
cat > web.tf <<'EOF'
locals {
startseite = templatefile("${path.module}/index.html.tftpl", {
umgebung = var.umgebung
team = var.team
labels = local.labels
})
}
EOF
cat > upload.txt <<'EOF'
upload {
file = "/usr/share/nginx/html/index.html"
content = local.startseite
}
EOF
sed -i '/^ dynamic "labels" {$/e cat upload.txt' main.tf
grep -B1 -A3 'upload {' main.tf
tofu fmt >/dev/null
tofu apply -auto-approve -no-color | grep -E 'must be replaced|Apply complete' \
| sed 's/^ *//'
curl -s "$(tofu output -raw url)"Erwartet:
}
upload {
file = "/usr/share/nginx/html/index.html"
content = local.startseite
}
# docker_container.web must be replaced
Apply complete! Resources: 1 added, 0 changed, 1 destroyed.
<h1>notes – DEV</h1>
<p>Verantwortlich: Plattform ([email protected])</p>
<p>team: Plattform</p>
<p>umgebung: dev</p>
<p>verwaltet_von: opentofu</p>
sed '/muster/e cat datei'fügt den Inhalt der Datei vor der passenden Zeile ein.templatefile(datei, werte)füllt eine Vorlage:${…}setzt Werte ein,%{ for }wiederholt Zeilen,~entfernt den Zeilenumbruch danach.path.moduleist der Ordner der Konfiguration – damit funktioniert der Pfad, egal von wotofuaufgerufen wird.- Eine neue Datei im Container ersetzt den Container: Docker kann Inhalte nur beim Anlegen hochladen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
tofu output -raw url; echoErwartet:
http://127.0.0.1:8082/
tofu plan -no-color -detailed-exitcode >/dev/null; echo "Exit: $?"Erwartet: Konfiguration und Docker stimmen überein (0 = nichts zu tun, 2 = Änderungen).
Exit: 0
tofu plan -no-color -var umgebung=qa 2>&1 | grep -c 'umgebung muss'Erwartet:
1
Challenge
Leg eine Datei prod.tfvars an, mit der dieselbe
Konfiguration eine Umgebung prod auf Port 8083 mit dem Team
„Betrieb” ([email protected]) beschreibt. Zeig im Plan nur
den Namen, den Port und die Kontaktadresse – ohne etwas anzulegen.
Hinweis: Eine Map wird in .tfvars wie
in HCL geschrieben.
Lösung
cat > prod.tfvars <<'EOF'
umgebung = "prod"
port = 8083
team = {
name = "Betrieb"
kontakt = "[email protected]"
}
EOF
tofu plan -no-color -var-file=prod.tfvars | grep -E 'notes-web-prod|Plan:'Erwartet (Leerzeichen gekürzt):
~ name = "notes-web-dev" -> "notes-web-prod" # forces replacement
Plan: 1 to add, 0 to change, 1 to destroy.
~ name = "notes-web-dev" -> "notes-web-prod"
Die letzte Zeile gehört zu den Outputs: Auch dort zeigt der Plan, was
sich ändern würde. Ohne grep siehst du auch den neuen Port
und die geänderte Startseite.
Derselbe Code, andere Werte – das ist die Grundlage für Umgebungen (Tag 10). Achtung: Mit demselben State würde der Plan die dev-Seite ersetzen, nicht eine zweite anlegen. Dafür braucht jede Umgebung ihren eigenen State.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Variablen dokumentieren:
descriptionundvalidationsind Teil der Schnittstelle. Werkzeuge wieterraform-docserzeugen daraus die Doku eines Moduls. - Keine Secrets in
.tfvarsim Git: Passwörter kommen ausTF_VAR_…, einer Secret-Datei außerhalb des Repos oder einem Vault (Tag 12). - Einheitliche Labels und Tags über
locals– Kostenstelle, Team, Umgebung – machen später Abrechnung und Aufräumen möglich.