Kubectl MCP Tool

Kubectl MCP-Tool

Ein Model Context Protocol (MCP)-Server für Kubernetes, der es KI-Assistenten wie Claude, Cursor und anderen ermöglicht, über natürliche Sprache mit Kubernetes-Clustern zu interagieren.

🎥 Live-Demo – Sehen Sie kubectl-mcp-tool mit Claude in Aktion!

🎥 Live-Demo – Sehen Sie kubectl-mcp-tool mit Cursor in Aktion!

🎥 Live-Demo – Sehen Sie kubectl-mcp-tool mit Windsurf in Aktion!

Merkmale

Kernvorgänge von Kubernetes

• [x] Verbindung zu einem Kubernetes-Cluster herstellen
• [x] Pods, Dienste, Bereitstellungen und Knoten auflisten und verwalten
• [x] Pods und andere Ressourcen erstellen, löschen und beschreiben
• [x] Pod-Protokolle und Kubernetes-Ereignisse abrufen
• [x] Unterstützung für Helm v3-Operationen (Installation, Upgrades, Deinstallation)
• [x] kubectl explain und API-Ressourcen-Unterstützung
• [x] Namespace für die nächsten Befehle auswählen (Speicherpersistenz)
• [x] Portweiterleitung zu Pods
• [x] Skalieren von Bereitstellungen und Statefulsets
• [x] Befehle in Containern ausführen
• [x] ConfigMaps und Secrets verwalten
• [x] Rollback von Bereitstellungen auf frühere Versionen
• [x] Ingress- und NetworkPolicy-Verwaltung
• [x] Kontextwechsel zwischen Clustern

Verarbeitung natürlicher Sprache

• [x] Verarbeiten Sie Abfragen in natürlicher Sprache für Kubectl-Operationen
• [x] Kontextabhängige Befehle mit Erinnerung an vorherige Operationen
• [x] Benutzerfreundliche Erklärungen der Kubernetes-Konzepte
• [x] Intelligente Befehlskonstruktion aus Absicht
• [x] Fallback auf kubectl, wenn keine Spezialwerkzeuge verfügbar sind
• [x] Unterstützung von Mock-Daten für Offline-/Test-Szenarien
• [x] Namespace-bewusste Abfragebehandlung

Überwachung

• [x] Cluster-Integritätsüberwachung
• [x] Verfolgung der Ressourcennutzung
• [x] Pod-Status und Gesundheitschecks
• [x] Ereignisüberwachung und Alarmierung
• [x] Knotenkapazitäts- und Zuordnungsanalyse
• [x] Historische Leistungsverfolgung
• [x] Ressourcennutzungsstatistik über kubectl top
• [x] Containerbereitschaft und Liveness-Tracking

Sicherheit

• [x] RBAC-Validierung und -Verifizierung
• [x] Sicherheitskontextüberwachung
• [x] Sichere Verbindungen zur Kubernetes-API
• [x] Anmeldeinformationsverwaltung
• [x] Bewertung der Netzwerkrichtlinien
• [x] Container-Sicherheitsscan
• [x] Durchsetzung bewährter Sicherheitspraktiken
• [x] Rollen- und Clusterrollenverwaltung
• [x] ServiceAccount-Erstellung und -Bindung
• [x] PodSecurityPolicy-Analyse
• [x] RBAC-Berechtigungsprüfung
• [x] Validierung des Sicherheitskontexts

Diagnose

• [x] Clusterdiagnose und Fehlerbehebung
• [x] Konfigurationsvalidierung
• [x] Fehleranalyse und Fehlerbehebungsvorschläge
• [x] Überwachung des Verbindungsstatus
• [x] Protokollanalyse und Mustererkennung
• [x] Identifizierung von Ressourcenbeschränkungen
• [x] Pod-Integritätsprüfungsdiagnose
• [x] Identifizierung häufiger Fehlermuster
• [x] Ressourcenvalidierung auf Fehlkonfigurationen
• [x] Detaillierte Validierung der Liveness- und Readiness-Sonde

Erweiterte Funktionen

• [x] Unterstützung mehrerer Transportprotokolle (stdio, SSE)
• [x] Integration mit mehreren KI-Assistenten
• [x] Erweiterbares Tool-Framework
• [x] Unterstützung für benutzerdefinierte Ressourcendefinitionen
• [x] Namespaceübergreifende Operationen
• [x] Batch-Operationen auf mehreren Ressourcen
• [x] Intelligente Zuordnung von Ressourcenbeziehungen
• [x] Fehlererklärung mit Wiederherstellungsvorschlägen
• [x] Volumenverwaltung und -identifikation

