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
ksopsim 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 -1Erwartet (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 -1Erwartet:
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 25Symptom 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 20Erwartet:
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; echoErwartet (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 25Erwartet:
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; echoErwartet:
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.
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; echoErwartet:
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}'; echoErwartet:
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; echoErwartet:
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
- Zeig die kustomize-Optionen in
argocd-cm. Zeitziel: 20 s - Zeig, wohin
SOPS_AGE_KEY_FILEim repo-server zeigt. Zeitziel: 20 s - Prüfe, dass dein eigener Schlüssel
dev/notes-db.yamlweiterhin 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; echoErwartet:
--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.yamlErwartet:
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 -1Erwartet:
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; echoErwartet:
… 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, inlast-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=trueals 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.