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 = trueversteckt 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 -lErwartet:
+ 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:
- Code: Das Passwort steht als
defaultinvariables.tf– und damit in Git. - Ausgabe: Der Output zeigt es im Plan und am Ende des Laufs. In einer CI-Pipeline steht es damit im Job-Log.
- 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 -lErwartet:
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.sensitiveschü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 -1Erwartet:
# 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.tfvarsliest OpenTofu automatisch. Mit dem Eintrag in.gitignoregelangt 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
defaultfragt 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; echoDer 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; echoErwartet:
# 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 -1Erwartet:
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; echoErwartet:
~ 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 -lErwartet:
0
kubectl -n tag12 get secret db -o jsonpath='{.data.password}' | base64 -d; echoErwartet:
lab-geheim-789
grep -l 'lab-geheim' *.tf | wc -lErwartet:
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 -1Erwartet:
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_revisiongehört in den Rotationsprozess. Wer sie hochzählt, braucht dieselbe Freigabe wie für jede andere Änderung an prod.