Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Secrets – sensitive, ephemeral, write-only

Ziel: Sehen, wo ein Passwort überall landet, und es Schritt für Schritt aus Ausgabe, Code und State heraushalten. · Dauer: ca. 75 min · Voraussetzung: Tag 6, Tag 9

Briefing

  • Ein Secret kann an vier Stellen auslaufen: im Code (Git), in der Ausgabe (Plan, CI-Log), im State und in der Zielressource selbst. Die letzte Stelle ist gewollt, die anderen drei nicht.
  • sensitive = true versteckt Werte in der Ausgabe – nur dort. Im State stehen sie weiter im Klartext.
  • Ephemere Werte (ephemeral = true, ephemeral-Ressourcen) existieren nur während eines Laufs. OpenTofu schreibt sie weder in den Plan noch in den State.
  • Write-only-Attribute (Endung _wo) nehmen ephemere Werte an und geben sie an die Zielressource weiter, ohne sie zu speichern. Damit kommt ein Passwort in Kubernetes an, aber nie in den State.
                 Code   Ausgabe   State   Ziel
 normal           ✗       ✗        ✗       ✓      ✗ = Secret liegt hier offen
 sensitive        ✗       ✓        ✗       ✓
 ephemeral + _wo  ✓       ✓        ✓       ✓

Drill 1: Das Leck

Ein Kubernetes-Secret mit einem Passwort aus einer Variablen – so, wie man es zuerst schreiben würde. Jeder Block bekommt seine eigene Datei – so tauschst du in den nächsten Drills immer nur eine kleine Datei aus:

mkdir -p ~/tf-lab/tag12 && cd ~/tf-lab/tag12
sed 's|tag05/terraform.tfstate|tag12/terraform.tfstate|' ~/tf-lab/tag05/backend.tf \
  > backend.tf
cat > versions.tf <<'EOF'
terraform {
  required_version = ">= 1.13.0"
  required_providers {
    kubernetes = { source = "hashicorp/kubernetes", version = "~> 3.4" }
    random     = { source = "hashicorp/random", version = "~> 3.9" }
  }
}

provider "kubernetes" {
  config_path = "/etc/rancher/k3s/k3s.yaml"
}
EOF
cat > variables.tf <<'EOF'
variable "db_passwort" {
  type    = string
  default = "lab-geheim-123"
}
EOF
cat > namespace.tf <<'EOF'
resource "kubernetes_namespace_v1" "tag12" {
  metadata {
    name = "tag12"
  }
}
EOF
cat > secret.tf <<'EOF'
resource "kubernetes_secret_v1" "db" {
  metadata {
    name      = "db"
    namespace = kubernetes_namespace_v1.tag12.metadata[0].name
  }
  data = {
    password = var.db_passwort
  }
}
EOF
cat > outputs.tf <<'EOF'
output "passwort" {
  value = var.db_passwort
}
EOF
tofu init -no-color >/dev/null
tofu apply -auto-approve -no-color | grep -E ' data |passwort|Apply complete'
tofu state pull | grep -o 'lab-geheim-123' | wc -l

Erwartet:

      + data                           = (sensitive value)
  + passwort = "lab-geheim-123"
Apply complete! Resources: 2 added, 0 changed, 0 destroyed.
passwort = "lab-geheim-123"
2

Drei Lecks auf einmal:

  1. Code: Das Passwort steht als default in variables.tf – und damit in Git.
  2. Ausgabe: Der Output zeigt es im Plan und am Ende des Laufs. In einer CI-Pipeline steht es damit im Job-Log.
  3. State: Zweimal im Klartext – einmal im Secret, einmal im Output. Den Wert im Secret hat der Provider zwar als sensitiv markiert, in den State schreibt OpenTofu ihn trotzdem.

Fortschritt speichern? Kostenlos registrieren

Drill 2: sensitive

Erster Schritt: Variable als sensitiv markieren.

cat > variables.tf <<'EOF'
variable "db_passwort" {
  type      = string
  default   = "lab-geheim-123"
  sensitive = true
}
EOF
tofu plan -no-color 2>&1 | grep '^Error'

Erwartet:

Error: Output refers to sensitive values

