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:

pip install kubectl-mcp-tool

Für eine bestimmte Version:

pip install kubectl-mcp-tool==1.1.1

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

# Install latest version from PyPI
pip install kubectl-mcp-tool

# Or install development version from GitHub
pip install git+https://github.com/rohitg00/kubectl-mcp-server.git

Lokale Entwicklungsinstallation

# Clone the repository
git clone https://github.com/rohitg00/kubectl-mcp-server.git
cd kubectl-mcp-server

# Install in development mode
pip install -e .

Überprüfen der Installation

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

# Check CLI mode
kubectl-mcp --help

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:

{
  "mcpServers": {
    "kubernetes": {
      "command": "python",
      "args": ["-m", "kubectl_mcp_tool.mcp_server"],
      "env": {
        "KUBECONFIG": "/path/to/your/.kube/config"
      }
    }
  }
}

Cursor-KI

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

{
  "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:/opt/homebrew/bin"
      }
    }
  }
}

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:

{
  "mcpServers": {
    "kubernetes": {
      "command": "python",
      "args": ["-m", "kubectl_mcp_tool.mcp_server"],
      "env": {
        "KUBECONFIG": "/path/to/your/.kube/config"
      }
    }
  }
}

Automatische Konfiguration

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

bash install.sh

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

List all pods in the default namespace

Bereitstellen einer Anwendung

Create a deployment named nginx-test with 3 replicas using the nginx:latest image

Überprüfen Sie die Pod-Protokolle

Get logs from the nginx-test pod

Portweiterleitung

Forward local port 8080 to port 80 on the nginx-test pod

Entwicklung

# Clone the repository
git clone https://github.com/rohitg00/kubectl-mcp-server.git
cd kubectl-mcp-server

# Install dependencies
pip install -r requirements.txt

# Install in development mode
pip install -e .

# Run the MCP server
python -m kubectl_mcp_tool

# Run tests
python -m python_tests.run_mcp_tests

Projektstruktur

├── kubectl_mcp_tool/         # Main package
│   ├── __init__.py           # Package initialization
│   ├── __main__.py           # Package entry point
│   ├── cli.py                # CLI entry point
│   ├── mcp_server.py         # MCP server implementation
│   ├── mcp_kubectl_tool.py   # Main kubectl MCP tool implementation
│   ├── natural_language.py   # Natural language processing
│   ├── diagnostics.py        # Diagnostics functionality
│   ├── core/                 # Core functionality 
│   ├── security/             # Security operations
│   ├── monitoring/           # Monitoring functionality
│   ├── utils/                # Utility functions
│   └── cli/                  # CLI functionality components
├── python_tests/             # Test suite
│   ├── run_mcp_tests.py      # Test runner script
│   ├── mcp_client_simulator.py # MCP client simulator for mock testing
│   ├── test_utils.py         # Test utilities
│   ├── test_mcp_core.py      # Core MCP tests
│   ├── test_mcp_security.py  # Security tests
│   ├── test_mcp_monitoring.py # Monitoring tests
│   ├── test_mcp_nlp.py       # Natural language tests
│   ├── test_mcp_diagnostics.py # Diagnostics tests
│   └── mcp_test_strategy.md  # Test strategy documentation
├── docs/                     # Documentation
│   ├── README.md             # Documentation overview
│   ├── INSTALLATION.md       # Installation guide
│   ├── integration_guide.md  # Integration guide
│   ├── cursor/               # Cursor integration docs
│   ├── windsurf/             # Windsurf integration docs
│   └── claude/               # Claude integration docs
├── compatible_servers/       # Compatible MCP server implementations
│   ├── cursor/               # Cursor-compatible servers
│   ├── windsurf/             # Windsurf-compatible servers
│   ├── minimal/              # Minimal server implementations
│   └── generic/              # Generic MCP servers
├── requirements.txt          # Python dependencies
├── setup.py                  # Package setup script
├── pyproject.toml            # Project configuration
├── MANIFEST.in               # Package manifest
├── mcp_config.json           # Sample MCP configuration
├── run_server.py             # Server runner script
├── LICENSE                   # MIT License
├── CHANGELOG.md              # Version history
├── .gitignore                # Git ignore file
├── install.sh                # Installation script
├── publish.sh                # PyPI publishing script
└── start_mcp_server.sh       # Server startup script

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 .