Zum Inhalt springen
Trainingslager IT-Trainingslager

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-plugin ersetzt 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; echo

Erwartet (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 HEAD

Erwartet:

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 eine ownerReference auf 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 -u

Erwartet:

✔ 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.tfstate

Erwartet:

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; echo

Erwartet:

✔ 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_JWT

Erwartet:

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.sh

Erwartet:

✔ 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)"; echo

Erwartet:

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) und tofu-apply (Schreibrechte, nur main, geschütztes Environment). Admin-Rechte auf sys/ 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_version und vault_version_override bewusst setzen und testen.
  • Argo CD: ESO pro Mandant mit eigenem SecretStore (Tag 4), Argo-Projekte erlauben nur ExternalSecret, nie Secret mit Inhalt (Kyverno, Tag 14).
  • Neue Provider-Versionen in einer Test-Pipeline gegen OpenBao prüfen, bevor die Lockfile-Version steigt.