Architektur

Model Context Protocol (MCP)-Integration

Das Kubectl MCP Tool implementiert das Model Context Protocol (MCP) und ermöglicht KI-Assistenten die Interaktion mit Kubernetes-Clustern über eine standardisierte Schnittstelle. Die Architektur besteht aus:

1. MCP-Server : Ein kompatibler Server, der Anfragen von MCP-Clients (KI-Assistenten) verarbeitet.
2. Tools Registry : Registriert Kubernetes-Operationen als MCP-Tools mit Schemata
3. Transportschicht : Unterstützt die Transportmethoden stdio, SSE und HTTP
4. Kernoperationen : Übersetzt Tool-Aufrufe in Kubernetes-API-Operationen
5. Antwortformatierer : Konvertiert Kubernetes-Antworten in MCP-kompatible Antworten

Anforderungsfluss

Dual-Mode-Betrieb

Das Tool arbeitet in zwei Modi:

1. CLI-Modus : Direkte Befehlszeilenschnittstelle zum Ausführen von Kubernetes-Operationen
2. Servermodus : Wird als MCP-Server ausgeführt, um Anfragen von KI-Assistenten zu verarbeiten

Installation

Ausführliche Installationsanweisungen finden Sie im Installationshandbuch .

Sie können kubectl-mcp-tool direkt von PyPI installieren:

Für eine bestimmte Version:

Das Paket ist auf PyPI verfügbar: https://pypi.org/project/kubectl-mcp-tool/1.1.1/

Voraussetzungen

• Python 3.9+
• kubectl CLI installiert und konfiguriert
• Zugriff auf einen Kubernetes-Cluster
• pip (Python-Paketmanager)

Globale Installation

Lokale Entwicklungsinstallation

Überprüfen der Installation

Überprüfen Sie nach der Installation, ob das Tool ordnungsgemäß funktioniert:

Hinweis: Dieses Tool dient als MCP-Server für KI-Assistenten und nicht als direkter Kubectl-Ersatz. Der primäre Befehl ist kubectl-mcp serve , der den MCP-Server startet.

Nutzung mit KI-Assistenten

Verwenden des MCP-Servers

Der MCP-Server ( kubectl_mcp_tool.mcp_server ) ist eine robuste Implementierung, die auf dem FastMCP SDK basiert und eine verbesserte Kompatibilität zwischen verschiedenen KI-Assistenten bietet:

Hinweis : Sollten bei der Implementierung des MCP-Servers Fehler auftreten, können Sie auf den Minimal-Wrapper zurückgreifen, indem Sie in Ihrer Konfiguration kubectl_mcp_tool.mcp_server durch kubectl_mcp_tool.minimal_wrapper ersetzen. Der Minimal-Wrapper bietet grundlegende Funktionen bei einfacherer Implementierung.

1. Direkte Konfiguration
   { "mcpServers": { "kubernetes": { "command": "python", "args": ["-m", "kubectl_mcp_tool.mcp_server"], "env": { "KUBECONFIG": "/path/to/your/.kube/config", "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin", "MCP_LOG_FILE": "/path/to/logs/debug.log", "MCP_DEBUG": "1" } } } }
2. Wichtige Umgebungsvariablen
   • MCP_LOG_FILE : Pfad zur Protokolldatei (empfohlen, um eine Verschmutzung der Standardausgabe zu vermeiden)
   • MCP_DEBUG : Auf „1“ setzen für ausführliche Protokollierung
   • MCP_TEST_MOCK_MODE : Auf „1“ setzen, um simulierte Daten anstelle des echten Clusters zu verwenden
   • KUBECONFIG : Pfad zu Ihrer Kubernetes-Konfigurationsdatei
   • KUBECTL_MCP_LOG_LEVEL : Auf „DEBUG“, „INFO“, „WARNING“ oder „ERROR“ eingestellt
3. Testen des MCP-Servers Sie können mit Folgendem testen, ob der Server ordnungsgemäß funktioniert:
   python -m kubectl_mcp_tool.simple_ping
   Dadurch wird versucht, eine Verbindung zum Server herzustellen und einen Ping-Befehl auszuführen.Alternativ können Sie den Server direkt ausführen mit:
   python -m kubectl_mcp_tool

Claude Desktop

Fügen Sie Ihrer Claude Desktop-Konfiguration unter ~/.config/claude/mcp.json (Windows: %APPDATA%\Claude\mcp.json ) Folgendes hinzu:

Cursor-KI

