🔗 Integrationen¶

Polycrate integriert sich nahtlos mit einer Vielzahl von Tools und Plattformen für Infrastructure-as-Code, Configuration Management, Container-Orchestrierung und Cloud-Provisioning. Diese Integrationen ermöglichen es Ihnen, komplexe Infrastrukturen und Anwendungen mit einem einheitlichen Workflow zu verwalten.

Übersicht¶

graph TB
    Polycrate[Polycrate] --> Ansible[Ansible]
    Polycrate --> Kubernetes[Kubernetes]
    Polycrate --> Terraform[Terraform]
    Polycrate --> Docker[Docker & Docker Compose]
    Polycrate --> SSH[SSH]
    Polycrate --> Git[Git]

    Ansible -->|provisioniert| Hosts[Linux-Hosts]
    Ansible -->|deployt| DockerApps[Docker-Apps]
    Ansible -->|deployt| K8sApps[Kubernetes-Apps]

    Kubernetes -->|verwaltet| Clusters[K8s-Cluster]
    Kubernetes -->|deployt mit| Helm[Helm-Charts]

    Terraform -->|provisioniert| Cloud[Cloud-Infrastruktur]
    Terraform -->|verwaltet| Resources[Ressourcen]

    Docker -->|deployt| Containers[Container]
    Docker -->|orchestriert| Stacks[Docker-Compose-Stacks]

    SSH -->|verbindet mit| Hosts
    Git -->|synchronisiert| Workspace[Workspace]

    style Polycrate fill:#e1f5ff
    style Ansible fill:#f0e1ff
    style Kubernetes fill:#ffe1e1
    style Terraform fill:#fff4e1

Verfügbare Integrationen¶

Configuration Management & Deployment¶

Ansible¶

Die primäre Integration für Configuration Management und Deployment. Polycrate bietet erstklassigen Support für Ansible-Playbooks als Actions.

Features: - Ansible-Playbooks als Actions ausführen - Automatische Inventory-Integration - Snapshot-Variablen als Ansible-Extra-Vars - SSH-Key-Management - Framework-Rollen für häufige Aufgaben - Kubernetes-Deployment mit Ansible - Docker-Compose-Management mit Ansible

Anwendungsfälle: - Linux-Server provisionieren und konfigurieren - Applikationen deployen (Docker, K8s, bare-metal) - Configuration-Drift beheben - Multi-Host-Orchestrierung

→ Zur Ansible-Dokumentation

Container & Orchestration¶

Kubernetes¶

Native Integration mit Kubernetes-Clustern für Application-Deployment und Cluster-Management.

Features: - Kubeconfig-Management pro Block - Helm-Chart-Integration - Namespace-Verwaltung - Ingress-Konfiguration - Persistence-Management - Monitoring-Integration - Multi-Cluster-Support

Anwendungsfälle: - Kubernetes-Applikationen deployen - Helm-Charts installieren und upgraden - Cluster-Konfiguration verwalten - Kubernetes-Manifeste anwenden

→ Zur Kubernetes-Dokumentation

Docker & Docker Compose¶

Integration mit Docker für Container-Management und Docker-Compose-Stacks.

Features: - Docker-Container starten/stoppen - Docker-Compose-Stacks deployen - Image-Building - Registry-Integration - Container-Netzwerke verwalten

Anwendungsfälle: - Docker-Compose-Stacks auf Servern deployen - Container-basierte Applikationen verwalten - Multi-Container-Setups orchestrieren

→ Zu Docker-Compose-Beispielen

Infrastructure Provisioning¶

Terraform¶

Integration mit Terraform für Infrastructure-as-Code und Cloud-Provisioning.

Features: - Terraform-Actions in Blocks - State-Management in Artifacts - Multi-Cloud-Support (AWS, Azure, GCP, etc.) - Terraform-Output als Inventory - Plan/Apply/Destroy-Workflows

Anwendungsfälle: - Cloud-Infrastruktur provisionieren - Kubernetes-Cluster erstellen - Netzwerke und VPCs verwalten - DNS-Records verwalten

→ Zur Terraform-Dokumentation

Remote Access & Connectivity¶

SSH¶

Integration mit SSH für direkten Zugriff auf Hosts und Ansible-Verbindungen.

Features: - Automatisches SSH-Key-Management - SSH-Shortcut: polycrate ssh HOSTNAME - SSH-Agent-Integration - Passphrase-Support ⚠️ Experimental - SSH-Control-Master für persistente Verbindungen - Host-Cache für Performance

Anwendungsfälle: - Schneller Zugriff auf Ansible-Inventory-Hosts - Debugging auf Remote-Servern - Manuelle Operationen auf Hosts

→ Zur SSH-Dokumentation

Version Control¶

Git¶

Native Git-Integration für Workspace-Synchronisierung und Versionierung.

Features: - Automatische Commits nach Actions - Sync mit Remote-Repositories - Branch-Management - Commit-Messages mit Transaction-IDs - Multi-Branch-Workflows

