Zum Inhalt

Best Practices & Konventionen

Diese Seite enthält bewährte Verfahren, Empfehlungen und verbindliche Konventionen für die Arbeit mit Polycrate.

Workspace-Organisation

Workspace-Speicherort

Speichern Sie Workspaces im Polycrate-Standardverzeichnis für optimale Integration:

$HOME/.polycrate/workspaces/<organization>/<workspace>/

Beispiel:

~/.polycrate/workspaces/
├── acme/
   ├── acme-production-1/
      └── workspace.poly
   ├── acme-staging-1/
      └── workspace.poly
   └── acme-development-1/
       └── workspace.poly
└── bcorp/
    ├── bcorp-demo-cluster-1/
       └── workspace.poly
    └── bcorp-demo-cluster-2/
        └── workspace.poly

Vorteile:

  • polycrate workspace list funktioniert out-of-the-box
  • Zentrale Übersicht aller Workspaces
  • Klare Trennung nach Organization

Workspace List Dokumentation

Workspace-Struktur

Empfohlene Verzeichnisstruktur:

acme-production-1/
├── workspace.poly        # Hauptkonfiguration
├── secrets.poly          # Sensitive Config (verschlüsselt als secrets.poly.age)
├── CHANGELOG.poly        # Workspace-Changelog
├── Dockerfile.poly       # Custom Container-Image (optional)
├── inventory.yml         # Ansible Inventory (optional)
├── blocks/               # Lokale Blocks
   └── k8s/
       └── kustomizations/
├── artifacts/            # Generierte Artefakte
   ├── blocks/           # Block-spezifische Artefakte
   └── secrets/          # Verschlüsselte Secrets (kubeconfig, SSH-Keys)
└── README.md             # Workspace-Dokumentation

Workspace-Namen

Das ideale Schema für Workspace-Namen ist: <org>-<purpose>-<count>

Beispiele:

Gut ✅ Schlecht ❌
acme-production-1 production
acme-staging-1 staging-cluster
bcorp-demo-cluster-1 demo
bcorp-demo-cluster-2 workspace1
internal-monitoring-1 my-workspace

Regeln:

  1. Organization-Präfix – Auf einen Blick erkennbar worum es geht
  2. Purpose – Beschreibt den Zweck (production, staging, demo, monitoring)
  3. Nummerierung – Immer nummerieren, beginnend mit 1

Organization-Namen

Organization-Namen sollten slugified sein (URL-freundlich, keine Sonderzeichen):

# Gut ✅
name: acme-production-1
organization: acme

# Gut ✅
name: internal-monitoring-1
organization: internal

# Schlecht ❌
organization: Demo GmbH      # Leerzeichen und Sonderzeichen
organization: ACME Corp.     # Punkt und Großbuchstaben

Slugified Names funktionieren gut in:

  • Verzeichnisnamen
  • Docker-Tags
  • Kubernetes-Labels
  • CI/CD-Pipelines

Git-Integration

Nutzen Sie die integrierten Git-Commands für Workspace-Synchronisierung:

# Status prüfen
polycrate git status

# Änderungen committen
polycrate git add --all
polycrate git commit -m "feat: update cluster configuration"
polycrate git push

# Automatischer Sync-Workflow (empfohlen!)
polycrate git sync

Maximale Safety mit git sync

polycrate git sync kombiniert add, commit, pull und push in einem Schritt. Nutzen Sie es regelmäßig um ungewollte Drifts zu vermeiden.

Git-Dokumentation

Workspace Changelog

Führen Sie ein Changelog für jeden Workspace in CHANGELOG.poly:

# CHANGELOG.poly
- version: "2.0.0"
  date: "2025-06-15"
  type: feat
  message: "Major Upgrade: Kubernetes 1.30 und neue Apps"
  description: |
    - Kubernetes auf 1.30 aktualisiert
    - Authentik SSO hinzugefügt
    - Grafana Monitoring Stack erweitert

