Skip to content

AI für DevOps & CI/CD

4. März 2026 Künstliche Intelligenz By MetinC

AI für DevOps & CI/CD: Docker, Kubernetes, GitHub Actions und Terraform mit Claude & ChatGPT automatisieren. 12 Prompts für Infrastructure as Code, Monitoring und Deployment.

Einleitung

DevOps und CI/CD sind Bereiche mit enormem Automatisierungspotenzial durch KI. Dockerfiles, Pipeline-Konfigurationen, Terraform-Module, Kubernetes-Manifeste – all das folgt Patterns, die KI hervorragend generieren und optimieren kann.

In diesem Artikel findest du 12 Prompts für die häufigsten DevOps-Aufgaben, von Docker bis Monitoring.

Im Grunde sparst du dadurch langfristig viel Zeit.

Inhaltsverzeichnis

  1. Prompt 1: Optimiertes Dockerfile
  2. Prompt 2: Docker Compose für Dev-Environment
  3. Prompt 3: GitHub Actions Pipeline
  4. Prompt 4: Terraform Module
  5. Prompt 5: Kubernetes Manifeste
  6. Prompt 6: Monitoring & Alerting Setup
  7. Prompt 7: Nginx/Reverse Proxy Konfiguration
  8. Prompt 8: Secrets Management
  9. Prompt 9: Zentrales Logging
  10. Prompt 10: Auto-Scaling Konfiguration
  11. Prompt 11: DevSecOps Pipeline
  12. Prompt 12: Disaster Recovery Plan
  13. FAQ

Dabei ist der folgende Punkt besonders wichtig.

Prompt 1: Optimiertes Dockerfile

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

Erstelle ein produktions-optimiertes Dockerfile:

App: [z.B. "Node.js 20, TypeScript, Express"]
Package Manager: [npm / pnpm / yarn]

Anforderungen:
1. Multi-Stage Build (build + production stage)
2. Minimales Base Image (alpine oder distroless)
3. Non-root User
4. Layer-Caching optimiert (package.json vor Quellcode)
5. .dockerignore Datei
6. Health Check Instruction
7. Nur produktionsnotwendige Dependencies installieren
8. Build-Args für Umgebungsvariablen
9. Geschätzte Image-Größe (vor und nach Optimierung)

Bonus: Erkläre jede Zeile mit einem kurzen Kommentar.

Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.

Vor allem in der Praxis hat sich dieser Workflow bewährt.

Prompt 2: Docker Compose für Dev-Environment

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

Erstelle ein docker-compose.yml für die lokale Entwicklung:

Services:
- App: [z.B. "Node.js mit Hot-Reload"]
- DB: [z.B. "PostgreSQL 16"]
- Cache: [z.B. "Redis 7"]
- Queue: [z.B. "RabbitMQ" oder "keiner"]

Anforderungen:
1. Hot-Reload (Volume-Mount für Quellcode)
2. Persistente Datenbank-Daten (Named Volume)
3. Environment-Variablen über .env Datei
4. Health Checks für alle Services
5. Network-Isolation (Frontend-Backend-DB)
6. Ports: Nur nötige exponieren
7. Init-Scripts für Datenbank (Schema + Seed-Daten)
8. docker-compose.override.yml für lokale Anpassungen

Liefere: docker-compose.yml + .env.example + README mit Befehlen

Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.

Tatsächlich zeigt die Praxis, dass dieser Ansatz sehr effektiv ist.

Prompt 3: GitHub Actions Pipeline

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

Erstelle eine GitHub Actions CI/CD Pipeline:

Projekt: [z.B. "Next.js App, TypeScript, Prisma"]
Deploy-Ziel: [z.B. "Vercel / AWS ECS / Docker Hub"]

Jobs:
1. lint (ESLint + Prettier Check)
2. typecheck (tsc --noEmit)
3. test (Jest/Vitest mit Coverage)
4. build (Next.js Build)
5. deploy-staging (bei Push auf develop)
6. deploy-production (bei Push auf main)

