Tag 13: GitOps und Infrastruktur-Pipelines
Ziel: Im Git-Repo stehen nur Verweise auf Secrets (ExternalSecret), und OpenTofu liest Secrets aus OpenBao mit kurzlebigem Pipeline-Token, ohne sie im State abzulegen. · Dauer: ca. 90 min · Voraussetzung: Tag 3, Tag 10
Briefing
- GitOps heißt: Git ist die Wahrheit. Secrets gehören trotzdem nicht hinein, auch nicht verschlüsselt, wenn OpenBao schon die Quelle ist.
- Argo CD synchronisiert ExternalSecrets, der ESO im Cluster holt die Werte (Tag 3). Argo CD sieht nie ein Secret.
argocd-vault-pluginersetzt Platzhalter beim Rendern. Die Secrets liegen dann im gerenderten Manifest und im Cache von Argo CD.- OpenTofu spricht OpenBao über den Provider
hashicorp/vault. Data-Sources schreiben Secrets in den State, Ephemeral Resources nicht.
Git: ExternalSecret ──▶ Argo CD ──▶ Cluster ──▶ ESO ──▶ OpenBao ──▶ K8s-Secret
Pipeline: JWT ──▶ tofu (auth_login_jwt) ──▶ OpenBao ──▶ ephemeral ──▶ write-only
Drill 1: GitOps-Repo ohne Secrets
Das Repo enthält den Verweis auf das Secret und die App. Sync-Waves
legen die Reihenfolge fest: erst das ExternalSecret (Welle
-1), dann das Deployment.
mkdir -p ~/secrets-lab/tag13/gitops/{apps,shop} && cd ~/secrets-lab/tag13/gitops
cat > shop/externalsecret.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
name: shop-api-gitops
namespace: shop
annotations:
argocd.argoproj.io/sync-wave: "-1"
spec:
refreshInterval: 1m
secretStoreRef:
kind: SecretStore
name: openbao # SecretStore aus Tag 3
target:
name: shop-api-gitops
data:
- secretKey: DB_PASSWORD
remoteRef:
key: shop/api
property: db_password
EOF
cat > shop/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-gitops
namespace: shop
annotations:
argocd.argoproj.io/sync-wave: "0"
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-gitops}
template:
metadata:
labels: {app: shop-api-gitops}
spec:
serviceAccountName: shop-api
containers:
- name: app
image: busybox:1.37
command: ["sh", "-c", "echo Secret da: ${DB_PASSWORD:+ja}; sleep 3600"]
envFrom:
- secretRef:
name: shop-api-gitops
EOF
git init -q && git add -A && git commit -qm "shop: ExternalSecret + Deployment"
git grep -n -E 'lab-[a-z-]*-[0-9]+' && echo "✘ Klartext im Repo" \
|| echo "✔ kein Secret-Wert im Repo"Erwartet:
✔ kein Secret-Wert im Repo
Ohne Argo CD prüfst du den ESO-Teil direkt im Cluster aus Tag 3:
kubectl apply -f shop/externalsecret.yaml
kubectl -n shop wait externalsecret/shop-api-gitops --for=condition=Ready --timeout=60s
kubectl -n shop get secret shop-api-gitops -o jsonpath='{.data.DB_PASSWORD}' \
| base64 -d; echoErwartet (gekürzt, kann je nach Version abweichen):
externalsecret.external-secrets.io/shop-api-gitops created
externalsecret.external-secrets.io/shop-api-gitops condition met
lab-db-pw-123
Fortschritt speichern? Kostenlos registrieren
Drill 2: Argo CD – App-of-Apps, Sync-Waves, Health
Eine Root-Application zeigt auf apps/, jede Datei dort
ist eine Kind-Application (nicht ausgeführt, gegen Argo-CD-Doku
geprüft):
cat > apps/shop.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: shop
namespace: argocd
finalizers:
- resources-finalizer.argocd.argoproj.io
spec:
project: default
source:
repoURL: https://git.example.com/acme/gitops.git
targetRevision: main
path: shop
destination:
server: https://kubernetes.default.svc
namespace: shop
syncPolicy:
automated:
prune: true
selfHeal: true
EOF
cat > root.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: root
namespace: argocd
spec:
project: default
source:
repoURL: https://git.example.com/acme/gitops.git
targetRevision: main
path: apps
destination:
server: https://kubernetes.default.svc
namespace: argocd
syncPolicy:
automated: {}
EOF
git add -A && git commit -qm "Argo CD: App-of-Apps" && git rev-list --count HEADErwartet:
2
Argo CD bringt für ExternalSecret einen eingebauten
Health-Check mit: Ready=True ist Healthy,
Ready=False ist Degraded. Weil Welle
-1 erst gesund sein muss, startet das Deployment nie mit
fehlendem Secret. Im UI bzw. per CLI sieht das so aus (gekürzt, kann je
nach Version abweichen):
$ argocd app get shop
GROUP KIND NAMESPACE NAME STATUS HEALTH
external-secrets.io ExternalSecret shop shop-api-gitops Synced Healthy
apps Deployment shop shop-api-gitops Synced Healthy
Achtung: Das von ESO erzeugte K8s-Secret steht nicht in Git, Argo CD verwaltet es nicht. Mit
creationPolicy: Owner(Standard) trägt es eineownerReferenceauf das ExternalSecret und verschwindet mit ihm, wenn Argo CD das ExternalSecret prunt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: argocd-vault-plugin – die Alternative abwägen
Beim Plugin steht der Platzhalter im Manifest, Argo CD ersetzt ihn beim Rendern (Muster, nicht ausführen):
apiVersion: v1
kind: Secret
metadata:
name: shop-api-avp
namespace: shop
type: Opaque
stringData:
DB_PASSWORD: <path:secret/data/shop/api#db_password>Das Plugin läuft im Repo-Server mit AVP_TYPE=vault,
VAULT_ADDR und z. B. AVP_AUTH_TYPE=k8s plus
AVP_K8S_ROLE. Der Vergleich:
| Kriterium | ESO (Drill 1) | argocd-vault-plugin |
|---|---|---|
| Wer liest OpenBao? | ESO im Zielcluster | Argo-CD-Repo-Server |
| Secret im Argo-CD-Cache | nein | ja, Klartext im Redis-Cache |
| Rotation | refreshInterval, ohne Git-Commit |
erst beim nächsten Rendern |
| Projektstatus | aktiv | letzte Version 1.18.1 (Juni 2024) |
Die Argo-CD-Doku rät ausdrücklich von Secret-Injektion beim Rendern ab und empfiehlt Lösungen im Zielcluster wie ESO.
Fortschritt speichern? Kostenlos registrieren
Drill 4: OpenTofu gegen OpenBao – und das State-Problem
Der Provider hashicorp/vault spricht die Vault-API und
funktioniert mit OpenBao. Er liest VAULT_ADDR und
VAULT_TOKEN, nicht die BAO_*-Variablen. Zuerst
die Pipeline-Rolle für das Infra-Repo (Admin-Schritt):
cd ~/secrets-lab/tag13 && cp ../tag10/{mint-jwt.sh,ci-issuer.key} .
export KEY=$PWD/ci-issuer.key # Lab-Issuer-Schlüssel, auch aus Unterordnern
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao policy write tofu-plan - <<'HCL'
path "secret/data/ci/deploy" {
capabilities = ["read"]
}
path "secret/data/ci/tofu/*" {
capabilities = ["create", "update", "read"]
}
path "secret/metadata/ci/tofu/*" {
capabilities = ["read", "delete"]
}
HCL
bao write auth/jwt-ci/role/tofu-main - <<'EOF'
{
"role_type": "jwt", "user_claim": "sub", "bound_audiences": ["openbao"],
"bound_claims": {"repository": "acme/infra", "ref": "refs/heads/main"},
"token_policies": ["tofu-plan"], "token_ttl": "20m", "token_max_ttl": "30m"
}
EOF
INFRA="repository=acme/infra sub=repo:acme/infra:ref:refs/heads/main"Erwartet:
Success! Uploaded policy: tofu-plan
Success! Data written to: auth/jwt-ci/role/tofu-main
Jetzt der naive Weg mit einer Data-Source:
mkdir -p tofu-data && cd tofu-data
cat > main.tf <<'EOF'
terraform {
required_providers {
vault = {
source = "hashicorp/vault"
version = "~> 5.12"
}
}
}
provider "vault" {}
data "vault_kv_secret_v2" "deploy" {
mount = "secret"
name = "ci/deploy"
}
output "deploy_keys" {
value = nonsensitive(keys(data.vault_kv_secret_v2.deploy.data))
}
EOF
tofu init -no-color >/dev/null && echo "✔ init"
export VAULT_ADDR=$BAO_ADDR
export VAULT_TOKEN=$(BAO_TOKEN= bao write -field=token auth/jwt-ci/login \
role=tofu-main jwt="$(../mint-jwt.sh $INFRA)")
tofu apply -auto-approve -no-color 2>&1 | grep -E '^(Error|Deprecated)' | sort -uErwartet:
✔ init
Deprecated. Please use new Ephemeral KVV2 Secret resource
Error: failed to create limited child token: Error making API request.
Zwei Lektionen: Die Data-Source ist abgekündigt, und der Provider
erzeugt standardmäßig einen Child-Token. Das darf der Pipeline-Token
nicht (zu Recht). skip_child_token schaltet das ab:
python3 - <<'PY'
s = open("main.tf").read()
s = s.replace('provider "vault" {}', 'provider "vault" {\n skip_child_token = true\n}')
open("main.tf", "w").write(s)
PY
tofu apply -auto-approve -no-color 2>&1 | sed -n '/^Outputs:/,$p'
grep -c lab-reg-pw terraform.tfstate
jq '.resources[0].instances[0].attributes.data' terraform.tfstateErwartet:
Outputs:
deploy_keys = tolist([
"kubeconfig_token",
"registry_password",
])
2
{
"kubeconfig_token": "lab-kube-token",
"registry_password": "lab-reg-pw"
}
sensitive versteckt den Wert nur in der Ausgabe. Im
State steht er im Klartext, und der State liegt meist in einem Bucket,
den viele lesen können.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Ephemeral Resource und Write-only-Argument
OpenTofu ab 1.11 kennt ephemeral-Blöcke: Der Wert
existiert nur während des Laufs. Verwenden darfst du ihn nur an
ephemeren Stellen, etwa in Provider-Konfigurationen,
locals, anderen ephemeren Werten oder Write-only-Argumenten
(*_wo). Beispiel: Das Registry-Passwort wird in einen
App-Pfad kopiert, ohne je im State zu landen.
mkdir -p ../tofu-eph && cd ../tofu-eph
cat > main.tf <<'EOF'
terraform {
required_providers {
vault = {
source = "hashicorp/vault"
version = "~> 5.12"
}
}
}
provider "vault" {
skip_child_token = true
}
ephemeral "vault_kv_secret_v2" "deploy" {
mount = "secret"
name = "ci/deploy"
}
# Verbraucher: Write-only-Argument, landet nie im State
resource "vault_kv_secret_v2" "app_registry" {
mount = "secret"
name = "ci/tofu/app-registry"
data_json_wo = jsonencode({
password = ephemeral.vault_kv_secret_v2.deploy.data.registry_password
})
data_json_wo_version = 1
}
EOF
tofu init -no-color >/dev/null && echo "✔ init"
tofu apply -auto-approve -no-color 2>&1 | grep -E 'Opening|Apply complete'
grep -c lab-reg-pw terraform.tfstate
jq '.resources[0].instances[0].attributes | {data_json_wo, data_json_wo_version}' \
terraform.tfstate
BAO_TOKEN=root bao kv get -field=password secret/ci/tofu/app-registry; echoErwartet:
✔ init
ephemeral.vault_kv_secret_v2.deploy: Opening...
ephemeral.vault_kv_secret_v2.deploy: Opening...
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
0
{
"data_json_wo": null,
"data_json_wo_version": 1
}
lab-reg-pw
Das Secret wird zweimal geöffnet, einmal für den Plan, einmal für das
Apply, und danach wieder geschlossen. Neue Werte schreibst du, indem du
data_json_wo_version hochzählst. Der Provider kann
Write-only-Werte nicht vergleichen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Kurzlebiger Token direkt im Provider
Statt den Token vorher per bao zu holen, meldet sich der
Provider selbst mit dem Pipeline-JWT an. Das JWT kommt aus
TERRAFORM_VAULT_AUTH_JWT, im CI-Job z. B. aus
$OPENBAO_ID_TOKEN (GitLab) oder dem OIDC-Aufruf (GitHub,
Tag 11).
python3 - <<'PY'
s = open("main.tf").read()
s = s.replace('provider "vault" {\n skip_child_token = true\n}', '''provider "vault" {
skip_child_token = true
auth_login_jwt {
mount = "jwt-ci"
role = "tofu-main"
}
}''')
open("main.tf", "w").write(s)
PY
unset VAULT_TOKEN
export TERRAFORM_VAULT_AUTH_JWT=$(../mint-jwt.sh $INFRA)
tofu plan -no-color 2>&1 | grep -E 'No changes|Error'
export TERRAFORM_VAULT_AUTH_JWT=$(../mint-jwt.sh $INFRA ref=refs/heads/feature)
tofu plan -no-color 2>&1 | grep -A4 'Code: 400' | tr -s '\n'
unset TERRAFORM_VAULT_AUTH_JWTErwartet:
No changes. Your infrastructure matches the configuration.
Code: 400. Errors:
* error validating claims: claim "ref" does not match any associated bound
claim values
Plan auf Feature-Branches bekommt so eine eigene Rolle mit
read-Rechten, apply nur main. Die
20 Minuten token_ttl sind Absicht: Der Provider warnt im
Debug-Log unter 15 Minuten, weil lange Applies sonst mitten im Lauf 403
bekommen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cat > check.sh <<'EOF'
#!/usr/bin/env bash
cd ~/secrets-lab/tag13
git -C gitops grep -q -E 'lab-[a-z-]*-[0-9]+' && echo "✘ Secret-Wert in Git" \
|| echo "✔ GitOps-Repo ohne Secret-Werte"
grep -q 'argocd.argoproj.io/sync-wave: "-1"' gitops/shop/externalsecret.yaml \
&& echo "✔ ExternalSecret in Welle -1" || echo "✘ Sync-Wave fehlt"
grep -q lab-reg-pw tofu-eph/terraform.tfstate && echo "✘ Secret im ephemeral-State" \
|| echo "✔ ephemeral-State sauber"
grep -q lab-reg-pw tofu-data/terraform.tfstate \
&& echo "✔ Data-Source-State enthält Klartext (erwartet, Gegenbeispiel)"
grep -q 'skip_child_token = true' tofu-eph/main.tf && echo "✔ skip_child_token" \
|| echo "✘ skip_child_token fehlt"
EOF
bash check.shErwartet:
✔ GitOps-Repo ohne Secret-Werte
✔ ExternalSecret in Welle -1
✔ ephemeral-State sauber
✔ Data-Source-State enthält Klartext (erwartet, Gegenbeispiel)
✔ skip_child_token
Challenge
Die JWT-Rollen selbst sollen als Code entstehen. Lege die Rolle
deploy-staging (Repo acme/shop, Branch
staging, Policy ci-deploy, 5 min) per OpenTofu
an und prüfe den Login mit deinem Lab-Issuer.
Hinweis: Die Ressource heißt
vault_jwt_auth_backend_role; bound_claims ist
eine Map aus Strings, TTLs sind Sekunden. Für diesen Admin-Lauf nimmst
du im Lab root.
Lösung
mkdir -p ../tofu-roles && cd ../tofu-roles
cat > main.tf <<'EOF'
terraform {
required_providers {
vault = {
source = "hashicorp/vault"
version = "~> 5.12"
}
}
}
provider "vault" {
skip_child_token = true
}
resource "vault_jwt_auth_backend_role" "deploy_staging" {
backend = "jwt-ci"
role_name = "deploy-staging"
role_type = "jwt"
user_claim = "sub"
bound_audiences = ["openbao"]
bound_claims = {
repository = "acme/shop"
ref = "refs/heads/staging"
}
token_policies = ["ci-deploy"]
token_ttl = 300
}
EOF
tofu init -no-color >/dev/null
VAULT_TOKEN=root tofu apply -auto-approve -no-color | grep 'Apply complete'
BAO_TOKEN= bao write -field=token_policies auth/jwt-ci/login role=deploy-staging \
jwt="$(../mint-jwt.sh ref=refs/heads/staging)"; echoErwartet:
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
[ci-deploy default]
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- State-Backend verschlüsseln (OpenTofu
encryption-Block) und trotzdem keine Secrets hineinlassen: ephemeral plus Write-only, Data-Sources für Secrets verbieten (Review, Policy-as-Code). - Getrennte Rollen:
tofu-plan(read, alle Branches) undtofu-apply(Schreibrechte, nurmain, geschütztes Environment). Admin-Rechte aufsys/nie im normalen Lauf. - Der Provider prüft die Server-Version per
sys/seal-status; OpenBao meldet 2.x. Bei Feature-Prüfungen gegen Vault-Versionen ggf.skip_get_vault_versionundvault_version_overridebewusst setzen und testen. - Argo CD: ESO pro Mandant mit eigenem SecretStore (Tag 4),
Argo-Projekte erlauben nur
ExternalSecret, nieSecretmit Inhalt (Kyverno, Tag 14). - Neue Provider-Versionen in einer Test-Pipeline gegen OpenBao prüfen, bevor die Lockfile-Version steigt.