Tutoriel : Utiliser MCP avec des sessions dynamiques (shell)

Important

Le serveur MCP géré par la plateforme pour les sessions dynamiques est en préversion. La version 2025-02-02-preview et les propriétés mcpServerSettings de l’API sont sujettes à modification.

Ce tutoriel montre comment créer un pool de sessions d’interpréteur de commandes avec le serveur MCP géré par la plateforme activé, s’y connecter et exécuter des commandes shell à distance à partir de l’interface CLI et de GitHub Copilot Chat dans VS Code.

Contrairement aux didacticiels de serveur MCP autonomes, vous n’écrivez pas ou ne déployez pas de code de serveur MCP. La plateforme fournit des outils intégrés pour les pools de sessions shell :

Outil	Descriptif
`launchShell`	Crée un environnement shell et retourne un `environmentId`
`runShellCommandInRemoteEnvironment`	Exécute une commande shell dans un environnement existant

Dans ce tutoriel, vous allez :

Créer un pool de sessions shell avec le serveur MCP activé
Récupérer le point de terminaison MCP et la clé API
Initialisez la connexion MCP et exécutez des commandes shell via JSON-RPC
Connecter le serveur MCP à GitHub Copilot dans VS Code

Prerequisites

Requirement	Descriptif
Compte Azure	Un compte Azure avec un abonnement actif. Créez-en un gratuitement.
Azure CLI	Installez Azure CLI.
curl	curl (préinstallé sur la plupart des systèmes Linux et macOS).
jq	jq Processeur JSON, utilisé pour analyser les réponses d’API.
VS Code	Visual Studio Code avec l’extension GitHub Copilot (pour la section intégration de Copilot).

Configuration

Mettez à jour Azure CLI et installez l’extension Container Apps :

az upgrade
az provider register --namespace Microsoft.App
az extension add --name containerapp --allow-preview true --upgrade

Connectez-vous et définissez votre abonnement :

az login
SUBSCRIPTION_ID=$(az account show --query id --output tsv)
az account set -s $SUBSCRIPTION_ID

Définissez des variables pour ce didacticiel. Remplacez les espaces réservés par vos valeurs :

RESOURCE_GROUP=<RESOURCE_GROUP_NAME>
SESSION_POOL_NAME=<SESSION_POOL_NAME>
LOCATION=<LOCATION>

Espace réservé	Descriptif
`<RESOURCE_GROUP_NAME>`	Nom du groupe de ressources Azure.
`<SESSION_POOL_NAME>`	Nom de votre pool de sessions (par exemple). `my-shell-sessions`
`<LOCATION>`	Région Azure qui prend en charge les sessions dynamiques (par exemple, `westus2`).

Créez un groupe de ressources :

az group create --name $RESOURCE_GROUP --location $LOCATION

Créer un pool de sessions shell avec le serveur MCP

Déployez un pool de sessions à l’aide d’un modèle ARM avec le serveur MCP activé.

Créez un fichier nommé deploy.json:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "name": { "type": "String" },
        "location": { "type": "String" }
    },
    "resources": [
        {
            "type": "Microsoft.App/sessionPools",
            "apiVersion": "2025-02-02-preview",
            "name": "[parameters('name')]",
            "location": "[parameters('location')]",
            "properties": {
                "poolManagementType": "Dynamic",
                "containerType": "Shell",
                "scaleConfiguration": {
                    "maxConcurrentSessions": 5
                },
                "sessionNetworkConfiguration": {
                    "status": "EgressEnabled"
                },
                "dynamicPoolConfiguration": {
                    "lifecycleConfiguration": {
                        "lifecycleType": "Timed",
                        "coolDownPeriodInSeconds": 300
                    }
                },
                "mcpServerSettings": {
                    "isMCPServerEnabled": true
                }
            }
        }
    ]
}

Note

Propriétés clés dans ce modèle :

containerType: "Shell" — crée des sessions avec un environnement d’interpréteur de commandes Linux.
mcpServerSettings.isMCPServerEnabled: true — active le point de terminaison MCP géré par la plateforme.
coolDownPeriodInSeconds: 300 — les sessions sont détruites après 5 minutes d’inactivité.

Déployez le modèle :

az deployment group create \
    --resource-group $RESOURCE_GROUP \
    --template-file deploy.json \
    --parameters name=$SESSION_POOL_NAME location=$LOCATION

Obtenir le point de terminaison du serveur MCP

Après le déploiement, récupérez l’URL du point de terminaison MCP de votre pool de sessions.

MCP_ENDPOINT=$(az rest --method GET \
    --uri "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.App/sessionPools/$SESSION_POOL_NAME" \
    --uri-parameters api-version=2025-02-02-preview \
    --query "properties.mcpServerSettings.mcpServerEndpoint" -o tsv)

Obtenir les informations d’identification du serveur MCP