OpenTofu verweigert den Output: Ein sensitiver Wert darf nur über einen ebenfalls sensitiven Output hinaus. Das ist Absicht – Sensitivität „vererbt“ sich und lässt sich nicht aus Versehen verlieren.

cat > outputs.tf <<'EOF'
output "passwort" {
  value     = var.db_passwort
  sensitive = true
}
EOF
tofu apply -auto-approve -no-color | grep -E 'passwort|Apply complete'
tofu output passwort
tofu output -raw passwort; echo
tofu state pull | grep -o 'lab-geheim-123' | wc -l

Erwartet:

Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
passwort = <sensitive>
"lab-geheim-123"
lab-geheim-123
2
  • Die Zusammenfassung am Ende des Laufs zeigt nur noch <sensitive> – das CI-Log ist sauber.
  • Wer gezielt nach dem Output fragt (tofu output passwort, -raw) oder den State liest, bekommt weiter den Klartext. sensitive schützt vor Blicken, nicht vor Zugriff.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Raus aus dem Code

Der Wert gehört nicht ins Repository. Zwei übliche Wege: eine Werte-Datei, die Git ignoriert, oder eine Umgebungsvariable.

cat > variables.tf <<'EOF'
variable "db_passwort" {
  type      = string
  sensitive = true
}
EOF
printf 'db_passwort = "lab-geheim-456"\n' > secret.auto.tfvars
printf '*.tfvars\n.terraform/\n' > .gitignore
tofu plan -no-color | grep -E 'will be|Plan:'
rm secret.auto.tfvars
export TF_VAR_db_passwort=lab-geheim-123
tofu plan -no-color | tail -1

Erwartet:

  # kubernetes_secret_v1.db will be updated in-place
Plan: 0 to add, 1 to change, 0 to destroy.
No changes. Your infrastructure matches the configuration.
  • *.auto.tfvars liest OpenTofu automatisch. Mit dem Eintrag in .gitignore gelangt die Datei nicht ins Repository – sie bleibt aber im Klartext auf der Platte.
  • TF_VAR_<name> setzt eine Variable aus der Umgebung. In CI kommt der Wert so aus dem Secret-Speicher der Pipeline, nicht aus einer Datei.
  • Ohne Wert und ohne default fragt OpenTofu interaktiv nach – in einer Pipeline bricht der Lauf ab.

Damit sind Code und Ausgabe sauber. Bleibt der State.

Fortschritt speichern? Kostenlos registrieren

Drill 4: ephemeral und write-only

Jetzt soll das Passwort gar nicht mehr im State landen. Dafür wird die Variable ephemer:

cat > variables.tf <<'EOF'
variable "db_passwort" {
  type      = string
  sensitive = true
  ephemeral = true
}
EOF
tofu plan -no-color 2>&1 | grep '^Error'

Erwartet:

Error: Output does not allow ephemeral value
Error: Ephemeral value used in non-ephemeral context

Ein ephemerer Wert darf nicht in einen Output und nicht in ein normales Attribut wie data – beide landen im State. Erlaubt sind nur Ziele, die nichts speichern: write-only-Attribute. Beim Kubernetes-Secret heißen sie data_wo und data_wo_revision.

rm outputs.tf
cat > secret.tf <<'EOF'
resource "kubernetes_secret_v1" "db" {
  metadata {
    name      = "db"
    namespace = kubernetes_namespace_v1.tag12.metadata[0].name
  }
  data_wo = {
    password = var.db_passwort
  }
  data_wo_revision = 1
}
EOF
tofu apply -auto-approve -no-color | grep -E 'data|Apply complete'
tofu state pull | grep -o 'lab-geheim-123' | wc -l
kubectl -n tag12 get secret db -o jsonpath='{.data.password}' | base64 -d; echo

Der Output fällt weg, das Secret bekommt data_wo statt data und eine data_wo_revision.

Erwartet:

      ~ binary_data_wo                 = (write-only attribute)
      ~ data_wo                        = (write-only attribute)
      + data_wo_revision               = 1
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
1
lab-geheim-123

Kubernetes hat den Wert, der Plan zeigt nur „write-only attribute“ – aber im State steht das Passwort immer noch einmal. data ist beim Kubernetes-Secret optional und berechnet: Lässt du es weg, behält OpenTofu den alten Wert im State. Was einmal im State steht, bleibt dort, bis die Ressource neu entsteht:

