Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Argo CD entschlüsselt

Ziel: Argo CD entschlüsselt mit KSOPS und einem eigenen age-Schlüssel, du erkennst die zwei typischen Einrichtungsfehler an ihrer Meldung und weißt, an welchen zwei Stellen Argo CD den Klartext trotzdem ablegt. · Dauer: ca. 75 min · Voraussetzung: Tag 10

Briefing

  • Argo CD kennt sops nicht. Es baut Manifeste mit kustomize, und KSOPS ist ein kustomize-Plugin (ein Generator), das sops-Dateien beim Bauen entschlüsselt.
  • Drei Teile müssen zusammenkommen: das Binary ksops im repo-server (Init-Container), die Freigabe für Plugins (kustomize.buildOptions) und ein Schlüssel (SOPS_AGE_KEY_FILE).
  • Argo CD bekommt einen eigenen age-Schlüssel. Er steht als zusätzlicher Recipient in .sops.yaml – nur für die Ordner, die Argo CD ausrollen soll.
  • Die Oberfläche maskiert Secret-Werte. Der Klartext liegt aber im Manifest-Cache (Redis) und – bei client-seitigem Apply – in einer Annotation am Secret.
  • Grundlagen (Installation, Applications, Sync) stehen in „GitOps mit Argo CD zum Anfassen“, Tag 10. Der andere Weg über Helm-Charts, helm-secrets, steht in „Helm Charts zum Anfassen“, Tag 16.
 Forgejo lab/secrets
   argocd/dev/kustomization.yaml ─► generators: secret-generator.yaml (kind: ksops)
   dev/notes-db.yaml, dev/neu.yaml (sops, Recipients: ich + argocd)
                     │
 argocd-repo-server  ▼  kustomize build --enable-alpha-plugins --enable-exec
   /usr/local/bin/ksops     (Init-Container install-ksops)
   /sops/keys.txt           (Secret sops-age, SOPS_AGE_KEY_FILE)
                     │  Klartext-Manifeste ─► Redis-Cache
                     ▼
 application-controller ─► Secrets in notes-dev

Drill 1: Ein Schlüssel für Argo CD

Argo CD soll dev/ lesen können – nicht prod/, nicht tresor/. Also ein eigener Schlüssel als zusätzlicher Recipient der dev-Regel.

# auf argo
mkdir -p ~/sops/tag11 && cd ~/sops/tag11
age-keygen -o argocd.key 2>&1
A=$(age-keygen -y argocd.key)
cd ~/sops/repo
yq -i '(.creation_rules[] | select(.path_regex == "^dev/.*\\.yaml$")).age
  += ",'"$A"'"' .sops.yaml
yq '.creation_rules[1].age' .sops.yaml | tr ',' '\n'
sops updatekeys -y dev/notes-db.yaml 2>&1 | tail -1
sops updatekeys -y dev/neu.yaml 2>&1 | tail -1

Erwartet (gekürzt):

Public key: age1ymx7x29j3nctlanp5kwt76xve66dc0dm4lpklcq5jykxr7vq55fsmhu7ts
age1rnz4tqupd0f3lm4kfs564cfgys5j80497rk7ajzn2ekxh3d2g3uqdtdnv2
age1ymx7x29j3nctlanp5kwt76xve66dc0dm4lpklcq5jykxr7vq55fsmhu7ts
… File /home/ubuntu/sops/repo/dev/notes-db.yaml synced with new keys
… File /home/ubuntu/sops/repo/dev/neu.yaml synced with new keys

yq hängt den Schlüssel an die Liste der Regel ^dev/.*\.yaml$ an; updatekeys überträgt die neue Liste in die Dateien (Tag 5). Dein Schlüssel bleibt drin.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der KSOPS-Generator

Argo CD braucht einen Ordner mit kustomization.yaml. Er liegt außerhalb von dev/ – dort lässt der Hook aus Tag 9 nur verschlüsselte Dateien zu.

# auf argo
cd ~/sops/repo
mkdir -p argocd/dev
cat > argocd/dev/secret-generator.yaml <<'EOF'
apiVersion: viaduct.ai/v1
kind: ksops
metadata:
  name: dev-secrets
  annotations:
    config.kubernetes.io/function: |
      exec:
        path: ksops
files:
  - ../../dev/notes-db.yaml
  - ../../dev/neu.yaml
EOF
cat > argocd/dev/kustomization.yaml <<'EOF'
generators:
  - secret-generator.yaml