Anforderungen:
- Dependency Caching (node_modules)
- Matrix Strategy für Node 18 + 20
- Concurrency: Nur ein Deploy gleichzeitig
- Secrets über GitHub Secrets
- Slack/Discord Notification bei Failure
- Coverage Report als PR-Kommentar
- Deploy nur wenn alle vorherigen Jobs grün sind

Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.

Außerdem profitierst du von einem systematischen Vorgehen.

Prompt 4: Terraform Module

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

Erstelle ein Terraform-Modul für folgende Infrastruktur:

Cloud: [AWS / GCP / Azure]
Ressource: [z.B. "Web-App mit Load Balancer, Auto-Scaling, RDS Database"]

Anforderungen:
1. Modulare Struktur (variables.tf, outputs.tf, main.tf)
2. Remote State (S3 + DynamoDB Lock)
3. Environments via Workspaces oder tfvars
4. Security Groups / Firewall Rules (Principle of Least Privilege)
5. Tags für Cost Management
6. Encryption at Rest für alle Datenbanken/Volumes
7. Outputs für Connection Strings und Endpunkte

Best Practices:
- Keine Hardcoded Werte
- Validierung für alle Variablen
- Lifecycle Rules wo nötig
- Data Sources statt hardcoded AMIs/Images

Folglich verbessert sich die gesamte Codequalität deutlich.

Prompt 5: Kubernetes Manifeste

Somit kannst du direkt mit der Umsetzung beginnen.

Erstelle Kubernetes-Manifeste für meine App:

App: [z.B. "Node.js API, 3 Replicas, mit Redis Sidecar"]
Namespace: [z.B. "production"]

Erstelle:
1. Deployment (mit Resource Limits, Probes, Anti-Affinity)
2. Service (ClusterIP + LoadBalancer/Ingress)
3. ConfigMap (für nicht-sensible Config)
4. Secret (für sensible Werte, base64)
5. HorizontalPodAutoscaler (CPU + Memory basiert)
6. Ingress (mit TLS/SSL, cert-manager)
7. NetworkPolicy (nur erlaubter Traffic)

Best Practices:
- Resource Requests und Limits definiert
- Liveness + Readiness + Startup Probes
- Rolling Update Strategy (maxSurge, maxUnavailable)
- Pod Disruption Budget
- Labels und Annotations für Monitoring

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

Im Folgenden gehe ich auf die wichtigsten Details ein.

Prompt 6: Monitoring & Alerting Setup

Natürlich gibt es dabei verschiedene Herangehensweisen.

Erstelle ein Monitoring-Setup für meine Applikation:

Stack: [z.B. "Prometheus + Grafana" oder "Datadog" oder "CloudWatch"]
App: [z.B. "Node.js Express API"]

Implementiere:
1. Application Metrics:
   - Request Rate (req/sec)
   - Error Rate (5xx/4xx pro Endpunkt)
   - Response Time (p50, p95, p99)
   - Active Connections

2. Infrastructure Metrics:
   - CPU, Memory, Disk Usage
   - Container Restarts
   - Network I/O

3. Business Metrics:
   - Registrierungen/Stunde
   - API-Aufrufe pro Kunde
   - Fehlerquote bei Payments

4. Alert Rules:
   - Error Rate > 5% für 5 Minuten → PagerDuty
   - Response Time p99 > 2s → Slack Warning
   - CPU > 80% für 10 Minuten → Auto-Scale + Alert
   - Disk > 90% → Critical Alert

5. Grafana Dashboards (JSON-Export)

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

Ebenso hilfreich ist ein strukturierter Ansatz bei der Umsetzung.

Prompt 7: Nginx/Reverse Proxy Konfiguration

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

Erstelle eine Nginx-Konfiguration:

Aufgabe: [z.B. "Reverse Proxy für Node.js API + Next.js Frontend"]