- version: "1.2.0"
  date: "2025-06-01"
  type: feat
  message: "Grafana Monitoring hinzugefügt"
  description: |
    - Prometheus Stack installiert
    - Grafana Dashboards für alle Services
    - Alerting konfiguriert

- version: "1.1.0"
  date: "2025-05-20"
  type: fix
  message: "Database Backup automatisiert"
  description: |
    - Automatische PostgreSQL Backups
    - Backup-Rotation implementiert

- version: "1.0.0"
  date: "2025-05-01"
  type: feat
  message: "Initial Setup"
  description: |
    - Kubernetes Cluster mit RKE2
    - PostgreSQL Datenbank
    - Redis Cache

Vorteile:

  • Nachvollziehbare Änderungshistorie
  • Team-Kommunikation
  • Rollback-Planung

Changelog anzeigen:

polycrate workspace changelog

Konfiguration pro Umgebung

Grundprinzip: Ein Workspace für einen Zweck. Keine Vermischung von Umgebungen!

~/.polycrate/workspaces/
└── acme/
    ├── acme-production-1/       # Production-Cluster
       └── workspace.poly
    ├── acme-staging-1/          # Staging-Cluster
       └── workspace.poly
    └── acme-development-1/      # Development-Cluster
        └── workspace.poly

Falsch:

# ❌ FALSCH: Mehrere Umgebungen in einem Workspace
config:
  environment: ${ENV:-development}  # Das funktioniert nicht!
  replicas: ${ENV == "production" ? 3 : 1}  # Das funktioniert nicht!

Richtig:

# ✅ acme-production-1/workspace.poly
name: acme-production-1
organization: acme

blocks:
  - name: my-app
    from: cargo.ayedo.cloud/acme/k8s/my-app:1.0.0
    config:
      replicas: 3
      resources:
        memory: 4Gi
# ✅ acme-staging-1/workspace.poly
name: acme-staging-1
organization: acme

blocks:
  - name: my-app
    from: cargo.ayedo.cloud/acme/k8s/my-app:1.0.0
    config:
      replicas: 1
      resources:
        memory: 1Gi

Workspace-Dokumentation

Dokumentieren Sie Ihren Workspace mit einer README.md:

# acme-production-1

## Übersicht
Production-Kubernetes-Cluster für ACME Corp.

## Blocks

- `cluster` - RKE2 Kubernetes Cluster
- `postgres` - PostgreSQL Datenbank
- `monitoring` - Prometheus + Grafana Stack

## Workflows

- `deploy-all` - Vollständiges Deployment
- `backup` - Backup aller Services

## Wartung

- Backups: Täglich 02:00 Uhr
- Updates: Sonntags im Wartungsfenster

YAML-Anker für wiederverwendbare Werte

YAML-Anker (&) und Aliase (*) ermöglichen die Definition und Wiederverwendung von Werten innerhalb einer workspace.poly. Das reduziert Redundanz und macht die Konfiguration wartbarer.

Grundprinzip

# Definition eines Ankers mit &name
my-value: &my-anchor "wiederverwendbarer-wert"

# Verwendung des Ankers mit *name
other-key: *my-anchor  # → "wiederverwendbarer-wert"

Anwendung in workspace.poly

# ═══════════════════════════════════════════════════════════════════
# YAML-ANKER (Workspace-weite Konstanten)
# ═══════════════════════════════════════════════════════════════════
domain: &domain acme-corp.com
s3_endpoint: &s3_endpoint https://s3.loopback.ayedo.cloud
keycloak_realm: &keycloak_realm acme
keycloak_base_url: &keycloak_base_url https://id.acme-corp.com

letsencrypt_email: &letsencrypt_email admin@acme-corp.com
letsencrypt_issuer: &letsencrypt_issuer letsencrypt-production
ingress_class: &ingress_class nginx

# Workspace-Metadaten
name: acme-production-1
organization: acme