Fügen Sie Ihren Cursor AI-Einstellungen unter MCP Folgendes hinzu, indem Sie einen neuen globalen MCP-Server hinzufügen:

Speichern Sie diese Konfiguration für globale Einstellungen in ~/.cursor/mcp.json .

Hinweis : Ersetzen Sie /path/to/your/.kube/config durch den tatsächlichen Pfad zu Ihrer Kubeconfig-Datei. Auf den meisten Systemen ist dies ~/.kube/config .

Windsurf

Fügen Sie Ihrer Windsurf-Konfiguration unter ~/.config/windsurf/mcp.json (Windows: %APPDATA%\WindSurf\mcp.json ) Folgendes hinzu:

Automatische Konfiguration

Führen Sie zur automatischen Konfiguration aller unterstützten KI-Assistenten das bereitgestellte Installationsskript aus:

Dieses Skript wird:

1. Installieren Sie die erforderlichen Abhängigkeiten
2. Erstellen Sie Konfigurationsdateien für Claude, Cursor und WindSurf
3. Richten Sie die richtigen Pfade und Umgebungsvariablen ein
4. Testen Sie Ihre Kubernetes-Verbindung

Voraussetzungen

1. kubectl installiert und in Ihrem PATH
2. Eine gültige Kubeconfig-Datei
3. Zugriff auf einen Kubernetes-Cluster
4. Helm v3 (optional, für Helm-Operationen)

Beispiele

Pods auflisten

Bereitstellen einer Anwendung

Überprüfen Sie die Pod-Protokolle

Portweiterleitung

Entwicklung

Projektstruktur

MCP-Servertools

Die MCP-Server-Implementierung ( kubectl_mcp_tool.mcp_server ) bietet einen umfassenden Satz von 26 Tools, die von KI-Assistenten zur Interaktion mit Kubernetes-Clustern verwendet werden können:

Core Kubernetes-Ressourcenverwaltung

• get_pods - Alle Pods im angegebenen Namespace abrufen
• get_namespaces – Alle Kubernetes-Namespaces abrufen
• get_services - Alle Dienste im angegebenen Namespace abrufen
• get_nodes - Alle Knoten im Cluster abrufen
• get_configmaps - Alle ConfigMaps im angegebenen Namespace abrufen
• get_secrets - Alle Geheimnisse im angegebenen Namespace abrufen
• get_deployments - Alle Bereitstellungen im angegebenen Namespace abrufen
• create_deployment – Erstellen Sie eine neue Bereitstellung
• delete_resource – Löschen einer Kubernetes-Ressource
• get_api_resources – Kubernetes-API-Ressourcen auflisten
• kubectl_explain - Erklären Sie eine Kubernetes-Ressource mit kubectl explain

Helmoperationen

• install_helm_chart - Helm-Chart installieren
• upgrade_helm_chart – Upgrade einer Helm-Version
• uninstall_helm_chart – Deinstallieren einer Helm-Version

Sicherheitsoperationen

• get_rbac_roles - Alle RBAC-Rollen im angegebenen Namespace abrufen
• get_cluster_roles - Alle clusterweiten RBAC-Rollen abrufen

Überwachung und Diagnose

• get_events - Alle Ereignisse im angegebenen Namespace abrufen
• get_resource_usage – Statistiken zur Ressourcennutzung über kubectl top abrufen
• health_check – Überprüfen Sie die Clusterintegrität, indem Sie den API-Server anpingen
• get_pod_events – Ereignisse für einen bestimmten Pod abrufen
• check_pod_health – Überprüfen Sie den Gesundheitszustand eines Pods
• get_logs - Protokolle von einem Pod abrufen

Clusterverwaltung

• switch_context – Aktuellen Kubeconfig-Kontext wechseln
• get_current_context – Aktuellen Kubeconfig-Kontext abrufen
• port_forward – Leitet den lokalen Port an den Pod-Port weiter
• scale_deployment – Skalieren einer Bereitstellung

Alle Tools geben strukturierte Daten mit Erfolgs-/Fehlerinformationen und relevanten Details zurück, sodass KI-Assistenten die Antworten leicht verarbeiten und verstehen können.

Beitragen

Beiträge sind willkommen! Senden Sie gerne einen Pull Request.

1. Forken Sie das Repository
2. Erstellen Sie Ihren Feature-Zweig ( git checkout -b feature/amazing-feature )
3. Übernehmen Sie Ihre Änderungen ( git commit -m 'Add some amazing feature' )
4. Pushen zum Zweig ( git push origin feature/amazing-feature )
5. Öffnen einer Pull-Anfrage

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .