Verbinden Ihres Azure Kubernetes Service (AKS)-Clusters mit KI-Agents mithilfe des MCP-Servers (Model Context Protocol)

Die einfachste Möglichkeit, mit AKS-MCP zu beginnen, ist die Azure Kubernetes-Diensterweiterung für VS Code. Die AKS-Erweiterung verarbeitet binäre Downloads, Updates und Konfiguration automatisch, um sicherzustellen, dass Sie immer über die neueste Version mit optimalen Einstellungen verfügen.

Schritt 1: Installieren der AKS-Erweiterung

1. Öffnen Sie VS Code, und wechseln Sie zu Erweiterungen (Ctrl+Shift+X unter Windows/Linux oder Cmd+Shift+X unter macOS).
2. Suchen Sie nach Azure Kubernetes Service.
3. Installieren Sie die offizielle Microsoft AKS-Erweiterung.

Schritt 2: Starten des AKS-MCP Servers

1. Öffnen Sie die Befehlspalette (Ctrl+Shift+P unter Windows/Linux oder Cmd+Shift+P unter macOS).
2. Suchen und ausführen: AKS: AKS-MCP-Server einrichten.

Nach erfolgreicher Installation wird der Server in MCP: Listenserver (über Befehlspalette) angezeigt. Von dort aus können Sie den MCP-Server starten oder dessen Status anzeigen.

Schritt 3: Starten der Verwendung von AKS-MCP

Nach dem Start wird der MCP-Server in der Dropdown-Liste "Copilot Chat: Konfigurieren von Tools" unter MCP Server: AKS MCP angezeigt, um kontextbezogene Aufforderungen basierend auf Ihrer AKS-Umgebung zu optimieren. Standardmäßig sind alle AKS-MCP Servertools aktiviert. Sie können die Liste der verfügbaren Tools überprüfen und alle deaktivieren, die für Ihr Szenario nicht erforderlich sind.

Versuchen Sie eine Eingabeaufforderung wie "Alle meine AKS-Cluster auflisten", um mit der Verwendung von Tools vom AKS-MCP-Server zu beginnen.

Für die direkte binäre Verwendung ohne die VS Code-Erweiterung:

Schritt 1: Herunterladen der Binärdatei

Wählen Sie Ihre Plattform aus, und laden Sie die neueste AKS-MCP Binärdatei herunter:

Schritt 2: Konfigurieren von VS-Code

Erstellen Sie im Stammverzeichnis Ihres Arbeitsbereichs eine .vscode/mcp.json Datei mit dem Pfad zur heruntergeladenen Binärdatei.

Arbeitsbereichspezifische Konfiguration (empfohlen für projektspezifische Verwendung):

{
  "servers": {
    "aks-mcp-server": {
      "type": "stdio",
      "command": "<path-to-binary>",
      "args": [
        "--transport", "stdio"
      ]
    }
  }
}

Konfiguration auf Benutzerebene (dauerhaft für alle Arbeitsbereiche):

Fügen Sie Ihren VS Code User Settings JSON hinzu (Ctrl+, oder Cmd+,, suchen Sie dann nach "mcp"):

{
  "github.copilot.chat.mcp.servers": {
    "aks-mcp-server": {
      "type": "stdio",
      "command": "<path-to-binary>",
      "args": [
        "--transport", "stdio"
      ]
    }
  }
}

Schritt 3: Laden der AKS-MCP Servertools

1. Starten Sie VS Code neu, um die neue MCP-Serverkonfiguration zu laden.
2. Öffnen Sie GitHub Copilot in VS Code, und wechseln Sie zum Agentmodus.
3. Wählen Sie die Schaltfläche "Extras " aus, um die Liste der verfügbaren Tools anzuzeigen.
4. Stellen Sie sicher, dass die AKS-MCP Tools in der Liste angezeigt werden.
5. Versuchen Sie eine Eingabeaufforderung wie: "Alle meine AKS-Cluster im Abonnement xxx auflisten".

Sie können den AKS-MCP-Server mit dem offiziellen Docker-Image aus dem Docker MCP Toolkit oder als containerisierte MCP-Konfiguration ausführen.

Option 1: Docker MCP Toolkit

