Intégrer une application App Service en tant que serveur MCP pour GitHub Copilot Chat (.NET)

Dans ce tutoriel, vous allez apprendre à exposer les fonctionnalités d’une application ASP.NET Core par le biais du protocole MCP (Model Context Protocol), l’ajouter en tant qu’outil à GitHub Copilot et interagir avec votre application à l’aide du langage naturel en mode Agent Copilot Chat.

Capture d’écran montrant GitHub Copilot appelant le serveur Todos MCP hébergé dans Azure App Service.

Si votre application web dispose déjà de fonctionnalités utiles, telles que le shopping, la réservation d’hôtels ou la gestion des données, il est facile de rendre ces fonctionnalités disponibles :

Toute application prenant en charge l’intégration MCP, telle que le mode d’agent GitHub Copilot Chat dans Visual Studio Code ou gitHub Codespaces.
Agent personnalisé qui accède aux outils distants à l’aide d’un client MCP.

En ajoutant un serveur MCP à votre application web, vous pouvez permettre à un agent de comprendre et d’utiliser les fonctionnalités de votre application lorsqu’elle répond aux invites de l’utilisateur. Cela signifie que tout ce que votre application peut faire, l’agent peut également le faire.

Ajoutez un serveur MCP à votre application web.
Testez le serveur MCP localement en mode agent GitHub Copilot Chat.
Déployez le serveur MCP sur Azure App Service et connectez-vous à celui-ci dans GitHub Copilot Chat.

Conditions préalables

Ce didacticiel part du principe que vous utilisez l’exemple utilisé dans le didacticiel : Déployer une application ASP.NET Core et Azure SQL Database sur Azure App Service.

Au minimum, ouvrez l’exemple d’application dans GitHub Codespaces et déployez l’application en exécutant azd up.

Ajouter un serveur MCP à votre application web

Dans le terminal Codespace, ajoutez le package NuGet ModelContextProtocol.AspNetCore à votre projet :
```
dotnet add package ModelContextProtocol.AspNetCore --prerelease
```

Créez un dossier McpServer et créez un TodosMcpTool.cs dans celui-ci avec le code suivant.

using DotNetCoreSqlDb.Data;
using DotNetCoreSqlDb.Models;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel;
using ModelContextProtocol.Server;

namespace DotNetCoreSqlDb.McpServer
{
    [McpServerToolType]
    public class TodosMcpTool
    {
        private readonly MyDatabaseContext _db;

        public TodosMcpTool(MyDatabaseContext db)
        {
            _db = db;
        }

        [McpServerTool, Description("Creates a new todo with a description and creation date.")]
        public async Task<string> CreateTodoAsync(
            [Description("Description of the todo")] string description,
            [Description("Creation date of the todo")] DateTime createdDate)
        {
            var todo = new Todo
            {
                Description = description,
                CreatedDate = createdDate
            };
            _db.Todo.Add(todo);
            await _db.SaveChangesAsync();
            return $"Todo created: {todo.Description} (Id: {todo.ID})";
        }

        [McpServerTool, Description("Reads all todos, or a single todo if an id is provided.")]
        public async Task<List<Todo>> ReadTodosAsync(
            [Description("Id of the todo to read (optional)")] string? id = null)
        {
            if (!string.IsNullOrWhiteSpace(id) && int.TryParse(id, out int todoId))
            {
                var todo = await _db.Todo.FindAsync(todoId);
                if (todo == null) return new List<Todo>();
                return new List<Todo> { todo };
            }
            var todos = await _db.Todo.OrderBy(t => t.ID).ToListAsync();
            return todos;
        }

        [McpServerTool, Description("Updates the specified todo fields by id.")]
        public async Task<string> UpdateTodoAsync(
            [Description("Id of the todo to update")] string id,
            [Description("New description (optional)")] string? description = null,
            [Description("New creation date (optional)")] DateTime? createdDate = null)
        {
            if (!int.TryParse(id, out int todoId))
                return "Invalid todo id.";
            var todo = await _db.Todo.FindAsync(todoId);
            if (todo == null) return $"Todo with Id {todoId} not found.";
            if (!string.IsNullOrWhiteSpace(description)) todo.Description = description;
            if (createdDate.HasValue) todo.CreatedDate = createdDate.Value;
            await _db.SaveChangesAsync();
            return $"Todo {todo.ID} updated.";
        }

        [McpServerTool, Description("Deletes a todo by id.")]
        public async Task<string> DeleteTodoAsync(
            [Description("Id of the todo to delete")] string id)
        {
            if (!int.TryParse(id, out int todoId))
                return "Invalid todo id.";
            var todo = await _db.Todo.FindAsync(todoId);
            if (todo == null) return $"Todo with Id {todoId} not found.";
            _db.Todo.Remove(todo);
            await _db.SaveChangesAsync();
            return $"Todo {todo.ID} deleted.";
        }
    }
}

Le code ci-dessus rend les outils disponibles pour le serveur MCP à l’aide des attributs spécifiques suivants :

[McpServerToolType]: marque la TodosMcpTool classe comme type d’outil serveur MCP. Il signale au framework MCP que cette classe contient les méthodes qui doivent être exposées comme outils appelables.
[McpServerTool]: marque une méthode comme une action appelante pour le serveur MCP.
[Description]: elles fournissent des descriptions lisibles par l’homme pour les méthodes et les paramètres. Il aide l’agent appelant à comprendre comment utiliser les actions et leurs paramètres.