Le serveur MCP géré par la plateforme utilise l’authentification par clé API via l’en-tête x-ms-apikey . Cette approche diffère de l’authentification par jeton du porteur que les API de gestion de pool de sessions standard utilisent.

API_KEY=$(az rest --method POST \
    --uri "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.App/sessionPools/$SESSION_POOL_NAME/fetchMCPServerCredentials" \
    --uri-parameters api-version=2025-02-02-preview \
    --query "apiKey" -o tsv)

Avertissement

Traitez la clé API comme un secret. Ne l’enregistrez pas dans le contrôle de version et ne le partagez pas publiquement. La clé authentifie tous les appels d’outils MCP sur votre pool de sessions.

Initialiser le serveur MCP

Envoyez la initialize requête JSON-RPC pour établir la connexion MCP :

curl -sS -X POST "$MCP_ENDPOINT" \
    -H "Content-Type: application/json" \
    -H "x-ms-apikey: $API_KEY" \
    -d '{ "jsonrpc": "2.0", "id": "1", "method": "initialize" }'

Vous devez voir une réponse qui inclut :

protocolVersion: 2025-03-26
serverInfo.name: Microsoft Container Apps MCP Server
capabilities.tools: { "call": true, "list": true }

Lancer un environnement shell

Créez un environnement shell pour exécuter des commandes.

ENVIRONMENT_RESPONSE=$(curl -sS -X POST "$MCP_ENDPOINT" \
    -H "Content-Type: application/json" \
    -H "x-ms-apikey: $API_KEY" \
    -d '{ "jsonrpc": "2.0", "id": "2", "method": "tools/call", "params": { "name": "launchShell", "arguments": {} } }')

echo $ENVIRONMENT_RESPONSE

Extrayez le environmentId de la réponse pour l'utiliser dans les commandes ultérieures.

ENVIRONMENT_ID=$(echo $ENVIRONMENT_RESPONSE | jq -r '.result.structuredContent.environmentId')
echo $ENVIRONMENT_ID

Exécuter des commandes shell

Utilisez l’étape $ENVIRONMENT_ID précédente pour exécuter des commandes dans l’environnement shell distant.

curl -sS -X POST "$MCP_ENDPOINT" \
    -H "Content-Type: application/json" \
    -H "x-ms-apikey: $API_KEY" \
    -d '{
        "jsonrpc": "2.0",
        "id": "3",
        "method": "tools/call",
        "params": {
            "name": "runShellCommandInRemoteEnvironment",
            "arguments": {
                "environmentId": "'"$ENVIRONMENT_ID"'",
                "shellCommand": "echo Hello from Azure Container Apps Shell Session!"
            }
        }
    }'

La réponse inclut les résultats de commande dans le stdout champ.

Essayez des commandes supplémentaires :

# Check the operating system
curl -sS -X POST "$MCP_ENDPOINT" \
    -H "Content-Type: application/json" \
    -H "x-ms-apikey: $API_KEY" \
    -d '{
        "jsonrpc": "2.0",
        "id": "4",
        "method": "tools/call",
        "params": {
            "name": "runShellCommandInRemoteEnvironment",
            "arguments": {
                "environmentId": "'"$ENVIRONMENT_ID"'",
                "shellCommand": "cat /etc/os-release && uname -a"
            }
        }
    }'

Note

L’outil runShellCommandInRemoteEnvironment accepte une shellCommand chaîne ou un execCommandAndArgs tableau pour les commandes avec des arguments. Utilisez shellCommand pour les commandes simples et execCommandAndArgs lorsque vous avez besoin d’un contrôle précis sur l’échappement des arguments.

Se connecter à GitHub Copilot dans VS Code

Vous pouvez connecter le serveur MCP du pool de sessions à GitHub Copilot pour une interface en langage naturel à l’environnement d’exécution de l’interpréteur de commandes.

Créez .vscode/mcp.json dans votre projet :
```
{
    "servers": {
        "aca-shell-sessions": {
            "type": "http",
            "url": "<MCP_ENDPOINT>",
            "headers": {
                "x-ms-apikey": "<API_KEY>"
            }
        }
    }
}
```
Remplacez <MCP_ENDPOINT> et <API_KEY> par les valeurs des étapes précédentes.

Avertissement

Ne stockez pas les clés API MCP dans la gestion du code source. Utilisez des variables d’environnement ou un gestionnaire de secrets en production. Ajouter .vscode/mcp.json à votre .gitignore.
Ouvrez VS Code, puis ouvrez Copilot Chat en mode Agent .
Vérifiez que aca-shell-sessions apparaît dans la liste des outils.
Testez avec des invites telles que :
- « Lancer un interpréteur de commandes et me montrer l’utilisation du disque »
- « Exécuter une commande shell pour répertorier toutes les variables d’environnement »
- « Vérifier les packages installés dans l’environnement shell »

Nettoyer les ressources

Une fois ce didacticiel terminé, supprimez les ressources que vous avez créées pour éviter les frais.

az group delete --resource-group $RESOURCE_GROUP

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-27