Anwendungsfälle: - Workspace-Änderungen versionieren - Team-Collaboration - Audit-Trail für Infrastruktur-Änderungen - GitOps-Workflows

→ Zu Git-Integration

Integration-Matrix¶

Typische Integration-Patterns¶

Pattern 1: Terraform → Ansible¶

graph LR
    TF[Terraform-Block] -->|provisioniert| Cloud[Cloud-VMs]
    TF -->|generiert| Inv[Inventory-Artifact]
    Inv -->|genutzt von| Ansible[Ansible-Block]
    Ansible -->|konfiguriert| Cloud

1. Terraform-Block provisioniert Infrastruktur (VMs, Netzwerke)
2. Terraform-Output generiert Ansible-Inventory
3. Ansible-Block nutzt generiertes Inventory für Configuration

Beispiel:

# Block: infrastructure
name: infrastructure
kind: generic
actions:
  - name: provision
    script:
      - terraform apply -auto-approve
      - terraform output -json | python3 scripts/to-inventory.py > $ARTIFACTS/inventory.yml

# Block: configure-servers
name: configure-servers
kind: linuxapp
inventory:
  from: infrastructure  # Nutzt generiertes Inventory
actions:
  - name: install
    playbook: playbooks/setup-servers.yml

Pattern 2: Kubernetes-Cluster → Apps¶

graph LR
    Cluster[Cluster-Block] -->|erstellt| K8s[K8s-Cluster]
    Cluster -->|generiert| KC[Kubeconfig-Artifact]
    KC -->|genutzt von| App1[App-Block 1]
    KC -->|genutzt von| App2[App-Block 2]
    App1 -->|deployt zu| K8s
    App2 -->|deployt zu| K8s

1. Cluster-Block erstellt Kubernetes-Cluster
2. Kubeconfig wird als Artifact gespeichert
3. App-Blocks erben Kubeconfig und deployen zu Cluster

Beispiel:

# Block: prod-cluster
name: prod-cluster
kind: k8scluster
actions:
  - name: create
    script:
      - eksctl create cluster -f cluster.yml
      - eksctl utils write-kubeconfig --cluster=prod > $ARTIFACTS/kubeconfig.yml

# Block: my-app
name: my-app
kind: k8sapp
kubeconfig:
  from: prod-cluster  # Nutzt Kubeconfig vom Cluster-Block
actions:
  - name: install
    playbook: playbooks/deploy-helm.yml

Pattern 3: Multi-Stage-Deployment¶

graph TB
    Start[Start] --> TF[Terraform: Provision]
    TF --> Inv[Generate Inventory]
    Inv --> Ansible[Ansible: Configure]
    Ansible --> Docker[Deploy Docker Compose]
    Docker --> Verify[Verify Deployment]

Komplettes Deployment mit mehreren Integrationen in einem Workflow:

# In workspace.poly
name: my-workspace

blocks:
  - name: infrastructure
    # ...
  - name: configure-servers
    # ...
  - name: my-app
    # ...

workflows:
  - name: deploy-complete-stack
    steps:
      - name: provision-infrastructure
        block: infrastructure
        action: provision  # Terraform

      - name: generate-inventory
        block: infrastructure
        action: generate-inventory

      - name: configure-servers
        block: configure-servers
        action: install  # Ansible

      - name: deploy-application
        block: my-app
        action: deploy  # Docker Compose via Ansible

Best Practices¶

1. Separation of Concerns¶

Trennen Sie Infrastructure, Configuration und Application in separate Blocks:

infrastructure-block (Terraform)
  └── generates inventory
        ↓
configure-block (Ansible)
  └── prepares servers
        ↓
app-block (Docker Compose / K8s)
  └── deploys application

2. Artifact-basierte Kommunikation¶

Nutzen Sie Artifacts für die Kommunikation zwischen Integrationen:

• Terraform → Inventory-Artifact → Ansible
• Kubernetes-Setup → Kubeconfig-Artifact → App-Deployment
• Config-Generator → Config-Files → Application

3. Idempotenz¶

Alle Integrationen sollten idempotent sein: - Ansible-Playbooks: Nutzen Sie state: present, nicht imperative Commands - Kubernetes: Nutzen Sie kubectl apply, nicht create - Terraform: Immer mit State-Management

4. Error-Handling¶

Implementieren Sie Rollback-Strategien in Workflows:

workflows:
  - name: deploy-with-rollback
    steps:
      - name: backup
        block: database
        action: backup

      - name: deploy
        block: app
        action: install
        allow_failure: false  # Stop bei Fehler

      - name: verify
        block: app
        action: health-check

      # Bei Fehler: Rollback
      - name: rollback
        block: app
        action: rollback

Nächste Schritte¶

Erkunden Sie die einzelnen Integrationen im Detail:

1. Für Configuration Management: Ansible-Dokumentation
2. Für Container-Orchestration: Kubernetes-Dokumentation
3. Für Infrastructure Provisioning: Terraform-Dokumentation
4. Für Remote-Access: SSH-Dokumentation

Oder lernen Sie, wie Sie Workflows erstellen, die mehrere Integrationen orchestrieren.