Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: Variablen, Outputs, locals

Ziel: Eine Konfiguration mit Variablen von außen steuern, Werte prüfen, mit locals und Ausdrücken rechnen, Ergebnisse als Outputs ausgeben und Dateien aus Vorlagen erzeugen. · Dauer: ca. 75 min · Voraussetzung: Tag 1

Briefing

  • variable ist der Eingang einer Konfiguration: mit Typ, Standardwert, Beschreibung und Prüfung (validation). Gelesen wird sie als var.name.
  • Werte kommen aus -var, aus *.tfvars-Dateien oder aus Umgebungsvariablen TF_VAR_name.
  • locals sind Zwischenergebnisse innerhalb der Konfiguration (local.name), output der Ausgang: Werte, die nach apply angezeigt und von anderen genutzt werden.
  • HCL kennt Ausdrücke: "${var.a}-x", var.p ? 1 : 2, [for k, v in map : …], Funktionen wie upper, 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 fmt hat main.tf umformatiert: Es richtet die = in labels aneinander aus. Es gibt aus, welche Dateien es geändert hat.
  • dynamic "labels" erzeugt für jedes Element der Map einen labels-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)))
EOF

Erwartet:

"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.module ist der Ordner der Konfiguration – damit funktioniert der Pfad, egal von wo tofu aufgerufen 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; echo

Erwartet:

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: description und validation sind Teil der Schnittstelle. Werkzeuge wie terraform-docs erzeugen daraus die Doku eines Moduls.
  • Keine Secrets in .tfvars im Git: Passwörter kommen aus TF_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.