blocks:
  - name: keycloak
    from: cargo.ayedo.cloud/ayedo/k8s/keycloak:0.4.1
    config:
      ingress:
        host: *keycloak_base_url  # → https://id.acme-corp.com
        class: *ingress_class     # → nginx
        tls:
          issuer: *letsencrypt_issuer  # → letsencrypt-production

  - name: mattermost
    from: cargo.ayedo.cloud/ayedo/k8s/mattermost:0.1.0
    config:
      s3:
        endpoint: *s3_endpoint  # → https://s3.loopback.ayedo.cloud
      oidc:
        discovery_url: !join [*keycloak_base_url, "/realms/", *keycloak_realm, "/.well-known/openid-configuration"]
      ingress:
        host: !join ["chat.", *domain]  # → chat.acme-corp.com
        class: *ingress_class

Häufige Anker-Patterns

Anker Typischer Wert Verwendung
&domain example.com Basis-Domain für alle Services
&s3_endpoint https://s3.provider.com S3-kompatibles Storage
&keycloak_base_url https://id.example.com SSO-Provider URL
&keycloak_realm production Keycloak Realm Name
&letsencrypt_email admin@example.com Let's Encrypt Kontakt
&letsencrypt_issuer letsencrypt-production cert-manager Issuer
&ingress_class nginx Ingress Controller Class

Vorteile von YAML-Ankern

  1. Single Source of Truth – Werte nur einmal definieren
  2. Konsistenz – Alle Blöcke nutzen garantiert dieselben Werte
  3. Wartbarkeit – Änderungen nur an einer Stelle
  4. Lesbarkeit – Klare Struktur am Anfang der Datei
  5. Fehlerreduktion – Keine Copy-Paste-Fehler

Anker am Dateianfang definieren

Definieren Sie alle YAML-Anker vor dem blocks:-Abschnitt. So sind alle Konstanten auf einen Blick sichtbar und die Block-Konfigurationen bleiben übersichtlich.

Anker sind workspace-lokal

YAML-Anker sind ein reines YAML-Feature und funktionieren nur innerhalb einer einzelnen Datei. Sie können nicht zwischen workspace.poly und secrets.poly geteilt werden.

Vollständiges Beispiel mit YAML-Ankern

Block-Management

Block-Naming

Best Practice: Blöcke in eine zentrale Registry pushen für Wiederverwendung.

Verwenden Sie immer den vollständigen Registry-Namen:

# Gut ✅ - Vollständiger Registry-Pfad
blocks:
  - name: zammad
    from: cargo.ayedo.cloud/ayedo/k8s/zammad:0.1.7

  - name: n8n
    from: cargo.ayedo.cloud/ayedo/k8s/n8n:0.1.3

  - name: open-webui
    from: cargo.ayedo.cloud/ayedo/k8s/open-webui:0.0.3

Workspace-lokale Blocks für spezifische Anpassungen:

# Für workspace-spezifische Anpassungen (z.B. Cilium IP Pool)
blocks:
  - name: kustomizations
    # Kein "from:" = lokaler Block in blocks/kustomizations/
    config:
      cilium_lb_pool: 10.0.100.0/24
blocks/
└── kustomizations/          # Workspace-spezifisch
    ├── block.poly
    └── playbooks/
        └── apply.yml

Block-Versionen

Versionen werden über das Tag im Block-Namen angegeben:

# Gut ✅ - Version im Namen
blocks:
  - name: zammad
    from: cargo.ayedo.cloud/ayedo/k8s/zammad:0.1.7

  - name: n8n
    from: cargo.ayedo.cloud/ayedo/k8s/n8n:0.1.3

# Schlecht ❌ - Separate version-Angabe (funktioniert nicht)
blocks:
  - name: zammad
    from: cargo.ayedo.cloud/ayedo/k8s/zammad
    version: 0.1.7  # Das funktioniert nicht!