tofu apply -auto-approve -no-color -replace=kubernetes_secret_v1.db \
  | grep -E 'replaced|Apply complete'
tofu state pull | grep -o 'lab-geheim-123' | wc -l
kubectl -n tag12 get secret db -o jsonpath='{.data.password}' | base64 -d; echo

Erwartet:

  # kubernetes_secret_v1.db will be replaced, as requested
Apply complete! Resources: 1 added, 0 changed, 1 destroyed.
0
lab-geheim-123

Jetzt steht das Passwort nirgends mehr im State. Lehre: Secrets von Anfang an write-only anlegen – nachträglich kostet es eine Ersetzung, und alte Stände des States (Versionen im Bucket, Backups) enthalten den Wert weiterhin.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Rotieren mit data_wo_revision

Weil OpenTofu den Wert nicht speichert, kann es eine Änderung auch nicht erkennen:

export TF_VAR_db_passwort=lab-geheim-789
tofu plan -no-color | tail -1

Erwartet:

No changes. Your infrastructure matches the configuration.

Ein neues Passwort, aber kein Plan. Die Zahl in data_wo_revision ist der Hebel: Erhöhst du sie, schreibt OpenTofu den write-only-Wert erneut.

sed -i 's/data_wo_revision = 1/data_wo_revision = 2/' secret.tf
tofu apply -auto-approve -no-color | grep -E 'revision|Apply complete'
kubectl -n tag12 get secret db -o jsonpath='{.data.password}' | base64 -d; echo

Erwartet:

      ~ data_wo_revision = 1 -> 2
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
lab-geheim-789

Die Revision steht im Code und im State – das Passwort nicht. Ein Review sieht „hier wurde rotiert“, aber nicht, worauf.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/tf-lab/tag12 && tofu state pull | grep -o 'lab-geheim' | wc -l

Erwartet:

0
kubectl -n tag12 get secret db -o jsonpath='{.data.password}' | base64 -d; echo

Erwartet:

lab-geheim-789
grep -l 'lab-geheim' *.tf | wc -l

Erwartet:

0

Challenge

Niemand soll das Passwort mehr ausdenken müssen: Ein zweites Secret api im Namespace tag12 bekommt ein zufälliges Passwort mit 24 Zeichen – ohne dass es im State steht.

Hinweis: Der Provider hashicorp/random bietet random_password auch als ephemere Ressource an: ephemeral "random_password" "…" { … }. Ihr Ergebnis steht in .result.

Lösung

cd ~/tf-lab/tag12
cat > api.tf <<'EOF'
ephemeral "random_password" "api" {
  length  = 24
  special = false
}

resource "kubernetes_secret_v1" "api" {
  metadata {
    name      = "api"
    namespace = kubernetes_namespace_v1.tag12.metadata[0].name
  }
  data_wo = {
    password = ephemeral.random_password.api.result
  }
  data_wo_revision = 1
}
EOF
tofu init -no-color >/dev/null
tofu apply -auto-approve -no-color | grep 'Apply complete'
API_PW=$(kubectl -n tag12 get secret api -o jsonpath='{.data.password}' | base64 -d)
echo "${#API_PW}"
tofu state pull | grep -c "$API_PW"
tofu plan -no-color | tail -1

Erwartet:

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
24
0
No changes. Your infrastructure matches the configuration.

Bei jedem Lauf erzeugt die ephemere Ressource ein neues Passwort – geschrieben wird es aber nur, wenn sich data_wo_revision ändert. Darum bleibt der Plan leer.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • State verschlüsseln und Zugriff beschränken: Nicht jeder Provider kennt schon write-only-Attribute. Die State-Verschlüsselung aus Tag 9 und enge Rechte auf dem Bucket bleiben die zweite Verteidigungslinie.
  • Secrets aus einem Tresor: Statt TF_VAR_ aus der Pipeline holen viele Teams Werte als ephemere Ressource direkt aus Vault oder OpenBao. Dann kennt nicht einmal die Pipeline das Passwort.
  • Rotation planen: data_wo_revision gehört in den Rotationsprozess. Wer sie hochzählt, braucht dieselbe Freigabe wie für jede andere Änderung an prod.