1. Öffnen Sie Docker Desktop.
2. Wählen Sie das MCP-Toolkit in der linken Randleiste aus.
3. Suchen Sie auf der Registerkarte "Katalog" nach "aks".
4. Wählen Sie die AKS-MCP Serverkarte aus.
5. Aktivieren Sie den Server, indem Sie in der oberen rechten Ecke auswählen + .
6. Konfigurieren Sie den Server mithilfe der Registerkarte "Konfiguration ":
   • [REQUIRED]azure_dir: Absoluter Pfad zu Ihrem Azure-Anmeldeinformationsverzeichnis (z. B/home/user/.azure. )
   • kubeconfig: Absoluter Pfad zu Ihrer Kubeconfig-Datei [REQUIRED](z. B/home/user/.kube/config. )
   • access_level[REQUIRED]: Auf readonly, readwrite oder admin nach Bedarf einstellen
   • [OPTIONAL]container_user: Benutzername oder UID zum Ausführen des Containers als (Standard istmcp). Verwenden Sie Ihre Hostbenutzer-ID (z. B 1000. bei Ausführung des Docker-Moduls unter Linux).

Option 2: Containerisierte MCP-Konfiguration

Bereitstellen von Anmeldeinformationen vom Host (empfohlen):

{
  "mcpServers": {
    "aks": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--user", "<your-user-id>",
        "-v", "~/.azure:/home/mcp/.azure",
        "-v", "~/.kube:/home/mcp/.kube",
        "ghcr.io/azure/aks-mcp:latest",
        "--transport", "stdio"
      ]
    }
  }
}

Wenn Sie stattdessen Anmeldeinformationen im Container abrufen möchten, lassen Sie die Volume mounts aus, und führen Sie die folgenden Befehle aus, nachdem sie den Container gestartet haben:

# Login to Azure CLI
docker exec -it <container-id> az login --use-device-code

# Get kubeconfig
docker exec -it <container-id> az aks get-credentials -g <resource-group> -n <cluster-name>

Konfigurieren Sie für andere MCP-kompatible KI-Clients wie Claude Desktop den Server in Ihrer MCP-Konfiguration:

{
  "mcpServers": {
    "aks": {
      "command": "<path-to-binary>",
      "args": [
        "--transport", "stdio"
      ]
    }
  }
}

Sie können den Server auch direkt über die Befehlszeile ausführen:

./aks-mcp --transport stdio

Befehlszeilenoptionen:

Umgebungsvariablen:

• USE_LEGACY_TOOLS: Legen Sie fest, dass true ältere spezialisierte Tools anstelle von einheitlichen Tools verwendet werden (Standard: false)
• Standardmäßige Azure-Authentifizierungsumgebungsvariablen werden unterstützt (AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_SUBSCRIPTION_ID)

Workload Identity bietet kennwortlose Authentifizierung, indem ein Kubernetes ServiceAccount mit einer azure Managed Identity verknüpft wird.

1. Aktivieren von OIDC auf Ihrem AKS-Cluster

az aks update \
  --resource-group <your-resource-group> \
  --name <your-aks-cluster> \
  --enable-oidc-issuer \
  --enable-workload-identity

2. Erstellen einer verwalteten Identität und Zuweisen von RBAC-Berechtigungen

# Create identity
az identity create --resource-group <your-resource-group> --name aks-mcp-identity --location <your-location>

# Get IDs
IDENTITY_CLIENT_ID=$(az identity show --resource-group <your-resource-group> --name aks-mcp-identity --query "clientId" -o tsv)
IDENTITY_PRINCIPAL_ID=$(az identity show --resource-group <your-resource-group> --name aks-mcp-identity --query "principalId" -o tsv)

# Assign Reader role (use Contributor for readwrite access)
az role assignment create --role "Reader" --assignee-object-id $IDENTITY_PRINCIPAL_ID --assignee-principal-type ServicePrincipal --scope "/subscriptions/<subscription-id>"

3. Erstellen von Anmeldeinformationen für eine Verbundidentität

AKS_OIDC_ISSUER=$(az aks show --resource-group <your-resource-group> --name <your-aks-cluster> --query "oidcIssuerProfile.issuerUrl" -o tsv)

az identity federated-credential create \
  --name "aks-mcp-federated-credential" \
  --identity-name aks-mcp-identity \
  --resource-group <your-resource-group> \
  --issuer $AKS_OIDC_ISSUER \
  --subject "system:serviceaccount:aks-mcp:aks-mcp" \
  --audience api://AzureADTokenExchange

4. Installation mit aktivierter Workload-Identität

