App Service-alkalmazás integrálása MCP-kiszolgálóként a GitHub Copilot Chathez (.NET)

Ebben az oktatóanyagban megtanulhatja, hogyan teheti elérhetővé egy ASP.NET Core-alkalmazás funkcióit a Model Context Protocol (MCP) használatával, hogyan adhat hozzá eszközt a GitHub Copilothoz, és hogyan használhatja az alkalmazást természetes nyelven a Copilot Csevegőügynök módban.

Képernyőkép az Azure App Service-ben üzemeltetett Todos MCP-kiszolgálót hívó GitHub Copilotról.

Ha a webalkalmazás már rendelkezik olyan hasznos funkciókkal, mint a vásárlás, a szállodai foglalás vagy az adatkezelés, könnyen elérhetővé teheti ezeket a képességeket a következő célokra:

Minden olyan alkalmazás, amely támogatja az MCP-integrációt, például a GitHub Copilot Csevegőügynök mód a Visual Studio Code-ban vagy a GitHub Codespacesben.
Egy egyéni ügynök, amely egy MCP-ügyféllel fér hozzá a távoli eszközökhöz.

Ha mcp-kiszolgálót ad hozzá a webalkalmazáshoz, lehetővé teszi az ügynök számára az alkalmazás képességeinek megértését és használatát, amikor az válaszol a felhasználói kérésekre. Ez azt jelenti, hogy amit az alkalmazás meg tud tenni, azt az ügynök is meg tudja tenni.

Adjon hozzá egy MCP-kiszolgálót a webalkalmazáshoz.
Tesztelje az MCP-kiszolgálót helyileg a GitHub Copilot Csevegőügynök módban.
Telepítse az MCP-kiszolgálót az Azure App Service-ben, és csatlakozzon hozzá a GitHub Copilot Chatben.

Előfeltételek

Ez az oktatóanyag feltételezi, hogy a következő oktatóanyagban használt mintával dolgozik : ASP.NET Core- és Azure SQL Database-alkalmazás üzembe helyezése az Azure App Service-ben.

Legalább nyissa meg a mintaalkalmazást a GitHub Codespacesben, és futtassa azd upaz alkalmazást.

MCP-kiszolgáló hozzáadása a webalkalmazáshoz

A kódtér termináljában adja hozzá a NuGet-csomagot ModelContextProtocol.AspNetCore a projekthez:
```
dotnet add package ModelContextProtocol.AspNetCore --prerelease
```

Hozzon létre egy McpServer mappát, és hozzon létre benne egy TodosMcpTool.cs az alábbi kóddal.

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.";
        }
    }
}

A fenti kód az alábbi attribútumok használatával teszi elérhetővé az eszközöket az MCP-kiszolgáló számára:

[McpServerToolType]: Az osztályt TodosMcpTool MCP-kiszolgálóeszköz-típusként jelöli meg. Jelzi az MCP-keretrendszernek, hogy ez az osztály olyan metódusokat tartalmaz, amelyeket hívható eszközként kell elérhetővé tenni.
[McpServerTool]: A metódust az MCP-kiszolgáló hívható műveleteként jelöli meg.
[Description]: Ezek a módszerek és paraméterek ember által olvasható leírását adják meg. Segít a hívóügynöknek megérteni a műveletek és paramétereik használatát.

Ez a kód duplikálja a meglévő TodosControllerfunkcióját, ami szükségtelen, de az egyszerűség kedvéért megtartja. Az ajánlott eljárás az alkalmazáslogika áthelyezése egy szolgáltatásosztályba, majd a szolgáltatás metódusainak meghívása a TodosController és a TodosMcpTool osztályokból.

A Program.cs regisztrálja az MCP-kiszolgáló szolgáltatást és a CORS szolgáltatást.

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();
    });
});

Ha streamelhető HTTP-t használ az MCP-kiszolgálóval, engedélyeznie kell a forrásközi erőforrás-megosztást (CORS), ha ügyfélböngésző eszközökkel vagy a GitHub Copilottal szeretné tesztelni (mind a Visual Studio Code-ban, mind a GitHub Codespace-ben).

Az Program.cs engedélyezze az MCP és CORS köztes szoftvereket.
```
app.MapMcp("/api/mcp");
app.UseCors();
```
Ez a kód az MCP-kiszolgáló végpontját a értékre állítja <url>/api/mcp.

Az MCP-kiszolgáló helyi tesztelése

A kódtér termináljában futtassa az alkalmazást a következővel dotnet run: .
Válassza a Megnyitás böngészőben lehetőséget, majd adjon hozzá egy feladatot.