EOF
git add .sops.yaml dev argocd
git commit -q -m "tag11: Argo CD als Recipient, KSOPS-Generator" && git push -q
git log --oneline | head -1

Erwartet:

8e27b9b tag11: Argo CD als Recipient, KSOPS-Generator

kind: ksops ist kein Kubernetes-Objekt, sondern die Konfiguration des Plugins: kustomize ruft das Programm ksops auf und übernimmt, was es ausgibt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Argo CD mit KSOPS installieren

Das Helm-Chart argo/argo-cd 10.18.2 bringt Argo CD v3.6.2. Der Init-Container kopiert ksops und ein passendes kustomize in ein emptyDir, der repo-server bindet beide nach /usr/local/bin ein (so steht es in der KSOPS-Doku). Dex, Benachrichtigungen und ApplicationSets bleiben aus – RAM.

# auf argo
cd ~/sops/tag11
helm repo add argo https://argoproj.github.io/argo-helm >/dev/null
helm repo update argo >/dev/null
cat > argocd-values.yaml <<'EOF'
configs:
  params:
    server.insecure: true
server:
  service:
    type: NodePort
    nodePortHttp: 30080
dex:
  enabled: false
notifications:
  enabled: false
applicationSet:
  replicas: 0
repoServer:
  volumes:
    - name: custom-tools
      emptyDir: {}
  initContainers:
    - name: install-ksops
      image: viaductoss/ksops:v4.5.1
      command: ["/usr/local/bin/ksops", "install", "--with-kustomize",
                "/custom-tools"]
      volumeMounts:
        - {mountPath: /custom-tools, name: custom-tools}
  volumeMounts:
    - {mountPath: /usr/local/bin/kustomize, name: custom-tools, subPath: kustomize}
    - {mountPath: /usr/local/bin/ksops, name: custom-tools, subPath: ksops}
EOF
helm install argocd argo/argo-cd --version 10.18.2 -n argocd --create-namespace \
  -f argocd-values.yaml --wait --timeout 5m 2>&1 | grep STATUS
kubectl -n argocd get pods --no-headers | awk '{print $1, $3}'

Erwartet:

STATUS: deployed
argocd-application-controller-0 Running
argocd-redis-866bcf475c-9lrhq Running
argocd-redis-secret-init-zfmbj Completed
argocd-repo-server-786889ccbc-ksh9x Running
argocd-server-76d678bd6c-m2wxz Running

Fortschritt speichern? Kostenlos registrieren

Drill 4: Plugins sind gesperrt

Einbauen: Zugang zu Forgejo und eine Application für argocd/dev, mit automatischem Sync. ServerSideApply kommt erst in Drill 7 dazu.

# auf argo
cd ~/sops/tag11
cat > repo.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: forgejo-secrets
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: http://forgejo-http.forgejo.svc:3000/lab/secrets.git
  username: lab
  password: lab-forgejo-123
EOF
cat > app-dev.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev
  namespace: argocd
spec:
  project: default
  source:
    repoURL: http://forgejo-http.forgejo.svc:3000/lab/secrets.git
    targetRevision: main
    path: argocd/dev
  destination:
    server: https://kubernetes.default.svc
    namespace: notes-dev
  syncPolicy:
    automated: {prune: true}
    syncOptions: [CreateNamespace=true]
EOF
kubectl apply -f repo.yaml -f app-dev.yaml
sleep 25

Symptom und Untersuchen:

# auf argo
kubectl -n argocd get application dev
kubectl -n argocd get application dev \
  -o jsonpath='{.status.conditions[*].message}' | grep -o 'external.*'

Erwartet:

NAME   SYNC STATUS   HEALTH STATUS
dev    Unknown       Healthy
external plugins disabled; unable to load external plugin 'ksops'

Ursache: kustomize führt Generator-Programme nur mit --enable-alpha-plugins --enable-exec aus. Argo CD gibt diese Optionen erst weiter, wenn sie in argocd-cm unter kustomize.buildOptions stehen.

Fix:

# auf argo
cd ~/sops/tag11
yq -i '.configs.cm."kustomize.buildOptions" = "--enable-alpha-plugins --enable-exec"' \
  argocd-values.yaml
helm upgrade argocd argo/argo-cd --version 10.18.2 -n argocd \
  -f argocd-values.yaml --wait 2>&1 | grep REVISION
kubectl -n argocd annotate application dev argocd.argoproj.io/refresh=hard \
  --overwrite >/dev/null