Ce code consiste à dupliquer les fonctionnalités de l’existant TodosController, ce qui n’est pas nécessaire, mais vous le conserverez par souci de simplicité. Une bonne pratique consisterait à déplacer la logique d'application vers une classe de service, puis à appeler les méthodes de service à partir de TodosController et de TodosMcpTool.

Dans Program.cs, inscrivez le service de serveur MCP et le service CORS.

builder.Services.AddMcpServer()
    .WithHttpTransport() // With streamable HTTP
    .WithToolsFromAssembly(); // Add all classes marked with [McpServerToolType]

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.AllowAnyOrigin()
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

Lorsque vous utilisez le protocole HTTP streamable avec le serveur MCP, vous devez activer le partage de ressources cross-origin (CORS) si vous souhaitez le tester avec des outils de navigateur client ou GitHub Copilot (à la fois dans Visual Studio Code et dans GitHub Codespaces).

Dans Program.cs, activez le middleware MCP et CORS.
```
app.MapMcp("/api/mcp");
app.UseCors();
```
Ce code définit votre point de terminaison de serveur MCP sur <url>/api/mcp.

Tester le serveur MCP localement

Dans le terminal codespace, exécutez l’application avec dotnet run.
Sélectionnez Ouvrir dans le navigateur, puis ajoutez une tâche.

Laissez dotnet run fonctionner. Votre serveur MCP est en cours d’exécution à http://localhost:5093/api/mcp maintenant.
De retour dans l’espace de code, ouvrez Copilot Chat, puis sélectionnez le mode Agent dans la zone d’invite.
Sélectionnez le bouton Outils , puis sélectionnez Ajouter d’autres outils... dans la liste déroulante.
Sélectionnez Ajouter un serveur MCP.
Sélectionnez HTTP (HTTP ou événements envoyés par le serveur).
Dans Entrée de l’URL du serveur, tapez http://localhost:5093/api/mcp.
Dans Entrer l’ID du serveur, tapez todos-mcp ou n’importe quel nom de votre choix.
Sélectionnez Paramètres de l’espace de travail.
Dans une nouvelle fenêtre de discussion du Copilot, tapez quelque chose comme « Montre-moi les tâches à faire ».
Par défaut, GitHub Copilot affiche une confirmation de sécurité lorsque vous appelez un serveur MCP. Sélectionnez Continuer.

Vous devez maintenant voir une réponse qui indique que l’appel de l’outil MCP réussit.

Déployer votre serveur MCP sur App Service

De retour dans le terminal Codespace, déployez vos modifications en commitant vos modifications (méthode GitHub Actions) ou en exécutant azd up (méthode CLI du développeur Azure).
Dans la sortie AZD, recherchez l’URL de votre application. L’URL ressemble à ceci dans la sortie AZD :
```
 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: <app-url>
 
```
Une fois azd up terminé, ouvrez .vscode/mcp.json. Définissez l’URL sur <app-url>/api/mcp.
Au-dessus de la configuration du serveur MCP modifiée, sélectionnez Démarrer.
Démarrez une nouvelle fenêtre gitHub Copilot Chat. Vous devez être en mesure d’afficher, de créer, de mettre à jour et de supprimer des tâches dans l’agent Copilot.

Bonnes pratiques de sécurité

Lorsque votre serveur MCP est sollicité par un agent utilisant de grands modèles de langage (LLM), soyez conscient des attaques par injection de commande. Tenez compte des meilleures pratiques de sécurité suivantes :

Authentification et autorisation : Sécurisez votre serveur MCP avec l’authentification Microsoft Entra pour vous assurer que seuls les utilisateurs ou agents autorisés peuvent accéder à vos outils. Consultez Protocole de Contexte de Modèle Sécurisé pour les appels vers Azure App Service depuis Visual Studio Code avec l'authentification Microsoft Entra pour un guide étape par étape.
Validation et assainissement d’entrée : l’exemple de code de ce tutoriel omet la validation et l’assainissement des entrées pour simplifier et clarifier. Dans les scénarios de production, implémentez toujours une validation et une assainissement appropriés pour protéger votre application. Pour ASP.NET Core, consultez validation de modèle dans ASP.NET Core.
HTTPS : L’exemple s’appuie sur Azure App Service, qui applique HTTPS par défaut et fournit des certificats TLS/SSL gratuits pour chiffrer les données en transit.
Principe des privilèges minimum : exposez uniquement les outils et données nécessaires pour votre cas d’usage. Évitez d’exposer des opérations sensibles, sauf si nécessaire.
Limitation et limitation du débit : utilisez gestion des API ou intergiciel personnalisé pour éviter les attaques par déni de service et d’abus.
Journalisation et surveillance : journalisation de l’accès et de l’utilisation des points de terminaison MCP pour l’audit et la détection des anomalies. Surveillez les activités suspectes.
Configuration CORS : limitez les demandes d’origine croisée aux domaines approuvés si votre serveur MCP est accessible à partir de navigateurs. Pour plus d’informations, consultez Activer CORS.
Mises à jour régulières : conservez vos dépendances à jour pour atténuer les vulnérabilités connues.

Plus de ressources

Intégrer l’IA à vos applications Azure App Service

Commentaires

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

Last updated on 2025-11-10