Ansluta ditt AKS-kluster (Azure Kubernetes Service) till AI-agenter med hjälp av MCP-servern (Model Context Protocol)

Det enklaste sättet att komma igång med AKS-MCP är via Azure Kubernetes Service Extension för VS Code. AKS-tillägget hanterar binära nedladdningar, uppdateringar och konfiguration automatiskt, vilket säkerställer att du alltid har den senaste versionen med optimala inställningar.

Steg 1: Installera AKS-tillägget

1. Öppna VS Code och gå till Tillägg (Ctrl+Shift+X i Windows/Linux eller Cmd+Shift+X på macOS).
2. Sök efter Azure Kubernetes Service.
3. Installera det officiella Microsoft AKS-tillägget.

Steg 2: Starta AKS-MCP-servern

1. Öppna kommandopaletten (Ctrl+Shift+P i Windows/Linux eller Cmd+Shift+P på macOS).
2. Sök och kör: AKS: Konfigurera AKS MCP Server.

När installationen har slutförts visas servern i MCP: Listservrar (via kommandopaletten). Därifrån kan du starta MCP-servern eller visa dess status.

Steg 3: Börja använda AKS-MCP

När den har startats visas MCP-servern i listrutan Copilot Chat: Configure Tools (Konfigurera verktyg ) under MCP Server: AKS MCP, redo att förbättra kontextuella frågor baserat på din AKS-miljö. Som standard är alla AKS-MCP serververktyg aktiverade. Du kan granska listan över tillgängliga verktyg och inaktivera alla som inte krävs för ditt scenario.

Prova en fråga som "Lista alla mina AKS-kluster" för att börja använda verktyg från AKS-MCP-servern.

För direkt binär användning utan VS Code-tillägget:

Steg 1: Ladda ned binärfilen

Välj din plattform och ladda ned den senaste AKS-MCP binärfilen:

Steg 2: Konfigurera VS Code

Skapa en .vscode/mcp.json fil i arbetsytans rot med sökvägen till den nedladdade binära filen:

Arbetsytespecifik konfiguration (rekommenderas för projektspecifik användning):

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

Konfiguration på användarnivå (beständiga för alla arbetsytor):

Lägg till i användarinställningarna för VS Code JSON (Ctrl+, eller Cmd+,och sök sedan efter "mcp"):

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

Steg 3: Ladda AKS-MCP serververktyg

1. Starta om VS Code för att läsa in den nya MCP-serverkonfigurationen.
2. Öppna GitHub Copilot i VS Code och växla till agentläge.
3. Välj knappen Verktyg för att se listan över tillgängliga verktyg.
4. Kontrollera att AKS-MCP verktygen visas i listan.
5. Prova en fråga som: "Visa en lista över alla mina AKS-kluster i prenumerationen xxx."

Du kan köra AKS-MCP-servern med den officiella Docker-avbildningen från Docker MCP Toolkit eller som en containerbaserad MCP-konfiguration.

Alternativ 1: Docker MCP Toolkit

1. Öppna Docker Desktop.
2. Välj MCP Toolkit i det vänstra sidofältet.
3. Sök efter "aks" på fliken Katalog.
4. Välj AKS-MCP serverkortet.
5. Aktivera servern genom att + välja i det övre högra hörnet.
6. Konfigurera servern med fliken Konfiguration :
   • [REQUIRED]azure_dir: Absolut sökväg till katalogen med Azure-autentiseringsuppgifter (till exempel /home/user/.azure)
   • kubeconfig[REQUIRED]: Absolut sökväg till kubeconfig-filen (till exempel /home/user/.kube/config)
   • access_level[REQUIRED]: Ange som readonly, readwrite, eller admin efter behov
   • [OPTIONAL]container_user: Användarnamn eller UID för att köra containern som (standard är mcp). Använd ditt värdanvändar-ID (till exempel 1000) om du kör Docker Engine på Linux.

Alternativ 2: Containerbaserad MCP-konfiguration

Montera autentiseringsuppgifter från värden (rekommenderas):

{
  "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"
      ]
    }
  }
}

Om du vill hämta autentiseringsuppgifter i containern istället, utelämna volymkopplingarna och kör följande kommandon efter att du startat containern:

# 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>

För andra MCP-kompatibla AI-klienter som Claude Desktop konfigurerar du servern i MCP-konfigurationen:

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

Du kan också köra servern direkt från kommandoraden:

./aks-mcp --transport stdio

Kommandoradsalternativ:

Miljövariabler:

• USE_LEGACY_TOOLS: Ställ in på för att true använda äldre specialiserade verktyg i stället för enhetliga verktyg (standard: false)
• Standardvariabler för Azure-autentiseringsmiljön stöds (AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_SUBSCRIPTION_ID)

Arbetsbelastningsidentitet ger lösenordslös autentisering genom att länka en Kubernetes ServiceAccount till en Hanterad Azure-identitet.

1. Aktivera OIDC i ditt AKS-kluster

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

2. Skapa en hanterad identitet och tilldela RBAC-behörigheter

# 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. Skapa en federerad identitetsautentiseringsuppgift

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. Installera med arbetsbelastningsidentitet aktiverad

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>

Aktivera OAuth-autentisering för att kräva användarinloggning för läs- eller administratörsåtgärder:

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>

Använd en Kubernetes-hemlighet som innehåller autentiseringsuppgifter för tjänstens huvudnamn:

# 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

Skicka autentiseringsuppgifter direkt via Helm-värden (rekommenderas inte för produktion):

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 med AKS-tillägg

1. Öppna kommandopaletten (Ctrl+Shift+P i Windows/Linux eller Cmd+Shift+P på macOS).
2. Kör MCP: Listservrar.
3. Välj AKS MCP i listan.
4. Välj Stoppa server för att stoppa servern som körs.
5. Om du vill ta bort konfigurationen väljer du Ta bort serverkonfiguration.

Du kan också ta bort serverkonfigurationen manuellt:

1. Öppna din .vscode/mcp.json-fil eller VS Code-användarinställningar.
2. Ta bort aks-mcp-server-posten från servers-objektet eller github.copilot.chat.mcp.servers.
3. Ta bort AKS-MCP binärfilen från systemet (platsen varierar beroende på installationsmetoden).

Docker

Om du använder Docker MCP Toolkit:

1. Öppna Docker Desktop.
2. Välj MCP Toolkit i det vänstra sidofältet.
3. Leta upp AKS-MCP-servern och inaktivera den.

Om du använder en containeriserad konfiguration ska du stoppa och ta bort containern:

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

Andra MCP-klienter

Ta bort aks- eller aks-mcp-posten från din MCP-klientkonfigurationsfil (till exempel Claude Desktops claude_desktop_config.json).

Ta bort Helm-utgåvan

helm uninstall aks-mcp --namespace aks-mcp

Rensa namnområdet (valfritt)

kubectl delete namespace aks-mcp

Rensa Azure-resurser (endast arbetsbelastningsidentitet)

Om du har konfigurerat arbetsbelastningsidentitet tar du bort de associerade Azure-resurserna:

# 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

Ta bort Kubernetes-hemligheten (endast tjänstens huvudnamn)

Om du har skapat en hemlighet för Service Principal-uppgifter:

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