sleep 20

Erwartet:

REVISION: 2

Fortschritt speichern? Kostenlos registrieren

Drill 5: Plugin da, Schlüssel fehlt

Symptom und Untersuchen:

# auf argo
kubectl -n argocd get application dev \
  -o jsonpath='{.status.conditions[*].message}' | grep -o 'error decrypting.*' \
  | head -c 150; echo

Erwartet (Zeile umbrochen):

error decrypting file "../../dev/neu.yaml" from manifest.Files: trouble decrypting
file: Error getting data key: 0 successful groups required, got 0unable to genera

Ursache: KSOPS läuft und findet die Datei – der relative Pfad ../../dev funktioniert. Aber im repo-server liegt kein Schlüssel. „0 successful groups“ ist sops’ Art zu sagen: keine Identity gefunden.

Fix: Der Schlüssel wird ein Secret im Namespace argocd, der repo-server bindet es ein und zeigt mit SOPS_AGE_KEY_FILE darauf.

# auf argo
cd ~/sops/tag11
kubectl -n argocd create secret generic sops-age --from-file=keys.txt=argocd.key
yq -i '.repoServer.volumes += [{"name":"sops-age",
    "secret":{"secretName":"sops-age"}}] |
  .repoServer.volumeMounts += [{"mountPath":"/sops","name":"sops-age",
    "readOnly":true}] |
  .repoServer.env = [{"name":"SOPS_AGE_KEY_FILE","value":"/sops/keys.txt"}]' \
  argocd-values.yaml
helm upgrade argocd argo/argo-cd --version 10.18.2 -n argocd \
  -f argocd-values.yaml --wait 2>&1 | grep REVISION
kubectl -n argocd annotate application dev argocd.argoproj.io/refresh=hard \
  --overwrite >/dev/null
sleep 25

Erwartet:

secret/sops-age created
REVISION: 3

Nachweis:

# auf argo
kubectl -n argocd get application dev
kubectl -n notes-dev get secret notes-db -o jsonpath='{.data.password}' \
  | base64 -d; echo

Erwartet:

NAME   SYNC STATUS   HEALTH STATUS
dev    Synced        Healthy
lab-db-dev-789

Fortschritt speichern? Kostenlos registrieren

Drill 6: Was Argo CD zeigt

Die CLI holst du wie die anderen Werkzeuge mit Prüfsumme.

# auf argo
cd ~/sops/tag11
ARCH=$(dpkg --print-architecture)
G=https://github.com/argoproj/argo-cd/releases/download/v3.6.2
curl -fsSL -o argocd-linux-$ARCH $G/argocd-linux-$ARCH
curl -fsSLO $G/cli_checksums.txt
grep " argocd-linux-$ARCH$" cli_checksums.txt | sha256sum -c
sudo install -m 0755 argocd-linux-$ARCH /usr/local/bin/argocd
PW=$(kubectl -n argocd get secret argocd-initial-admin-secret \
  -o jsonpath='{.data.password}' | base64 -d)
argocd login 172.16.0.182:30080 --plaintext --username admin --password "$PW" \
  2>&1 | tail -1
argocd app manifests dev --source live | grep -A1 '^data:'

Erwartet:

argocd-linux-amd64: OK
Context '172.16.0.182:30080' updated
data:
  password: ++++++++
--
data:
  password: ++++++++