Anforderungen:
1. SSL/TLS (Let's Encrypt, A+ SSL Labs Rating)
2. HTTP/2 aktiviert
3. Gzip-Kompression für Text-Assets
4. Static File Caching (Bilder, CSS, JS)
5. Rate Limiting (100 req/min pro IP)
6. Security Headers (HSTS, X-Frame-Options, CSP)
7. WebSocket Proxy (falls nötig)
8. Load Balancing (Round Robin, mehrere Backend-Server)
9. Access + Error Logs (JSON-Format für Log-Aggregation)
10. Redirect: HTTP → HTTPS, www → non-www

Darüber hinaus lässt sich das Beispiel leicht erweitern.

Allerdings gibt es dabei einige Punkte, die du beachten solltest.

Prompt 8: Secrets Management

Grundsätzlich gibt es dabei einige Punkte zu beachten.

Implementiere ein Secrets Management System:

Umgebung: [z.B. "AWS + GitHub Actions + Node.js"]
Aktuelle Situation: [z.B. ".env Dateien im Repo, Secrets in CI-Variablen"]

Plan:
1. Vergleich: AWS Secrets Manager vs HashiCorp Vault vs SOPS
2. Empfehlung für mein Setup
3. Migration: .env → Secrets Manager
4. Integration in die App (SDK, Environment Variables)
5. Integration in CI/CD (GitHub Actions Secrets → Runtime)
6. Rotation-Strategie (automatisch alle 90 Tage)
7. Audit-Logging (wer hat wann auf welches Secret zugegriffen)
8. Notfall-Prozess: Secret ist geleaked – was tun?

Insbesondere für fortgeschrittene Projekte ist das relevant.

Prompt 9: Zentrales Logging

Allerdings gibt es einige wichtige Unterschiede zu beachten.

Implementiere ein zentrales Logging-System:

App: [z.B. "3 Node.js Microservices + 1 Next.js Frontend"]
Stack: [z.B. "ELK Stack / Loki + Grafana / CloudWatch"]

Anforderungen:
1. Strukturiertes JSON-Logging (pino / winston)
2. Correlation ID über Service-Grenzen hinweg
3. Log Levels: error, warn, info, debug (konfigurierbar pro Umgebung)
4. Sensitive Daten maskieren (Passwörter, Tokens, PII)
5. Request/Response Logging (ohne Body für Performance)
6. Retention Policy (30 Tage hot, 90 Tage cold)
7. Log-basierte Alerts (Error-Burst, unerwartete Patterns)
8. Dashboard für Log-Suche und Analyse

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

Somit ergibt sich ein klarer Vorteil gegenüber manuellen Methoden.

Prompt 10: Auto-Scaling Konfiguration

Dennoch solltest du einige Besonderheiten beachten.

Konfiguriere Auto-Scaling für meine App:

Infrastruktur: [z.B. "AWS ECS Fargate" oder "Kubernetes"]
Aktuelle Last: [z.B. "500 DAU, Peak 2000 req/min um 12 Uhr"]
Erwartetes Wachstum: [z.B. "10x in den nächsten 6 Monaten"]

Implementiere:
1. Horizontal Scaling (mehr Container/Pods)
2. Scaling-Metriken (CPU, Memory, Custom Metrics wie Request Queue)
3. Scale-Up Policy (schnell, bei 70% CPU für 2 Minuten)
4. Scale-Down Policy (langsam, Cooldown 10 Minuten)
5. Min/Max Instanzen pro Umgebung
6. Database Connection Pooling (für Scale-Events)
7. Kosten-Schätzung pro Scaling-Stufe
8. Load Testing Empfehlung (k6 / Artillery)

Ebenfalls sinnvoll ist es, verschiedene Varianten auszuprobieren.

Deshalb ist es wichtig, diesen Abschnitt aufmerksam zu lesen.

Prompt 11: DevSecOps Pipeline

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

Erweitere meine CI/CD Pipeline um Security-Checks:

Aktuelle Pipeline: [z.B. "GitHub Actions: lint → test → build → deploy"]

Füge hinzu:
1. SAST (Static Application Security Testing)
   - Tool: Semgrep oder CodeQL
   - Wann: Bei jedem PR

2. Dependency Scanning
   - Tool: npm audit / Snyk / Dependabot
   - Wann: Täglich + bei jedem PR

3. Container Scanning
   - Tool: Trivy oder Snyk Container
   - Wann: Vor jedem Deploy

4. Secret Scanning
   - Tool: gitleaks oder truffleHog
   - Wann: Bei jedem Push (pre-receive hook)

5. DAST (Dynamic Testing)
   - Tool: OWASP ZAP
   - Wann: Nach Deploy auf Staging

6. License Compliance Check
7. SBOM Generation (Software Bill of Materials)

Liefere die GitHub Actions YAML Konfiguration.

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Grundsätzlich empfiehlt es sich, schrittweise vorzugehen.

Prompt 12: Disaster Recovery Plan

Ebenso wichtig ist es, die Best Practices zu kennen.

Erstelle einen Disaster Recovery Plan:

App: [Beschreibung]
Infrastruktur: [z.B. "AWS, eu-central-1, RDS + S3 + ECS"]
SLA: [z.B. "99.9% Uptime, RTO 1h, RPO 15min"]

Der Plan soll enthalten:
1. Risiko-Analyse: Was kann ausfallen? (Region, Service, DB, DNS)
2. Backup-Strategie:
   - Datenbank: Automatische Snapshots (Frequenz, Retention)
   - Dateien/S3: Cross-Region Replication
   - Code: Git (ohnehin verteilt)
   - Konfiguration: Infrastructure as Code (Terraform State)

3. Recovery-Prozesse:
   - DB-Restore aus Snapshot (Schritt für Schritt)
   - App-Deployment aus Git (kompletter Neuaufbau)
   - DNS-Failover (Route53 Health Checks)
   
4. Multi-Region Setup (Active-Passive oder Active-Active)
5. Kommunikations-Plan (wer wird wann informiert)
6. Test-Prozedur (vierteljährlicher DR-Test)
7. Runbook für häufigste Szenarien

Ebenfalls empfehlenswert ist eine regelmäßige Überprüfung der Ergebnisse.

FAQ

Kann KI meine komplette Infrastruktur erstellen?

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

Für Standard-Setups (Web-App + DB + CDN): Ja, zu 90%. Für komplexe Multi-Region-Setups mit vielen Services: KI als Startpunkt, dann manuell anpassen und testen. Nie ungeprüft in Production deployen.

Docker oder Kubernetes?

Dabei spielen mehrere Faktoren eine wichtige Rolle.

Docker Compose für kleine Teams (1-5 Entwickler) und einfache Apps. Kubernetes ab mittlerer Komplexität (Microservices, Auto-Scaling, Multi-Region). Managed Kubernetes (EKS, GKE) senkt die Einstiegshürde.

Terraform oder Pulumi?

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

Terraform hat das größere Ökosystem und mehr KI-Trainings-Daten (bessere Generierung). Pulumi ist besser wenn dein Team TypeScript/Python bevorzugt. Für neue Projekte 2026: Beides valide, Terraform ist der sichere Standard.

Wie schütze ich Secrets in CI/CD?

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

Nie in Code oder Environment-Variablen im Repo. Nutze: GitHub Secrets (CI), AWS Secrets Manager oder Vault (Runtime). Secrets automatisch rotieren. Gitleaks als pre-commit Hook gegen versehentliche Commits.

Dementsprechend solltest du die einzelnen Schritte sorgfältig abarbeiten.

Verwandte Artikel:

Weiterhin ist es sinnvoll, die Ergebnisse regelmäßig zu überprüfen.

Zuletzt aktualisiert: März 2026