Tutoriel : Utiliser MCP avec des sessions dynamiques (Python)

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 avec le serveur MCP géré par la plateforme activé, se connecter à celui-ci et exécuter du code Python à distance.

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 Python :

Outil	Descriptif
launchShell	Crée un nouvel environnement et retourne un environmentId
runPythonCodeInRemoteEnvironment	Exécute du code Python dans un environnement existant
runShellCommandInRemoteEnvironment	Exécute une commande shell dans un environnement existant

Dans ce tutoriel, vous allez :

• Créer un pool de sessions Python avec le serveur MCP activé
• Récupérer le point de terminaison MCP et la clé API
• Initialisez la connexion MCP et exécutez du code Python 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

1. 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
   

2. Connectez-vous et définissez votre abonnement :

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

3. 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>
   

4. Créez un groupe de ressources :

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

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

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

1. 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": "PythonLTS",
                   "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: "PythonLTS": crée des sessions avec un runtime Python.
   • 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é.

2. 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 méthode d’authentification 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 Python

Créez un environnement Python :

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 du champ structuredContent dans la réponse. Vous avez besoin de cet ID pour toutes les commandes suivantes.

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

Note

L’outil launchShell génère un identificateur d’environnement unique. La session en cours est allouée de manière dite différée. Lorsque vous exécutez votre première commande, le pool de sessions affecte un conteneur isolé Hyper-V pour le gérer.

Exécuter des commandes Python

Pour exécuter du code Python dans l’environnement distant, utilisez l’étape $ENVIRONMENT_ID précédente.

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": "runPythonCodeInRemoteEnvironment",
            "arguments": {
                "environmentId": "'"$ENVIRONMENT_ID"'",
                "pythonCode": "import sys; print(f\"Python {sys.version}\")"
            }
        }
    }'

La réponse inclut des résultats de commande dans le champ stdout à l'intérieur de structuredContent.

Essayez un exemple plus complexe :

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": "runPythonCodeInRemoteEnvironment",
            "arguments": {
                "environmentId": "'"$ENVIRONMENT_ID"'",
                "pythonCode": "import math\nresults = {n: math.factorial(n) for n in range(1, 11)}\nfor k, v in results.items():\n    print(f\"{k}! = {v}\")"
            }
        }
    }'

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 du code.

1. Créez .vscode/mcp.json dans votre projet :

   {
       "servers": {
           "aca-python-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.

2. Ouvrez VS Code, puis ouvrez Copilot Chat en mode Agent .

3. Vérifiez que aca-python-sessions apparaît dans la liste des outils.

4. Testez avec des invites telles que :

   • « Lancer un environnement Python et calculer les 20 premiers nombres Fibonacci »
   • « Exécuter un script Python qui extrait https://api.GitHub.com et imprime les en-têtes de réponse »

Nettoyer les ressources

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

az group delete --resource-group $RESOURCE_GROUP

Contenu connexe

• Vue d’ensemble des serveurs MCP sur Azure Container Apps
• Utiliser MCP avec des sessions dynamiques (shell)
• Sessions dynamiques dans Azure Container Apps
• Sécuriser les serveurs MCP sur Container Apps
• Résoudre les problèmes de serveurs MCP sur Container Apps