Hagyja futni dotnet run . Az MCP-kiszolgáló jelenleg http://localhost:5093/api/mcp fut.
A kódtérben nyissa meg a Copilot-csevegést, majd válassza az Ügynök mód lehetőséget a parancssorban.
Válassza az Eszközök gombot, majd válassza a További eszközök hozzáadása... lehetőséget a legördülő menüben.
Válassza az MCP-kiszolgáló hozzáadása lehetőséget.
Válassza a HTTP (HTTP vagy Server-Sent események) lehetőséget.
A Server URL bevitele mezőbe írja be a http://localhost:5093/api/mcp értéket.
Az Enter Server ID mezőbe írja bea todos-mcp nevet vagy a kívánt nevet.
Válassza a Munkaterület beállításai lehetőséget.
Egy új Copilot-csevegési ablakban írja be a következőt: "Mutasd meg a todos".
Alapértelmezés szerint a GitHub Copilot biztonsági megerősítést jelenít meg egy MCP-kiszolgáló meghívásakor. Válassza a Folytatáslehetőséget.

Ekkor megjelenik egy válasz, amely azt jelzi, hogy az MCP-eszköz hívása sikeres.

Az MCP-kiszolgáló üzembe helyezése az App Service-ben

A kódtér termináljába visszatérve telepítse a módosításokat a módosítások véglegesítésével (GitHub Actions metódus) vagy futtassa azd up (Azure Developer CLI-metódus).
Az AZD-kimenetben keresse meg az alkalmazás URL-címét. Az URL-cím így néz ki az AZD-kimenetben:
```
 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: <app-url>
 
```
Miután azd up befejeződött, nyissa meg a .vscode/mcp.json. Módosítsa az URL-címet a következőre: <app-url>/api/mcp.
A módosított MCP-kiszolgáló konfigurációja felett válassza a Start lehetőséget.
Hozzon létre egy új GitHub Copilot-csevegőablakot. A Copilot-ügynökben meg kell tudnia tekinteni, létrehozni, frissíteni és törölni a feladatokat.

Ajánlott biztonsági eljárások

Ha az MCP-kiszolgálót nagy nyelvi modellekkel (LLM) rendelkező ügynök hívja meg, vegye figyelembe a gyors injektálási támadásokat. Vegye figyelembe az alábbi ajánlott biztonsági eljárásokat:

Hitelesítés és engedélyezés: Az MCP-kiszolgáló védelme Microsoft Entra-hitelesítéssel annak biztosítása érdekében, hogy csak a jogosult felhasználók vagy ügynökök férhessenek hozzá az eszközeihez. Részletes útmutatót a Visual Studio Code-ból az Azure App Service-be irányuló Biztonságos modell környezeti protokoll hívásai a Microsoft Entra-hitelesítéssel című témakörben talál.
Bemenet-ellenőrzés és -tisztítás: Az oktatóanyagban szereplő példakód kihagyja a bemeneti ellenőrzést és a tisztítást az egyszerűség és az egyértelműség érdekében. Éles helyzetekben mindig valósítsa meg a megfelelő ellenőrzést és tisztítást az alkalmazás védelme érdekében. A ASP.NET Core esetében lásd a modellérvényesítést ASP.NET Core-ban.
HTTPS: A minta az Azure App Service-ra támaszkodik, amely alapértelmezés szerint kényszeríti a HTTPS-t, és ingyenes TLS-/SSL-tanúsítványokat biztosít az átvitel közbeni adatok titkosításához.
Minimális jogosultság elve: Csak a használati esethez szükséges eszközöket és adatokat tegye elérhetővé. Ha szükséges, kerülje a bizalmas műveletek felfedését.
Sebességkorlátozás és szabályozás: Az API Management vagy az egyéni köztes szoftver használata a visszaélések és a szolgáltatásmegtagadásos támadások megelőzésére.
Naplózás és figyelés: Az MCP-végpontok naplóhozzáférése és használata naplózáshoz és anomáliadetektáláshoz. Gyanús tevékenységek figyelése.
CORS-konfiguráció: Ha az MCP-kiszolgáló böngészőkből érhető el, korlátozza a forrásközi kérelmeket megbízható tartományokra. További információ: CORS engedélyezése.
Rendszeres frissítések: A függőségek naprakészen tartása az ismert biztonsági rések csökkentése érdekében.

További erőforrások

AI integrálása az Azure App Service-alkalmazásokba

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-20