Infrastructure-as-Code mit Polycrate: nie wieder SOPS

Wer Infrastructure-as-Code ernsthaft betreibt, kennt das Problem: Der Workspace im Git-Repository enthält Kubeconfigs, SSH-Keys, Passwörter und API-Tokens – alles Dateien, die niemals unkryptiert in einem Remote-Repository landen dürfen. Die übliche Antwort des cloud-nativen Ökosystems: ein weiteres Tool.

SOPS, git-crypt, sealed-secrets, Vault Agent – jedes Werkzeug löst das Problem, fügt aber gleichzeitig neue hinzu. Mehr Konfigurationsdateien, mehr Key-Backends, mehr mentale Last, mehr Dinge die kaputtgehen können. Polycrate macht das anders.

Das Tool-Sprawl-Problem im cloud-nativen IaC-Workflow

Ein typischer IaC-Workflow 2024 sieht ungefähr so aus:

Workspace-Verwaltung:     polycrate / Terraform / Pulumi
Secrets-Verwaltung:       SOPS + AWS KMS / GCP KMS / Azure Key Vault
Git-Operationen:          git (extern, eigene Konfiguration)
SSH-Key-Management:       ssh-agent / ssh-add (manuell)
Kube-Kontext:             kubectl config use-context (manuell)
CI/CD:                    GitHub Actions + eigene decrypt-steps

Jedes dieser Tools hat seine eigene Konfigurationssyntax, seine eigenen Fehlermeldungen und seine eigenen Upgrade-Zyklen. Für ein neues Teammitglied bedeutet das Onboarding in der Praxis: tagelange Dokumentationslektüre, bis der erste kubectl apply funktioniert.

Konkret am Beispiel SOPS:

# .sops.yaml - extra Konfigurationsdatei, die jeder braucht
creation_rules:
  - path_regex: secrets\.poly$
    kms: arn:aws:kms:eu-central-1:123456789:key/abc-def
    age: age1uz9wjtwnk7wx...
  - path_regex: artifacts/secrets/.*
    kms: arn:aws:kms:eu-central-1:123456789:key/abc-def

Dann noch die eigentliche Verschlüsselung:

# SOPS-Workflow
sops --encrypt --in-place secrets.yaml
sops --decrypt secrets.yaml > secrets-decrypted.yaml
# Nicht vergessen: git add, git commit, git push
# Und: AWS-Credentials konfigurieren, KMS-Zugriffsrechte setzen...

Polycrate-Ansatz: Alles integriert, nichts konfigurieren

Polycrate integriert Verschlüsselung und Git-Synchronisation direkt in den Workspace-Lifecycle. Keine externe Konfigurationsdatei, kein separates Key-Backend-Setup, keine zusätzlichen CLI-Tools nötig.

Der gesamte sichere IaC-Workflow besteht aus zwei Befehlen:

# Secrets verschlüsseln und Workspace sichern
polycrate workspace encrypt

# Workspace synchronisieren (commit + pull + push)
polycrate workspace sync

Das war es.

polycrate workspace encrypt – Sicherheit mit einem Befehl

Der encrypt-Befehl verschlüsselt alle sensiblen Dateien im Workspace mit age – einem modernen, auditierten Verschlüsselungsstandard, der von den gleichen Autoren wie Go selbst entwickelt wurde.

Was verschlüsselt wird

Polycrate kennt die Struktur eines Workspaces und weiß automatisch, welche Dateien sensibel sind:

workspace/
├── secrets.poly              ← wird verschlüsselt
├── workspace.poly            ← bleibt im Klartext (public)
└── artifacts/
    └── secrets/
        ├── kubeconfig.yml    ← wird verschlüsselt
        ├── id_rsa            ← wird verschlüsselt
        └── myblock/
            └── api-token.txt ← wird verschlüsselt

Nach der Verschlüsselung:

workspace/
├── secrets.poly.age          ← verschlüsselt, sicher für Git ✅
├── workspace.poly            ← unverändert ✅
└── artifacts/
    └── secrets/
        ├── kubeconfig.yml.age ← verschlüsselt ✅
        ├── id_rsa.age         ← verschlüsselt ✅
        └── myblock/
            └── api-token.txt.age ← verschlüsselt ✅

Die Originaldateien werden gelöscht. Im Repository landen ausschließlich .age-Dateien.

Key-Management ohne manuelle Konfiguration

