Connecter votre cluster Azure Kubernetes Service (AKS) à des agents IA à l’aide du serveur MCP (Model Context Protocol)

Le moyen le plus simple de commencer à utiliser AKS-MCP consiste à utiliser l’extension Azure Kubernetes Service pour VS Code. L’extension AKS gère automatiquement les téléchargements binaires, les mises à jour et la configuration, ce qui garantit que vous disposez toujours de la dernière version avec des paramètres optimaux.

Étape 1 : installer l’extension AKS

1. Ouvrez VS Code et accédez aux extensions (Ctrl+Shift+X sur Windows/Linux ou Cmd+Shift+X sur macOS).
2. Recherchez Azure Kubernetes Service.
3. Installez l’extension Microsoft AKS officielle.

Étape 2 : Lancer le serveur AKS-MCP

1. Ouvrez la palette de commandes (Ctrl+Shift+P sur Windows/Linux ou Cmd+Shift+P sur macOS).
2. Recherchez et exécutez : AKS : Configurer le serveur AKS MCP.

Une fois l’installation réussie, le serveur apparaît dans MCP : Répertorier les serveurs (via la palette de commandes). À partir de là, vous pouvez démarrer le serveur MCP ou afficher son état.

Étape 3 : Commencer à utiliser AKS-MCP

Une fois démarré, le serveur MCP apparaît dans la liste déroulante Copilot Chat : Configurer les outils sous MCP Server: AKS MCP, prêt à améliorer les invites contextuelles en fonction de votre environnement AKS. Par défaut, tous les outils serveur AKS-MCP sont activés. Vous pouvez consulter la liste des outils disponibles et désactiver ceux qui ne sont pas requis pour votre scénario.

Essayez une invite telle que « Répertorier tous mes clusters AKS » pour commencer à utiliser des outils à partir du serveur AKS-MCP.

Pour une utilisation binaire directe sans l’extension VS Code :

Étape 1 : Télécharger le fichier binaire

Choisissez votre plateforme et téléchargez la dernière AKS-MCP binaire :

Étape 2 : Configurer VS Code

Créez un .vscode/mcp.json fichier à la racine de votre espace de travail avec le chemin d’accès à votre fichier binaire téléchargé :

Configuration spécifique à l’espace de travail (recommandée pour une utilisation spécifique au projet) :

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

Configuration au niveau de l’utilisateur (persistante sur tous les espaces de travail) :

Ajoutez à votre fichier JSON des paramètres utilisateur VS Code (Ctrl+, ou Cmd+,, recherchez « mcp ») :

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

Étape 3 : Charger les outils serveur AKS-MCP

1. Redémarrez VS Code pour charger la nouvelle configuration du serveur MCP.
2. Ouvrez GitHub Copilot dans VS Code et basculez en mode Agent.
3. Sélectionnez le bouton Outils pour afficher la liste des outils disponibles.
4. Vérifiez que les outils AKS-MCP apparaissent dans la liste.
5. Essayez une requête telle que : « Répertorier tous mes clusters AKS dans l’abonnement xxx ».

Vous pouvez exécuter le serveur AKS-MCP à l’aide de l’image Docker officielle de Docker MCP Toolkit ou en tant que configuration MCP conteneurisée.

Option 1 : Docker MCP Toolkit

1. Ouvrez Docker Desktop.
2. Sélectionnez MCP Toolkit dans la barre latérale gauche.
3. Recherchez « aks » dans l'onglet Catalogue.
4. Sélectionnez la carte de serveur AKS-MCP.
5. Activez le serveur en sélectionnant + dans le coin supérieur droit.
6. Configurez le serveur à l’aide de l’onglet Configuration :
   • [REQUIRED]azure_dir : chemin absolu vers votre répertoire d’informations d’identification Azure (par exemple, /home/user/.azure)
   • kubeconfig[REQUIRED] : chemin absolu de votre fichier kubeconfig (par exemple, /home/user/.kube/config)
   • [REQUIRED]niveau_d'accès : défini sur readonly, readwrite ou admin si nécessaire
   • [OPTIONAL]container_user : nom d’utilisateur ou UID pour exécuter le conteneur comme (valeur mcppar défaut ). Utilisez votre ID d’utilisateur hôte (par exemple) 1000si vous exécutez le moteur Docker sur Linux.

Option 2 : Configuration MCP conteneurisée

Monter les identifiants depuis l’hôte (recommandé) :

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

Pour récupérer les informations d’identification à l’intérieur du conteneur, omettez les montages de volume et exécutez les commandes suivantes après avoir démarré le conteneur :

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

Pour d’autres clients d’IA compatibles AVEC MCP comme Claude Desktop, configurez le serveur dans votre configuration MCP :

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

Vous pouvez également exécuter le serveur directement à partir de la ligne de commande :

./aks-mcp --transport stdio

Options de ligne de commande :

Variables d’environnement :

• USE_LEGACY_TOOLS: Définir pour true utiliser des outils spécialisés hérités au lieu d’outils unifiés (par défaut : false)
• Les variables d’environnement d’authentification Azure standard sont prises en charge (AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_SUBSCRIPTION_ID)

L’identité de charge de travail fournit une authentification sans mot de passe en liant kubernetes ServiceAccount à une identité managée Azure.

1. Activer OIDC sur votre cluster AKS

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

2. Créer une identité managée et attribuer des autorisations RBAC

# 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. Créer des identifiants d’identité fédérée

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. Installer avec l’identité de charge de travail activée

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>

Activez l’authentification OAuth pour exiger la connexion utilisateur pour les opérations en lecture-écriture ou d’administration :

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>

Utilisez un secret Kubernetes contenant les informations d’identification du principal de service :

# 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

Transmettez les informations d’identification directement via les valeurs Helm (non recommandé pour la production) :

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 avec l’extension AKS

1. Ouvrez la palette de commandes (Ctrl+Shift+P sur Windows/Linux ou Cmd+Shift+P sur macOS).
2. Exécutez MCP : Répertorier les serveurs.
3. Sélectionnez AKS MCP dans la liste.
4. Sélectionnez Arrêter le serveur pour arrêter le serveur en cours d’exécution.
5. Pour supprimer la configuration, sélectionnez Supprimer la configuration du serveur.

Vous pouvez également supprimer manuellement la configuration du serveur :

1. Ouvrez votre .vscode/mcp.json fichier ou vos paramètres utilisateur VS Code.
2. Supprimez l'entrée aks-mcp-server de l'objet servers ou github.copilot.chat.mcp.servers.
3. Supprimez le AKS-MCP binaire de votre système (l’emplacement varie en fonction de la méthode d’installation).

Docker

Si vous utilisez Docker MCP Toolkit :

1. Ouvrez Docker Desktop.
2. Sélectionnez MCP Toolkit dans la barre latérale gauche.
3. Recherchez le serveur AKS-MCP et désactivez-le.

Si vous utilisez une configuration conteneurisée, arrêtez et supprimez le conteneur :

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

Autres clients MCP

Supprimez l'entrée aks ou aks-mcp de votre fichier de configuration du client MCP (par exemple, claude_desktop_config.json de Claude Desktop).

Supprimer la version Helm

helm uninstall aks-mcp --namespace aks-mcp

Nettoyer l’espace de noms (facultatif)

kubectl delete namespace aks-mcp

Nettoyer les ressources Azure (Identité de charge de travail uniquement)

Si vous avez configuré l’identité de charge de travail, supprimez les ressources Azure associées :

# 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

Supprimer le secret Kubernetes (principal de service uniquement)

Si vous avez créé un secret pour les informations d’identification du principal de service :

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