cloud-pilot stellt drei Tools bereit — search, execute und tofu —, die zusammen über 1.289 Dienste und 51.900+ API-Operationen mit vollständigem Infrastruktur-Lebenszyklusmanagement abdecken. Entdecken Sie APIs zur Laufzeit, führen Sie Skripte gegen den Live-Cloud-Status aus und verwalten Sie zustandsbehaftete Bereitstellungen mit Planen/Anwenden/Zerstören über OpenTofu.

Wenn sich ein Agent verbindet, liefert der Server eine Senior Cloud Platform Engineer-Persona — komplett mit technischen Prinzipien, anbieterspezifischem Fachwissen, Sicherheitsbewusstsein und strukturierten Workflow-Prompts —, sodass der Agent automatisch mit Cloud-Architektur- und Sicherheitsstandards auf Produktionsniveau arbeitet.

Demo: Drei-Schichten-AWS-Bereitstellung mit OpenTofu — VPC, ALB, ASG, RDS bereitgestellt und zerstört über das tofu-Tool.

Vollständige Demo ansehen

Was hat sich in v0.2 geändert:

Native SDK-Ausführung — AWS-Aufrufe verwenden @aws-sdk/client-*-Pakete (kein benutzerdefiniertes HTTP). Azure verwendet @azure/core-rest-pipeline mit automatischem Retry/Throttling. Keine Serialisierungsfehler.
OpenTofu-Integration — neues tofu-Tool für zustandsbehafteten Infrastruktur-Lebenszyklus: HCL schreiben, planen, anwenden, zerstören, bestehende Ressourcen importieren, Drift-Erkennung und Rollback.
4-stufiges Dry-Run-System — native Cloud-Anbieter-Validierung (AWS DryRun), sitzungsgesteuertes Gate, Wirkungszusammenfassungen mit Kostenwarnungen und Sitzungs-Änderungssätze mit Rollback-Plänen.
Konfigurierbare Sicherheit — dryRunPolicy pro Anbieter: enforced (interaktive Sitzungen), optional (genehmigte Automatisierung), disabled (schreibgeschützte Bots).

Inhaltsverzeichnis

Abschnitt	Beschreibung
Das Problem	Warum bestehende Ansätze zu kurz greifen
Funktionsweise	Das Drei-Tool-Muster: search, execute, tofu
Cloud-Anbieter-Abdeckung	4 Anbieter, 1.289 Dienste, 51.900+ Operationen
Architektur	Systemdesign und Komponentenübersicht
Integrierte Cloud-Engineering-Persona	Anweisungen, Ressourcen, Prompts, Konfiguration
Warum cloud-pilot?	Wenn Sie eine Steuerungsebene zwischen KI-Agenten und Ihrer Cloud benötigen
Agenten, die handeln, nicht beraten	Wie cloud-pilot KI vom Berater zum Akteur macht — echtes Bereitstellungsbeispiel
Unternehmensintegration	ServiceNow, Teams/Slack und wie MCP eine Integration für alle Clouds ermöglicht
Infrastruktur-Lebenszyklus mit OpenTofu	Zustandsbehaftete Bereitstellungen: planen, anwenden, zerstören, importieren, Drift-Erkennung, Rollback
Praxisbeispiele	Landing Zones, globales WAN, K8s, Incident Response, Kostenanalyse
Erste Schritte
Schnellstart	Voraussetzungen, Installation und Ausführung
Anmeldedaten konfigurieren	Auto-Discovery, Umgebungsvariablen, Vault, Azure AD
Mit Docker ausführen	Container-Bereitstellung
Mit Ihrem MCP-Client verbinden	stdio, HTTP, API-Schlüssel-Authentifizierung
Plattform-Integrationsbeispiele	OpenAI SDK, Cursor, LangChain, benutzerdefinierte Agenten
Referenz
Konfigurationsreferenz	Vollständiges `config.yaml`-Schema und Überschreibungen durch Umgebungsvariablen
Dynamische API-Erkennung	Drei-Stufen-Spezifikationssystem: Katalog, Index, vollständige Spezifikationen
Sicherheitsmodell	Sandbox-Isolationsstufen, Modi, Zulassungslisten, Audit-Protokoll
HTTP-Transportsicherheit	Auth, CORS, Ratenbegrenzung
Betrieb
CI/CD-Pipeline	Build, Test, Docker, Katalog-Aktualisierung
Projektstruktur	Rundgang durch den Quellcode-Baum
Erweiterung	Anbieter, Auth-Backends, Bereitstellungsziele hinzufügen
Fehlerbehebung	Häufige Probleme und Diagnoseschritte

Das Problem