Der wichtigste Unterschied zu SOPS: Kein Key-Backend konfigurieren. Polycrate löst den Encryption Key automatisch auf – in dieser Priorität:

1. Polycrate API (höchste Priorität) – Key wird automatisch vom Workspace abgerufen
2. Umgebungsvariable WORKSPACE_ENCRYPTION_KEY – Fallback für CI/CD
3. Interaktiver Prompt – Letzter Fallback für manuelle Workflows

In der Praxis mit der Polycrate API bedeutet das: einfach polycrate workspace encrypt aufrufen, der Rest passiert automatisch.

$ polycrate workspace encrypt

Found 2 files to encrypt
Encrypted: secrets.poly -> secrets.poly.age
Encrypted: artifacts/secrets/kubeconfig.yml -> artifacts/secrets/kubeconfig.yml.age
Workspace encryption completed successfully

Der Pre-Commit Hook: Sicherheitsnetz ohne Disziplin

Polycrate installiert beim ersten encrypt automatisch einen Pre-Commit Hook im Git-Repository. Dieser Hook verhindert, dass unverschlüsselte Secrets aus Versehen committet werden – auch wenn jemand vergisst, vorher encrypt aufzurufen:

# Jemand versucht, secrets.poly unverschlüsselt zu committen:
git add secrets.poly
git commit -m "Update secrets"

# Der Hook greift:
# 🔒 Running Polycrate security checks...
#
# ❌ FATAL: Cannot commit - UNENCRYPTED secrets detected:
#    - secrets.poly
#
# Fix:
#   1. Encrypt: polycrate workspace encrypt
#   2. Commit the .age files

Keine Disziplin erforderlich. Der Workspace schützt sich selbst.

polycrate workspace decrypt – Secrets wiederherstellen

Der gegenteilige Prozess: .age-Dateien werden entschlüsselt, Originaldateien werden wiederhergestellt. Auch hier: Key-Auflösung automatisch, kein Setup erforderlich.

$ polycrate workspace decrypt

Found 2 encrypted files to decrypt
Decrypted: secrets.poly.age -> secrets.poly
Decrypted: artifacts/secrets/kubeconfig.yml.age -> artifacts/secrets/kubeconfig.yml
Workspace decryption completed successfully

Ein neues Teammitglied klont das Repository, führt polycrate workspace decrypt aus – und der Workspace ist vollständig betriebsbereit. Keine Einrichtung von Key-Backends, keine AWS-Profile, keine manuelle Schlüsselverteilung über unsichere Kanäle.

polycrate workspace sync – Git ohne Git-Wissen

Git ist mächtig, aber für Platform Engineers, die täglich Infrastruktur verwalten, oft eine Fehlerquelle. Vergessene git add, falsche Branch-Namen, nicht gepullte Remote-Änderungen vor einem Push – all das führt zu vermeidbaren Problemen.

polycrate workspace sync kapselt den vollständigen Git-Workflow in einem einzigen Befehl:

1. Uncommitted changes? → Auto-commit mit generierter Nachricht
2. Fetch from remote → Remote-Stand prüfen
3. Merge conflicts? → Warnung mit Liste der betroffenen Dateien
4. Pull remote changes → Lokalen Stand aktualisieren
5. Push to remote → Geänderten Stand hochladen

In der Praxis:

$ polycrate workspace sync

Uncommitted changes detected, committing...
Committed: 485f52d

Fetching from origin...
Fetch complete

Pulling from remote...
Already up to date

Pushing to remote...
Pushed to origin/main

Sync completed successfully

Die eingebaute Git-Engine basiert auf go-git und funktioniert ohne externe Git-Installation. SSH-Keys werden automatisch aus dem Workspace geladen – kein ssh-add, keine ~/.ssh/config-Einträge nötig.

Bei potentiellen Merge-Konflikten warnt Polycrate proaktiv vor dem Pull und fragt nach Bestätigung – im Gegensatz zu Standard-Git, das Konflikte erst nach dem Merge sichtbar macht:

Warning: Potential merge conflicts detected!
The following files were modified both locally and on remote:
  • workspace.poly

Continue with pull? This may result in merge conflicts [y/N]:

Der vollständige sichere IaC-Workflow

Wie sieht der tägliche Workflow mit Polycrate aus?

Morgens: Workspace starten

cd /workspace/my-infra
polycrate workspace decrypt    # Secrets aus Git entschlüsseln
polycrate workspace sync       # Aktuellsten Stand holen