Die Oberfläche (http://172.16.0.182:30080, Benutzer admin, Passwort wie oben) zeigt dasselbe: die Application mit beiden Secrets und im Live-Manifest nur Pluszeichen.

Argo CD: Application dev mit den Secrets neu und notes-db
Argo CD: Live-Manifest des Secrets notes-db, Wert maskiert

Fortschritt speichern? Kostenlos registrieren

Drill 7: Wo der Klartext trotzdem liegt

Die Maske gilt nur für die Anzeige. Erste Stelle: die Annotation, die client-seitiges kubectl apply an jedes Objekt hängt.

# auf argo
kubectl -n notes-dev get secret notes-db -o jsonpath=\
'{.metadata.annotations.kubectl\.kubernetes\.io/last-applied-configuration}' \
  | jq -r .data.password | base64 -d; echo

Erwartet:

lab-db-dev-789

Zweite Stelle: der Manifest-Cache im Redis von Argo CD. Die Einträge sind gzip-komprimiertes JSON – mit den entschlüsselten Werten.

# auf argo
R=$(kubectl -n argocd get secret argocd-redis -o jsonpath='{.data.auth}' \
  | base64 -d)
K=$(kubectl -n argocd exec deploy/argocd-redis -- redis-cli -a "$R" \
  --no-auth-warning --scan --pattern 'mfst|*' | head -1)
kubectl -n argocd exec deploy/argocd-redis -- redis-cli -a "$R" \
  --no-auth-warning --raw get "$K" | gunzip 2>/dev/null | grep -o 'password[^}]*'

Erwartet:

password\":\"bGFiLWRiLW5ldS0xMjM=\"
password\":\"bGFiLWRiLWRldi03ODk=\"

bGFiLWRiLWRldi03ODk= ist base64 für lab-db-dev-789. Die Argo-CD-Doku warnt selbst davor: Plugins, die Secrets erzeugen, legen sie im Cache ab. Wer Redis lesen darf, liest die Secrets.

Fix für die Annotation: Server-seitiges Apply hängt keine last-applied-configuration an.

# auf argo
cd ~/sops/tag11
yq -i '.spec.syncPolicy.syncOptions += ["ServerSideApply=true"]' app-dev.yaml
kubectl apply -f app-dev.yaml
kubectl -n notes-dev annotate secret notes-db neu \
  kubectl.kubernetes.io/last-applied-configuration-
argocd app sync dev --force 2>&1 | grep -E '^ +Secret' | awk '{print $3, $4, $6}'
kubectl -n notes-dev get secret notes-db -o jsonpath='{.metadata.annotations}'; echo

Erwartet:

application.argoproj.io/dev configured
secret/notes-db annotated
secret/neu annotated
notes-db Synced serverside-applied
neu Synced serverside-applied
{"argocd.argoproj.io/tracking-id":"dev:/Secret:notes-dev/notes-db"}

Gegen den Cache hilft nur Abschottung: Redis nur für Argo CD erreichbar (NetworkPolicy, die das Chart mitbringen kann), Redis-Passwort, kein exec in den Namespace argocd für Menschen.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Ändern und ausrollen

# auf argo
cd ~/sops/repo
sops set dev/notes-db.yaml '["data"]["password"]' \
  "\"$(printf lab-db-dev-999 | base64)\""
git add dev/notes-db.yaml && git commit -q -m "tag11: dev-Passwort gewechselt"
git push -q && git log --oneline | head -1
argocd app get dev --hard-refresh >/dev/null
sleep 15
argocd app get dev -o json | jq -r '.status.sync.status'
kubectl -n notes-dev get secret notes-db -o jsonpath='{.data.password}' \
  | base64 -d; echo

Erwartet:

c0c5d67 tag11: dev-Passwort gewechselt
Synced
lab-db-dev-999

Ohne --hard-refresh fragt Argo CD Forgejo alle drei Minuten. Ein Webhook von Forgejo an Argo CD macht das sofort (Hinweis dazu in „GitOps mit Argo CD zum Anfassen“, Tag 2).

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die kustomize-Optionen in argocd-cm. Zeitziel: 20 s
  2. Zeig, wohin SOPS_AGE_KEY_FILE im repo-server zeigt. Zeitziel: 20 s
  3. Prüfe, dass dein eigener Schlüssel dev/notes-db.yaml weiterhin entschlüsseln kann. Zeitziel: 15 s

Lösung

# auf argo
kubectl -n argocd get cm argocd-cm -o jsonpath='{.data.kustomize\.buildOptions}'
echo
kubectl -n argocd set env deploy/argocd-repo-server --list | grep SOPS
sops decrypt --extract '["data"]["password"]' ~/sops/repo/dev/notes-db.yaml \
  | base64 -d; echo

Erwartet:

--enable-alpha-plugins --enable-exec
SOPS_AGE_KEY_FILE=/sops/keys.txt
lab-db-dev-999

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf argo
argocd app get dev -o json | jq -r '.status.sync.status + " " + .status.health.status'
kubectl -n notes-dev get secret --no-headers | wc -l
grep -c "$(age-keygen -y ~/sops/tag11/argocd.key)" ~/sops/repo/dev/notes-db.yaml

Erwartet:

Synced Healthy
2
1

Challenge

Argo CD soll zusätzlich dev/app.env (Tag 4) als Secret app-env ausrollen. KSOPS kann aus einer dotenv-Datei direkt ein Secret erzeugen (secretFrom mit envs). Erweitere den Generator, pushe – und lies die Meldung, bevor du sie behebst.

Hinweis: Für .env-Dateien gilt eine eigene Regel in .sops.yaml.

Lösung

# auf argo
cd ~/sops/repo
cat >> argocd/dev/secret-generator.yaml <<'EOF'
secretFrom:
  - metadata:
      name: app-env
    envs:
      - ../../dev/app.env
EOF
git add argocd && git commit -q -m "tag11: app.env als Secret" && git push -q
argocd app get dev --hard-refresh >/dev/null; sleep 10
argocd app get dev -o json | jq -r '.status.conditions[0].message' \
  | grep -o 'error decrypting[^:]*' | head -1

Erwartet:

error decrypting file "../../dev/app.env" from secretFrom.Envs

Die Regel ^dev/.*\.env$ kennt nur deinen Schlüssel. Fix wie in Drill 1:

# auf argo
cd ~/sops/repo
A=$(age-keygen -y ~/sops/tag11/argocd.key)
yq -i '(.creation_rules[] | select(.path_regex == "^dev/.*\\.env$")).age
  += ",'"$A"'"' .sops.yaml
sops updatekeys -y dev/app.env 2>&1 | tail -1
git add .sops.yaml dev/app.env
git commit -q -m "tag11: Argo CD darf app.env lesen" && git push -q
argocd app get dev --hard-refresh >/dev/null
argocd app sync dev 2>&1 | grep -E '^Phase'
kubectl -n notes-dev get secret app-env -o jsonpath='{.data.API_KEY}' \
  | base64 -d; echo

Erwartet:

… File /home/ubuntu/sops/repo/dev/app.env synced with new keys
Phase:              Succeeded
lab-key-123

Nach einem fehlgeschlagenen Manifest-Bau hat Argo CD im Labor nicht von selbst synchronisiert, obwohl der neue Stand gebaut werden konnte – argocd app sync stößt es an.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Argo CD geht wieder vom Cluster. Die Application zuerst löschen – mit prune und dem Finalizer würde sie sonst beim Abbau hängen oder Secrets mitnehmen.

# auf argo
kubectl -n argocd patch application dev --type merge \
  -p '{"metadata":{"finalizers":null}}'
kubectl -n argocd delete application dev
helm uninstall argocd -n argocd >/dev/null && kubectl delete namespace argocd notes-dev
rm ~/sops/tag11/argocd-linux-* ~/sops/tag11/cli_checksums.txt
kubectl get ns | grep -cE 'argocd|notes'

Erwartet:

application.argoproj.io/dev patched (no change)
application.argoproj.io "dev" deleted from argocd namespace
namespace "argocd" deleted
namespace "notes-dev" deleted
0

Für spätere Tage bleiben: ~/sops/tag11/argocd.key (Recipient in den dev-Regeln), der Ordner argocd/dev im Repo, das argocd-Binary. Die CRDs von Argo CD lässt helm uninstall stehen; sie stören nicht.

Interview-Notiz

  • Wie bringt man Argo CD sops bei? Über ein Config-Management-Werkzeug: KSOPS als kustomize-Generator (Init-Container + kustomize.buildOptions + Schlüssel im repo-server) oder helm-secrets für Helm-Charts.
  • Ist das Secret in Argo CD sicher, weil die UI ++++++++ zeigt? Nein – Klartext im Redis-Cache und, bei client-seitigem Apply, in last-applied-configuration.
  • Warum ein eigener Schlüssel für Argo CD? Er lässt sich pro Ordner vergeben und einzeln entziehen (updatekeys + rotate), ohne Menschen-Schlüssel anzufassen.

Enterprise-Notiz

  • Viele Teams lassen Argo CD gar nicht entschlüsseln: External Secrets Operator holt die Werte zur Laufzeit aus OpenBao, im Git steht nur die Referenz (Tag 15).
  • Das Argo-CD-Projekt selbst empfiehlt diesen Weg gegenüber Plugins, die Secrets beim Bauen erzeugen – genau wegen des Caches.
  • Wenn KSOPS: ein eigenes repo-server-Image statt Init-Container (schnellerer Start, signierbar), Redis mit TLS und NetworkPolicy, ServerSideApply=true als Standard in jeder Application (z. B. über die Vorlage eines ApplicationSets).
  • Schlüssel pro Cluster; Recipient nur für die Pfade, die dieser Cluster ausrollt.
  • Mit Cloud-KMS bekommt der repo-server per Workload Identity Zugriff, ohne Schlüsseldatei.