Cloud-Anbieter stellen Tausende von API-Operationen über Hunderte von Diensten bereit. Traditionelle Ansätze für KI-gesteuertes Cloud-Management sind entweder:

Hardcodierung einer Handvoll Tools (z. B. "EC2-Instanzen auflisten", "S3-Bucket erstellen") — was die Möglichkeiten des Agenten auf das beschränkt, was der Entwickler vorhergesehen hat
Generierung Hunderter von MCP-Tools aus API-Spezifikationen — was das Kontextfenster des Agenten überlastet und die Tool-Auswahl unzuverlässig macht
Erfordern manuelle Updates, jedes Mal wenn ein Cloud-Anbieter einen neuen Dienst startet

cloud-pilot-mcp löst dies mit einem Suchen-und-Ausführen-Muster: Der Agent entdeckt zur Laufzeit, was er benötigt, und ruft es dann über eine isolierte Ausführungsumgebung auf. Keine vorgefertigten Tools, keine feste Dienstliste, keine manuellen Updates.

Funktionsweise

                  User                        Agent                      cloud-pilot-mcp
                   |                            |                              |
                   |  "Set up a Transit Gateway |                              |
                   |   connecting three VPCs"    |                              |
                   |--------------------------->|                              |
                   |                            |                              |
                   |                            |  search("transit gateway")   |
                   |                            |----------------------------->|
                   |                            |                              |
                   |                            |  CreateTransitGateway,       |
                   |                            |  CreateTGWVpcAttachment,     |
                   |                            |  CreateTGWRouteTable + schemas|
                   |                            |<-----------------------------|
                   |                            |                              |
                   |                            |  execute(provider: "aws",    |
                   |                            |    code: sdk.request({       |
                   |                            |      service: "ec2",         |
                   |                            |      action: "CreateTGW",    |
                   |                            |      params: {...}           |
                   |                            |    })                        |
                   |                            |----------------------------->|
                   |                            |                              |  QuickJS
                   |                            |                              |  Sandbox
                   |                            |                              |----+
                   |                            |                              |    | SigV4
                   |                            |                              |    | signed
                   |                            |                              |<---+
                   |                            |  Transit Gateway ID, state   |
                   |                            |<-----------------------------|
                   |                            |                              |
                   |  "Done! TGW tgw-0abc123    |                              |
                   |   created in us-east-1"    |                              |
                   |<---------------------------|                              |

Der Agent überlegt, welche APIs existieren, plant die Sequenz und führt sie aus — alles innerhalb des Gesprächs.

Cloud-Anbieter-Abdeckung

  +-------------------------------------------+
  |          51,900+ API Operations            |
  |                                            |
  |   +----------+  +---------+  +--------+   |
  |   |   AWS    |  |  Azure  |  |  GCP   |   |
  |   | 421 svcs |  | 240+    |  | 305    |   |
  |   | 18,109   |  | 3,157   |  | 12,599 |   |
  |   |   ops    |  |   ops   |  |  ops   |   |
  |   +----------+  +---------+  +--------+   |
  |                                            |
  |              +-----------+                 |
  |              |  Alibaba  |                 |
  |              |  323 svcs |                 |
  |              |  18,058   |                 |
  |              |    ops    |                 |
  |              +-----------+                 |
  +-------------------------------------------+

Anbieter	Dienste	Operationen	Spezifikationsquelle	Auth
AWS	421	18.109	boto/botocore via jsDelivr CDN	AWS CLI / SDK-Credential-Chain -> Nativ `@aws-sdk/client-*`
Azure	240+	3.157	azure-rest-api-specs via GitHub CDN	Azure CLI / DefaultAzureCredential -> `@azure/core-rest-pipeline`
GCP	305	12.599	Google Discovery API (live)	gcloud CLI / GoogleAuth -> Bearer-Token
Alibaba	323	18.058	Alibaba Cloud API + api-docs.json	aliyun CLI / Credential-Chain -> ACS3-HMAC-SHA256
Gesamt	1.289+	51.923

Alle Dienste werden dynamisch erkannt — keine Vorkonfiguration erforderlich. Wenn ein Cloud-Anbieter einen neuen Dienst startet, wird dieser automatisch bei der nächsten Katalogaktualisierung verfügbar.

Architektur

                         MCP Protocol (stdio or Streamable HTTP)
                                       |
                         +-------------v--------------+
                         |      cloud-pilot-mcp       |
                         |                            |
    +--------------------+----------------------------+--------------------+
    |                    |                            |                    |
    |  +--------------+  |  +--------------+          |  +--------------+  |
    |  |   Persona    |  |  |    search    |          |  |   Safety     |  |
    |  +--------------+  |  +--------------+          |  |   + Audit    |  |
    |  | Sr. Cloud    |  |  | 51,900+ ops  |          |  +--------------+  |
    |  | Platform     |  |  |              |          |  | read-only    |  |
    |  | Engineer     |  |  | Tier 1:      |          |  | allowlists   |  |
    |  |              |  |  |  Catalog     |          |  | blocklists   |  |
    |  | 8 principles |  |  |  (1,289 svc) |          |  | 4-level      |  |
    |  | 6 prompts    |  |  | Tier 2:      |          |  |  dry-run     |  |
    |  | 4 provider   |  |  |  Op Index    |          |  | audit trail  |  |
    |  |   guides     |  |  | Tier 3:      |          |  | dryRunPolicy |  |
    |  |              |  |  |  Full Spec   |          |  | rate limit   |  |
    |  +--------------+  |  +--------------+          |  +--------------+  |
    |                    |                            |                    |
    |  +--------------+  |  +--------------+          |                    |
    |  |   execute    |  |  |    tofu      |          |                    |
    |  +--------------+  |  +--------------+          |                    |
    |  | VM sandbox   |  |  | OpenTofu     |          |                    |
    |  | Native SDK   |  |  | plan/apply   |          |                    |
    |  | calls        |  |  | destroy      |          |                    |
    |  |              |  |  | import       |          |                    |
    |  | Fast reads,  |  |  | State mgmt   |          |                    |
    |  | ad-hoc       |  |  | Drift detect |          |                    |
    |  | scripts      |  |  | Rollback     |          |                    |
    |  +--------------+  |  +--------------+          |                    |
    +--------------------+----------------------------+--------------------+
                         |    |         |         |
                +--------+    +---+     +---+     +--------+
                |                 |         |              |
           +----v-----+    +-----v---+  +--v-----+  +-----v------+
           |   AWS    |    |  Azure  |  |  GCP   |  |  Alibaba   |
           | Native   |    | ARM     |  | REST   |  | ACS3-HMAC  |
           | SDK v3   |    | Pipeline|  | + Auth |  | + fetch    |
           | 421 svcs |    | 240+    |  | 305    |  | 323 svcs   |
           +----------+    +---------+  +--------+  +------------+

Integrierte Cloud-Engineering-Persona

Wenn sich ein KI-Agent mit cloud-pilot-mcp verbindet, formt der Server das Verhalten des Agenten automatisch durch vier Ebenen:

Server-Anweisungen (immer übermittelt)

Bei jeder Verbindung sendet der Server MCP-instructions, die den Agenten als Senior Cloud Platform Engineer, Security Architect und DevOps Specialist etablieren, mit:

8 Kernprinzipien: Sicherheit zuerst, Infrastructure as Code, Minimierung des Explosionsradius, Verteidigung in der Tiefe, Kostenbewusstsein, operative Exzellenz, Well-Architected Framework, Hochverfügbarkeit standardmäßig
Verhaltensstandards: Suchen vor dem Ausführen, Status überprüfen vor dem Ändern, Dry-Run zuerst bei mutierenden Operationen, Begründung erklären, vor Kosten/Risiken warnen, Überwachung bei Änderungen einbeziehen
Sicherheitsbewusstsein: Den aktuellen Modus verstehen und kommunizieren (schreibgeschützt/lesen-schreiben/voll), Audit-Protokoll respektieren, Dry-Run verwenden

Die Anweisungen sind dynamisch darauf zugeschnitten, nur die konfigurierten Anbieter, deren Modi, Regionen und erlaubten Dienste einzubeziehen.

Anbieter-Fachwissen (auf Abruf über MCP-Ressourcen)

Umfassende, anbieterspezifische technische Leitfäden (jeweils ca. 1.500 Wörter) sind als MCP-Ressourcen verfügbar:

Ressourcen-URI	Inhalt
`cloud-pilot://persona/overview`	Vollständiges Persona-Dokument mit allen Prinzipien und Anbieterzusammenfassung
`cloud-pilot://persona/aws`	VPC/TGW-Design, IAM-Rollen, GuardDuty/SecurityHub, S3-Lebenszyklus, Graviton, Anti-Patterns
`cloud-pilot://persona/azure`	Landing Zones, Entra ID/Managed Identity, Virtual WAN, Defender, Policy, PIM
`cloud-pilot://persona/gcp`	Shared VPC, Workload Identity Federation, GKE Autopilot, VPC Service Controls
`cloud-pilot://persona/alibaba`	CEN, RAM/STS, ACK, Security Center, China-spezifisch (ICP, Datenresidenz)
`cloud-pilot://safety/{provider}`	Aktueller Sicherheitsmodus, erlaubte Dienste, blockierte Aktionen, Audit-Konfiguration

Agenten rufen diese bei Bedarf ab — sie verursachen keinen Overhead bei Verbindungen, bei denen sie nicht benötigt werden.

Workflow-Prompts (strukturierte mehrstufige Verfahren)

Sechs MCP-Prompts bieten meinungsstarke, mehrstufige Workflows, die Agenten aufrufen können:

Prompt	Was es tut
`landing-zone`	Bereitstellung einer vollständigen Cloud-Landing-Zone: Organisationsstruktur, Identität, Netzwerk, Sicherheitsbasis, Überwachung
`incident-response`	Sicherheitsvorfall-Lebenszyklus: Eindämmen, untersuchen, beseitigen, wiederherstellen, Post-Mortem
`cost-optimization`	Vollständiges Kosten-Audit: ungenutzte Ressourcen, Rightsizing, reservierte Kapazität, Storage-Tiering, Netzwerkkosten
`security-audit`	Umfassende Sicherheitsüberprüfung: IAM, Netzwerk, Verschlüsselung, Protokollierung, Compliance, Schwachstellenmanagement
`migration-assessment`	Workload-Migrationsplanung: Erkennung, 6R-Strategie, Zielarchitektur, Migrationswellen, Cutover
`well-architected-review`	Well-Architected Framework-Überprüfung über alle 6 Säulen mit anbieternativen Empfehlungen

Jeder Prompt akzeptiert ein provider-Argument (dynamisch auf konfigurierte Anbieter begrenzt) und gibt strukturierte Anleitungen zurück, denen der Agent Schritt für Schritt mit search und execute folgt.

Persona-Konfiguration

Die Persona ist standardmäßig aktiviert. Passen Sie sie in config.yaml an oder deaktivieren Sie sie:

persona:
  enabled: true                 # Set false to disable all persona features
  # instructionsOverride: "..." # Replace default instructions with your own
  # additionalGuidance: "..."   # Append custom policies (e.g., "All resources must be tagged with CostCenter")
  enablePrompts: true           # Set false to disable workflow prompts
  enableResources: true         # Set false to disable persona resources

Oder über die Umgebungsvariable: CLOUD_PILOT_PERSONA_ENABLED=false

Warum cloud-pilot?

Wenn Sie ein Entwickler mit Claude Code oder Cursor sind und Ihre eigenen AWS-Anmeldedaten haben, brauchen Sie dies nicht — führen Sie einfach aws-CLI-Befehle direkt aus. Die KI kennt bereits die CLI-Syntax, und Sie vertrauen sich selbst mit Administratorzugriff.

cloud-pilot existiert für den Fall, dass das, was mit Ihrer Cloud spricht, nicht Sie in einem Terminal sind. Es ist die Steuerungsebene zwischen nicht vertrauenswürdigen oder teilweise vertrauenswürdigen KI-Agenten und Ihren Cloud-Konten.

SaaS-Produkt — Cloud Copilot für Ihre Kunden

Sie bauen eine Plattform, auf der Kunden ihre AWS/Azure/GCP-Konten verbinden und ihre Teams die Infrastruktur über eine Chat-Schnittstelle verwalten. Sie können der KI keine rohen Anmeldedaten geben — Sie benötigen einen schreibgeschützten Modus für Junior-Ingenieure, Lesen-Schreiben für Senioren, ein vollständiges Audit-Protokoll für Compliance und Dienst-Zulassungslisten, damit niemand versehentlich Produktionsdatenbanken berührt. Cloud-pilot ist die Middleware, die dies sicher macht.

Internes DevOps-Portal

Ihr Unternehmen hat 50 Ingenieure. Anstatt jedem AWS-Konsolenzugriff mit weitreichenden IAM-Richtlinien zu geben, stellen Sie cloud-pilot hinter einer internen Chat-Schnittstelle bereit. Ingenieure fragen "Was läuft in Staging?" oder "Skaliere den ECS-Dienst hoch". Das MCP erzwingt, wer lesen vs. schreiben darf, protokolliert jede Aktion, und das Infra-Team überprüft das Audit-Protokoll. Ein Satz Anmeldedaten, kontrollierter Zugriff, volle Sichtbarkeit.

Incident-Response-Bot

Ein PagerDuty-Alarm geht um 3 Uhr morgens los. Ein automatisierter Agent verbindet sich über cloud-pilot, zieht CloudWatch-Metriken, prüft den EC2-Instanzstatus, greift CloudTrail-Ereignisse ab und

Cloud Pilot MCP