Versionsempfehlungen:

Umgebung Empfehlung
Production Explizite Version: :1.2.3
Staging Explizite Version: :1.2.3 (vor Prod testen)
Development latest okay, aber explizit bevorzugt

Immer explizite Versionen verwenden

Block-Instanzen sollten die Block-Version im from:-Key immer explizit angeben. Ohne explizite Version kann polycrate block pull unbeabsichtigt eine andere Version installieren, was zu unerwarteten Änderungen führt.

# ✅ Gut: Explizite Version verhindert Überraschungen
- name: my-postgres
  from: cargo.ayedo.cloud/ayedo/k8s/cloudnative-pg:1.3.1

# ❌ Schlecht: Ohne Version riskiert man unerwartete Updates
- name: my-postgres
  from: cargo.ayedo.cloud/ayedo/k8s/cloudnative-pg

Block-Versionen sind Singletons

Kritisches Konzept: Eine Version pro Workspace

Eine Block-Version kann nur einmal im Workspace existieren. Wird die Version durch polycrate block pull ge-upgraded oder downgraded, wird der bestehende Template-Block vollständig überschrieben.

Auswirkungen auf mehrfach instanziierte Blocks:

Wenn ein installierter Block mehrfach instanziiert wurde (z.B. frontend und backend beide von generic-app:1.0.0), müssen alle Instanzen auf die neue Version angepasst werden, bevor der Workspace sauber compiliert:

# workspace.poly - Beide Instanzen nutzen denselben Template-Block
blocks:
  - name: frontend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0  # ← Teilen sich
    config:
      app_name: frontend

  - name: backend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0  # ← denselben Block!
    config:
      app_name: backend

Was passiert bei einem Versions-Update:

# Block auf neue Version aktualisieren
polycrate block pull cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0

Der alte Block (generic-app:1.0.0) wird vollständig überschrieben mit der neuen Version (generic-app:2.0.0). Jetzt müssen alle Block-Instanzen in workspace.poly aktualisiert werden:

# workspace.poly - Nach dem Update: BEIDE Instanzen anpassen!
blocks:
  - name: frontend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0  # ← Aktualisiert
    config:
      app_name: frontend

  - name: backend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0  # ← Aktualisiert
    config:
      app_name: backend

Was passiert bei inkonsistenten Versionen?

Wenn Sie vergessen, alle Instanzen zu aktualisieren, entsteht ein inkonsistenter Zustand:

# workspace.poly - INKONSISTENT: Verschiedene Versionen!
blocks:
  - name: frontend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0  # ← Alte Version (nicht mehr installiert!)
    config:
      app_name: frontend

  - name: backend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0  # ← Neue Version (installiert)
    config:
      app_name: backend

Beim nächsten polycrate run frontend install erkennt Polycrate die Inkonsistenz und zeigt den Interaktiven Dependency-Prompt:

┌─────────────────────────────────────────────────────────────────────────────┐
│  Block Dependency Issues                                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│  The following block dependencies need to be resolved:                      │
│                                                                             │
│  ● cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0              [DOWNGRADE]   │
│    └─ required by: frontend                                                 │
│    └─ installed: 2.0.0 → requested: 1.0.0                                  │
│                                                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│  ▸ Install/Update all                                                       │
│    Solve manually                                                           │
└─────────────────────────────────────────────────────────────────────────────┘

Status-Bedeutungen:

Status Bedeutung
[MISSING] Block ist nicht installiert
[UPGRADE] Installierte Version ist älter als angefordert
[DOWNGRADE] Installierte Version ist neuer als angefordert ⚠️

Optionen:

  1. Install/Update all - Polycrate installiert die angeforderte Version
  2. Solve manually - Zeigt die benötigten Befehle:
    polycrate block pull cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0
    

Downgrade-Warnung