helm install aks-mcp . \
  --namespace aks-mcp \
  --create-namespace \
  --set workloadIdentity.enabled=true \
  --set azure.clientId=$IDENTITY_CLIENT_ID \
  --set azure.subscriptionId=<your-subscription-id>

Aktivieren Sie die OAuth-Authentifizierung, um die Benutzeranmeldung für Lese-/Schreibzugriffs- oder Administratorvorgänge zu erfordern:

helm install aks-mcp . \
  --namespace aks-mcp \
  --create-namespace \
  --set app.accessLevel=readwrite \
  --set oauth.enabled=true \
  --set oauth.tenantId=<your-tenant-id> \
  --set oauth.clientId=<your-oauth-client-id> \
  --set azure.subscriptionId=<your-subscription-id>

Verwenden Sie ein Kubernetes Secret, das Anmeldeinformationen des Dienstprinzipals enthält:

# Create secret first
kubectl create secret generic azure-credentials \
  --namespace aks-mcp \
  --from-literal=tenant-id=<your-tenant-id> \
  --from-literal=client-id=<your-client-id> \
  --from-literal=client-secret=<your-client-secret> \
  --from-literal=subscription-id=<your-subscription-id>

# Install with existing secret
helm install aks-mcp . \
  --namespace aks-mcp \
  --set app.accessLevel=readonly \
  --set azure.existingSecret=azure-credentials

Übergeben Sie Anmeldeinformationen direkt über Helm Values (nicht für die Produktion empfohlen):

helm install aks-mcp . \
  --namespace aks-mcp \
  --create-namespace \
  --set azure.tenantId=<your-tenant-id> \
  --set azure.clientId=<your-client-id> \
  --set azure.clientSecret=<your-client-secret>

VS-Code mit AKS-Erweiterung

1. Öffnen Sie die Befehlspalette (Ctrl+Shift+P unter Windows/Linux oder Cmd+Shift+P unter macOS).
2. Führen Sie MCP aus: Listenserver.
3. Wählen Sie AKS MCP aus der Liste aus.
4. Wählen Sie "Server beenden" aus, um den ausgeführten Server zu beenden.
5. Um die Konfiguration zu entfernen, wählen Sie "Serverkonfiguration löschen" aus.

Alternativ können Sie die Serverkonfiguration manuell entfernen:

1. Öffnen Sie Ihre .vscode/mcp.json Datei oder vs Code-Benutzereinstellungen.
2. Löschen Sie den aks-mcp-server Eintrag aus dem Objekt servers oder github.copilot.chat.mcp.servers.
3. Löschen Sie die AKS-MCP Binärdatei aus Ihrem System (der Speicherort variiert je nach Installationsmethode).

Docker

Bei Verwendung des Docker MCP Toolkits:

1. Öffnen Sie Docker Desktop.
2. Wählen Sie das MCP-Toolkit in der linken Randleiste aus.
3. Suchen Sie den AKS-MCP-Server, und deaktivieren Sie ihn.

Wenn Sie eine containerisierte Konfiguration verwenden, beenden und entfernen Sie den Container.

docker stop <container-id>
docker rm <container-id>

Andere MCP-Clients

Entfernen Sie den Eintrag aks oder aks-mcp aus Ihrer MCP-Clientkonfigurationsdatei, z. B. bei Claude Desktop claude_desktop_config.json.

Entfernen des Helm-Loslassens

helm uninstall aks-mcp --namespace aks-mcp

Bereinigen des Namespaces (optional)

kubectl delete namespace aks-mcp

Bereinigen von Azure-Ressourcen (nur Workload-Identität)

Wenn Sie Workload Identity konfiguriert haben, entfernen Sie die zugeordneten Azure-Ressourcen:

# Delete the federated credential
az identity federated-credential delete \
  --name "aks-mcp-federated-credential" \
  --identity-name aks-mcp-identity \
  --resource-group <your-resource-group>

# Remove role assignments
IDENTITY_PRINCIPAL_ID=$(az identity show --resource-group <your-resource-group> --name aks-mcp-identity --query "principalId" -o tsv)
az role assignment delete --assignee $IDENTITY_PRINCIPAL_ID --scope "/subscriptions/<subscription-id>"

# Delete the managed identity
az identity delete --resource-group <your-resource-group> --name aks-mcp-identity

Löschen Sie das Kubernetes-Secret (nur Dienstprinzipal)

Wenn Sie ein Secret für Service Principal-Anmeldeinformationen erstellt haben:

kubectl delete secret azure-credentials --namespace aks-mcp