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!

Related MCP server: MCP Toolkit

🎥 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 .