Bei [DOWNGRADE] wird eine zusätzliche Bestätigung angefordert, da Downgrades zu Datenverlust oder Inkompatibilitäten führen können. In diesem Fall sollten Sie stattdessen die workspace.poly anpassen und frontend auf 2.0.0 aktualisieren.

Empfehlung: Konsistente Versionen

Verschiedene Versionen desselben Blocks im Workspace sollten nur temporär für Migrationen verwendet werden. Für einfachere Wartung und Konsistenz empfehlen wir eine einheitliche Version pro Workspace.

# ✅ Empfohlen: Einheitliche Version
blocks:
  - name: frontend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0
  - name: backend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:2.0.0

Ausführliche Dokumentation: Interaktiver Dependency-Prompt

Konsistenz sicherstellen

  • Vor dem Pull: Prüfen Sie, welche Instanzen den Block nutzen
  • Nach dem Pull: Alle from:-Referenzen in workspace.poly aktualisieren
  • Testen: Workspace mit polycrate workspace compile validieren

Block-Wiederverwendung

Erstellen Sie parametrisierbare Blocks über config:

# block.poly
name: generic-app
kind: k8sapp

config:
  app_name: ""        # Muss im Workspace gesetzt werden
  port: 8080          # Default-Wert
  replicas: 3         # Default-Wert

actions:
  - name: deploy
    playbook: deploy.yml

Mehrfach instanziieren im Workspace:

# workspace.poly
blocks:
  - name: frontend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0
    config:
      app_name: frontend
      port: 3000

  - name: backend
    from: cargo.ayedo.cloud/acme/k8s/generic-app:1.0.0
    config:
      app_name: backend
      port: 8080

Block-README

Jeder Block sollte eine README.md enthalten:

# Block-Name

## Beschreibung
Kurze Beschreibung des Blocks

## Konfiguration

```yaml
config:
  parameter1: Beschreibung
  parameter2: Beschreibung
```

## Actions

- `install` - Initiale Installation
- `uninstall` - Deinstallation

## Beispiele

```bash
polycrate run my-block install
```

Action-Design

Action-Namen

Verwenden Sie konsistente Action-Namen:

Action Beschreibung
install Initiale Installation
uninstall Vollständige Deinstallation
update Updates und Upgrades
start / stop Dienste starten/stoppen
backup / restore Backup-Operationen
status Status-Abfrage
validate Validierung

Prompts verwenden

Verwenden Sie Prompts für kritische Operationen:

actions:
  - name: delete-database
    prompt:
      message: "WARNUNG: Dies löscht alle Daten! Fortfahren?"
    playbook: delete.yml

In Automatisierungen können Prompts mit --force übersprungen werden.

Idempotenz

Actions sollten idempotent sein – mehrfaches Ausführen führt zum gleichen Ergebnis:

actions:
  - name: install
    playbook: install.yml  # Ansible ist von Natur aus idempotent

Fehlerbehandlung

Nutzen Sie allow_failure strategisch in Workflows:

workflows:
  - name: deploy
    steps:
      - name: backup
        block: database
        action: backup
        allow_failure: true  # Deployment fortsetzen auch wenn Backup fehlschlägt

      - name: deploy
        block: app
        action: install
        allow_failure: false  # Bei Fehler stoppen (Standard)

Workflows

Workflow-Organisation

Erstellen Sie Workflows für häufige Aufgaben:

workflows:
  - name: deploy-production
    prompt:
      message: "Production-Deployment starten?"
    steps:
      - name: backup
        block: database
        action: backup
      - name: deploy-backend
        block: backend
        action: install
      - name: deploy-frontend
        block: frontend
        action: install
      - name: smoke-tests
        block: tests
        action: run

Workflow-Benennung

  • Verwenden Sie Verben: deploy-all, backup-databases
  • Seien Sie spezifisch: rollback-to-previous-version statt rollback

Container-Nutzung

Custom Dockerfile.poly

Das Polycrate-Image basiert auf Ubuntu/Debian. Erweitern Sie es bei Bedarf:

# Dockerfile.poly
FROM cargo.ayedo.cloud/library/polycrate:latest

# Ubuntu/Debian: apt verwenden (nicht apk!)
RUN apt-get update && apt-get install -y --no-install-recommends \
    nodejs \
    npm \
    && rm -rf /var/lib/apt/lists/*

# Spezifische CLI-Tools installieren
RUN npm install -g some-cli-tool

Alpine vs Ubuntu

Das Polycrate-Image ist Ubuntu-basiert, nicht Alpine! Verwenden Sie apt-get, nicht apk.

Mounts

Mounten Sie zusätzliche Verzeichnisse bei Bedarf:

polycrate run my-block deploy --mount /home/user/data:/data

Sicherheit

SSH-Keys

SSH-Keys werden automatisch bei polycrate workspace init erstellt:

# Workspace initialisieren (SSH-Keys werden automatisch erstellt)
polycrate workspace init

# Oder explizit mit SSH-Key-Erstellung
polycrate workspace init --with-ssh-keys

# Mit Passphrase-Schutz
polycrate --ssh-use-passphrase workspace init

Die Keys werden in artifacts/secrets/ gespeichert:

  • artifacts/secrets/id_rsa – Private Key
  • artifacts/secrets/id_rsa.pub – Public Key

Automatische Verschlüsselung

Bei aktivierter Workspace-Verschlüsselung werden SSH-Keys automatisch mit verschlüsselt:

polycrate workspace encrypt
# → artifacts/secrets/id_rsa.age
# → artifacts/secrets/id_rsa.pub.age

Falls Sie manuell Keys erstellen müssen (z.B. bei bestehenden Workspaces):

# Manuell erstellen (nur wenn nötig)
polycrate create ssh-keys

# Oder direkt mit ssh-keygen
ssh-keygen -t ed25519 -f artifacts/secrets/id_rsa -C "workspace@example.com" -N ""

Verschlüsselung

Verschlüsseln Sie Workspaces mit sensiblen Daten:

# Verschlüsseln
polycrate workspace encrypt

# Status prüfen
polycrate workspace status

# Entschlüsseln für Bearbeitung
polycrate workspace decrypt

Verschlüsselte Dateien:

  • secrets.polysecrets.poly.age
  • Alle Dateien in artifacts/secrets/*.age

Workspace-Verschlüsselung

Secrets und Konfiguration

Keine Template-Substitution in .poly-Dateien

In workspace.poly und block.poly ist keine Template-Substitution möglich – weder Jinja2 noch Bash. Verwenden Sie stattdessen secrets.poly und Ansible-Playbooks.

# ❌ FALSCH: Funktioniert NICHT!
config:
  api_token: "{{ secrets.token }}"
  home: "$HOME/data"

# ✅ RICHTIG: Literal-Wert in secrets.poly
config:
  api_token: "actual-secret-value"

Details zu Konfigurationseinschränkungen

Best Practices für Secrets:

  • Speichern Sie Secrets niemals im Klartext in workspace.poly
  • Nutzen Sie secrets.poly für sensitive Konfiguration
  • Verschlüsseln Sie den Workspace vor dem Git-Push
  • Jinja2-Templating funktioniert nur in Ansible-Playbooks und Templates

Registry-Zugriff

Authentifizieren Sie sich vor dem Push/Pull von privaten Blocks:

# Docker login
docker login cargo.ayedo.cloud

# Block pushen
polycrate block push cargo.ayedo.cloud/acme/k8s/my-block

Testing

Snapshot-Testing

Testen Sie Ihre Konfiguration mit Snapshots:

# Snapshot generieren ohne auszuführen
polycrate run my-block install --snapshot > snapshot.yml

# Snapshot prüfen
cat snapshot.yml

Logging

Polycrate bietet verschiedene Log-Levels für unterschiedliche Anwendungsfälle:

Level CLI-Verhalten Ansible-Verhalten Anwendungsfall
0 Minimal Standard Automatisierung, CI/CD
1 Normal (Standard) Standard Tägliche Arbeit
2 Debug -vv Fehlersuche, erhöhte Details
3 Trace -vvv + debug=true Maximaler Output, SSH/Helm-Debugging

Level 0 – Minimal

polycrate run my-block install --loglevel 0

Nur essentielle Ausgaben. Ideal für CI/CD-Pipelines und Automatisierung.

Level 1 – Normal (Standard)

polycrate run my-block install
# oder explizit:
polycrate run my-block install --loglevel 1

Standardmäßiges Logging für die tägliche Arbeit.

Level 2 – Debug

polycrate run my-block install --loglevel 2
  • CLI: Debug-Meldungen werden angezeigt
  • Ansible: Läuft mit -vv (verbose)

Nützlich für:

  • Erste Fehlersuche
  • Nachvollziehen von Abläufen
  • Prüfen von Variablenwerten

Level 3 – Trace (Maximum)

polycrate run my-block install --loglevel 3
  • CLI: Trace-Level mit maximalen Details
  • Ansible: Läuft mit -vvv und debug=true

Großer Shell-Buffer erforderlich

Level 3 produziert sehr viel Output. Stellen Sie sicher, dass Ihr Terminal einen ausreichend großen Scrollback-Buffer hat (z.B. 100.000 Zeilen).

Besonders hilfreich bei:

  • SSH-Verbindungsproblemen: Zeigt Connection-Details, Authentifizierungsschritte, Key-Negotiation
  • Helm-Install-Fehlern: Zeigt vollständige Helm-Ausgabe inkl. Template-Rendering
  • Kubernetes-Problemen: Zeigt API-Calls und Responses
  • Ansible-Task-Debugging: Input/Output aus Ansible-Sicht, inkl. Modul-Argumente

Beispiel-Output bei SSH-Problemen:

TASK [Connect to host] *********************************************************
<192.168.1.10> ESTABLISH SSH CONNECTION FOR USER: ubuntu
<192.168.1.10> SSH: EXEC ssh -o ControlMaster=auto -o ControlPersist=60s ...
<192.168.1.10> SSH: RC = 0

Beispiel-Output bei Helm-Problemen:

TASK [Install Helm chart] ******************************************************
changed: [localhost] => {
    "changed": true,
    "command": "helm upgrade --install zammad zammad/zammad ...",
    "stderr": "Release \"zammad\" has been upgraded.",
    "stdout": "NAME: zammad\nLAST DEPLOYED: ...",
    ...
}

Konventionen

Die folgenden Konventionen werden empfohlen um eine konsistente Struktur und optimale Integration mit dem Polycrate-Ökosystem zu gewährleisten.

Block-Metadaten

Block-Metadaten werden vom Polycrate Hub und der Polycrate API ausgelesen und für Integrationen sowie die Darstellung von Block-Informationen genutzt.

Unterstützte Metadaten-Felder:

Feld Beschreibung
kind Block-Typ (k8sapp, k8cluster, linuxapp, generic)
type Übergeordnete Kategorie (db, kv, mq, s3, web)
flavor Konkrete Implementierung (postgresql, redis, etc.)
description Kurzbeschreibung des Blocks
app_version Version der installierten Anwendung
license Lizenz (MIT, Apache-2.0, etc.)
website_url Projekt-Website
documentation_url Link zur Dokumentation
releases_url Link zu Releases/Changelog
license_url Link zur Lizenz
git_repository_url Git-Repository URL
implementation Implementierungsdetails
alias Alternative Namen
changelog Inline-Changelog
# block.poly - Beispiel mit Metadaten
name: my-postgres
kind: k8sapp
type: db
flavor: postgresql
description: "PostgreSQL Datenbank mit CloudNativePG"
app_version: "16.2"
license: Apache-2.0
website_url: https://cloudnative-pg.io
documentation_url: https://cloudnative-pg.io/documentation/

Kubernetes-Integration

Die Polycrate API behandelt Blöcke mit kind: k8sapp speziell für die Kubernetes-Integration (z.B. Status-Monitoring, Deployment-Tracking).

Dynamische Blöcke

Dynamische Blöcke, die via from: von Blöcken mit kind: k8sapp erben, exportieren automatisch kind: k8sappinstance. Das kennzeichnet sie als laufende Instanz der App.

Block-Struktur

1 Block = 1 App = 1 Chart = 1 Namespace

  • Ein App-Block installiert eine einzelne App
  • Dependencies (z.B. PostgreSQL) gehören in separate Blöcke
  • Nur 1 Helm Chart pro Block (Chart-Dependencies okay)
  • Beschränkung auf 1 Namespace mit Option zum Anlegen
# block.poly
name: my-block
kind: k8sapp
config:
  namespace: my-namespace
  create_namespace: true
  chart:
    name: my-chart
    version: 1.0.0
    repo:
      url: https://charts.example.com

Versionierung

Blöcke und Workspaces sollten fortlaufend versioniert werden. Polycrate nutzt Semantic Versioning für maximale Kompatibilität mit Docker, Helm, Kubernetes und anderen Tools.

Change Types

Die Changelogs von Workspaces und Blöcken kennen ein type-Attribut, das angelehnt an die Conventional Commits Spezifikation Aufschluss über die Severity/Criticality einer Änderung gibt:

Type Beschreibung Beispiel
chore Keine wesentliche Änderung (README, Kommentare) 0.0.10.0.2
fix Bugfix, unkritische Änderung 0.0.20.0.3
feat Neues Feature 0.0.30.1.0
breaking Breaking Change, manuelle Migration nötig 0.1.01.0.0

Startversion

Neue Blöcke starten per Konvention bei Version 0.0.1.

OCI-Artefakte erfordern neue Version

Da Blöcke als OCI-Artefakte gespeichert werden, muss jede Änderung am Block auch eine neue Version erzeugen – selbst wenn der Change Type nur chore ist.

Changelog führen

Format in CHANGELOG.poly:

- version: "0.1.0"
  date: "2025-06-15"
  type: feat
  message: "My App Helm Chart von 1.12.2 auf 1.14.2 aktualisiert"
  description: |
    - Helm Chart aktualisiert
    - Neue Config-Optionen hinzugefügt

- version: "0.0.1"
  date: "2025-06-01"
  type: feat
  message: "Initial Commit"

Polycrate Labels

App-Blöcke SOLLTEN Polycrate Labels vererben

Polycrate setzt automatisch Labels unter block.labels:

labels:
  blocks.polycrate.io/kind: k8sappinstance
  blocks.polycrate.io/name: my-block
  organizations.polycrate.io/name: my-org
  workspaces.polycrate.io/name: my-workspace

Diese Labels müssen an Helm Charts und Manifeste vererbt werden:

# values.yaml.j2
commonLabels: {{ block.labels }}

# manifest.yaml.j2
metadata:
  labels: {{ block.labels }}

Workspace-Konventionen

1 Workspace = 1 Kubernetes Cluster

Pro Workspace sollte nur 1 Kubernetes Cluster verwaltet werden für Übersichtlichkeit und Fehlervermeidung.

Kubeconfig und Inventory

Artefakt Speicherort Typ Konvention
Inventory inventory.yml Workspace Ansible-Inventory Format
Kubeconfig artifacts/secrets/kubeconfig.yml Workspace-Secret Automatisch verschlüsselt

Workspace-Secrets vs. Block-Secrets

  • Workspace-Secrets (artifacts/secrets/): Gelten workspace-weit, z.B. kubeconfig.yml
  • Block-Secrets (artifacts/secrets/<block>/): Gehören zu einem spezifischen Block

Artefakte-Dokumentation

Siehe auch