Änderungen machen

# Kubernetes-Manifeste anpassen, Actions ausführen...
polycrate run app deploy

# Neues Secret hinzufügen
echo "new-api-token" > artifacts/secrets/myapp/api-token.txt

Abends: Sichern

polycrate workspace encrypt    # Alle Secrets verschlüsseln
polycrate workspace sync       # Committen und pushen

Der Pre-Commit Hook stellt sicher, dass kein unverschlüsseltes Secret in Git landet – auch wenn jemand sync direkt ohne vorheriges encrypt aufruft.

polycrate workspace status – Überblick jederzeit

Der Status-Befehl zeigt den vollständigen Sicherheits- und Git-Zustand des Workspace:

$ polycrate workspace status

Workspace Encryption Status
============================

Workspace: https://app.polycrate.example.com/ui/workspaces/339cdbb9.../
UUID: 339cdbb9-3829-48f1-9ecf-7bae7f85d2de

🔑 Key Status: ✅ Key available
   Key ID: age1uz9wjtwnk7wx...
   Source: Polycrate API (priority 1)

📁 File Status:
   Encrypted files:
   ✅ secrets.poly.age
   ✅ artifacts/secrets/kubeconfig.yml.age

🔒 Security Status:
   .gitignore: ✅ Properly configured
   Git repo: ✅ Detected
   Branch: main
   Commit: ce4bd771
   Remote: ✅ In sync
   Changes: ✅ Clean working tree

💡 Recommendations:
   - Workspace is properly encrypted and ready to commit

age: Das richtige Fundament

Die Wahl von age als Verschlüsselungsalgorithmus ist keine Zufallsentscheidung. age wurde von Filippo Valsorda (Go-Sicherheitsteam, früher Google) entwickelt und ist:

• Simpel: Kein Key-Ring, keine komplexe Konfiguration
• Modern: X25519, ChaCha20-Poly1305 – keine Legacy-Algorithmen
• Auditiert: Externe Sicherheitsaudits durchgeführt
• Standard-kompatibel: Alle von Polycrate verschlüsselten Dateien können mit dem Standard-age-CLI entschlüsselt werden

Letzteres ist besonders wichtig: Kein Vendor Lock-in. Sollte Polycrate in einem Notfall nicht verfügbar sein, können Secrets jederzeit mit dem Standard-Tool entschlüsselt werden:

# Notfall-Entschlüsselung ohne Polycrate
echo "$WORKSPACE_ENCRYPTION_KEY" | age --decrypt -i - secrets.poly.age > secrets.poly

Team-Workflow: Key-Management via Polycrate API

Für Teams ist die Polycrate API die empfohlene Lösung für zentrales Key-Management. Der Encryption Key wird als Workspace Credential in der API gespeichert und automatisch an berechtigte Teammitglieder ausgegeben.

# ~/.polycrate/polycrate.yml
api:
  enabled: true
  url: https://api.polycrate.example.com
  api_key: your-api-key

Damit entfällt die Frage “Wo ist der Encryption Key?” vollständig. Neue Teammitglieder konfigurieren einmal die API, danach funktioniert encrypt und decrypt ohne weitere Schritte.

Vergleich: Polycrate vs. SOPS

Fazit

Das cloud-native Ökosystem hat ein Tool-Sprawl-Problem. Für jeden Aspekt eines Infrastruktur-Workflows gibt es ein spezialisiertes Tool – und jedes dieser Tools will konfiguriert, gewartet und verstanden werden.

Polycrate wählt einen anderen Ansatz: Verschlüsselung, Git-Integration, Key-Management und Workflow-Automatisierung gehören zum Kern des Tools, nicht zu einem separaten Plugin-Ökosystem. Das Ergebnis ist ein IaC-Workflow, der sicher ist ohne komplex zu sein.

# Der vollständige sichere IaC-Workflow:
polycrate workspace decrypt    # Secrets laden
polycrate run my-block deploy  # Infrastruktur ausrollen
polycrate workspace encrypt    # Secrets sichern
polycrate workspace sync       # Stand committen und pushen

Vier Befehle. Ein Tool. Keine SOPS-Konfiguration.

→ Polycrate installieren → Workspace-Verschlüsselung Dokumentation → Git-Integration Dokumentation

Polycrate ist das Infrastructure-as-Code Tool von ayedo für deklaratives Multi-Cluster-Management. Mehr erfahren →