Rövid útmutató: Egyéni távoli MCP-kiszolgáló létrehozása az Azure Functions használatával

Ebben a rövid útmutatóban egy egyéni távoli Model Context Protocol (MCP) kiszolgálót hoz létre egy sablonprojektből az Azure Developer CLI (azd) használatával. Az MCP-kiszolgáló az Azure Functions MCP-kiszolgálóbővítmény használatával biztosít eszközöket AI-modellekhez, ügynökökhöz és asszisztensekhez. Miután helyileg futtatta a projektet, és ellenőrizte a kódot a GitHub Copilot használatával, üzembe helyezi azt egy új kiszolgáló nélküli függvényalkalmazásban az Azure Functionsben, amely a biztonságos és skálázható üzemelő példányok jelenlegi ajánlott eljárásait követi.

Jótanács

A Functions lehetővé teszi, hogy meglévő MCP-kiszolgálókódprojektet helyezzen üzembe egy Flex Consumption-tervalkalmazásban anélkül, hogy módosítania kellene a kódprojektet. További információ : Rövid útmutató: Meglévő MCP-kiszolgálók üzemeltetésére az Azure Functionsben.

Mivel az új alkalmazás a Használatalapú fizetéses számlázási modellt követő Flex Consumption-csomagban fut, ennek a rövid útmutatónak a elvégzése néhány dollárcentes vagy annál kisebb költséget jelent az Azure-fiókjában.

Fontos

Bár az egyéni MCP-kiszolgálók létrehozása minden Functions-nyelv esetében támogatott, ebben a rövid útmutatóban jelenleg csak a C#, a Python és a TypeScript esetében vannak példák. A rövid útmutató végrehajtásához válasszon egyet a cikk tetején található támogatott nyelvek közül.

Ez a cikk az Azure Functions Node.js programozási modelljének 4. verzióját támogatja.

Ez a cikk az Azure Functions Python programozási modelljének 2. verzióját támogatja.

Előfeltételek

.NET 8.0 SDK

Java 17 Fejlesztői készlet
- Ha a Java egy másik támogatott verzióját használja, frissítenie kell a projekt pom.xml fájlját.
- Állítsa a környezeti változót JAVA_HOME a Java Development Kit (JDK) megfelelő verziójának telepítési helyére.
Apache Maven 3.8.x

Node.js 20

Python 3.11

Visual Studio Code az alábbi bővítményekkel:
- Azure Functions-bővítmény. Ehhez a bővítményhez az Azure Functions Core Tools szükséges, és ha nem érhető el, megpróbálja telepíteni.
- Azure Developer CLI-bővítmény.
Azurite Storage Emulator
Azure parancssori felület (CLI). Az Azure CLI-parancsokat az Azure Cloud Shellben is futtathatja.
Egy Azure-fiók, aktív előfizetéssel. Hozzon létre egy fiókot ingyenesen.

A projekt inicializálása

azd init A parancs használatával helyi Azure Functions-kódprojektet hozhat létre egy sablonból.

A Visual Studio Code-ban nyisson meg egy mappát vagy munkaterületet, ahol létre szeretné hozni a projektet.

Futtassa azd init a következő parancsot a terminálban:
```
azd init --template remote-mcp-functions-dotnet -e mcpserver-dotnet
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforráscsoport nevében is használatos.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot:
```
azd init --template remote-mcp-functions-java -e mcpserver-java 
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot:
```
azd init --template remote-mcp-functions-typescript -e mcpserver-ts
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A helyi terminálban vagy parancssorban futtassa ezt a azd init parancsot:
```
azd init --template remote-mcp-functions-python -e mcpserver-python
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A táremulátor indítása

Az Azurite emulátor használatával szimulálhatja az Azure Storage-fiókkapcsolatot a kódprojekt helyi futtatásakor.

Ha még nem tette meg, telepítse az Azurite-ot.
Nyomja le az F1 billentyűt. A parancskatalógusban keresse meg és futtassa a parancsot Azurite: Start a helyi tárolóemulátor elindításához.

Az MCP-kiszolgáló helyi futtatása

A Visual Studio Code az Azure Functions Core-eszközökkel integrálva lehetővé teszi a projekt futtatását a helyi fejlesztői számítógépen az Azurite emulátor használatával.

A függvény helyi indításához nyomja le az F5 billentyűt vagy a Futtatás és hibakeresés ikont a bal oldali tevékenységsávon. A Terminál panelen a Core Tools kimenete látható. Az alkalmazás a Terminál panelen kezdődik, és láthatja a helyileg futó függvények nevét.
Jegyezze fel a helyi MCP-kiszolgálóvégpontot (például http://localhost:7071/runtime/webhooks/mcp), amellyel konfigurálhatja a GitHub Copilotot a Visual Studio Code-ban.

A GitHub Copilot használatának ellenőrzése

A kód ellenőrzéséhez adja hozzá a futó projektet MCP-kiszolgálóként a GitHub Copilothoz a Visual Studio Code-ban:

Nyomja le az F1 billentyűt. A parancskatalógusban keresse meg és futtassa az MCP: Kiszolgáló hozzáadása parancsot.
Az átviteli típushoz válassza a HTTP (Server-Sent Események) lehetőséget.
Adja meg az előző lépésben másolt MCP-végpont URL-címét.
Használja a létrehozott kiszolgálóazonosítót , és válassza a Munkaterület lehetőséget az MCP-kiszolgáló kapcsolatának a munkaterület beállításaiba való mentéséhez.
Nyissa meg a parancskatalógust, és futtassa az MCP: List Servers parancsot , és ellenőrizze, hogy a hozzáadott kiszolgáló szerepel-e a listán és fut-e.
A Copilot beszélgetésben válassza az Ügynök módot, és futtassa ezt az utasítást:
```
Say Hello
```
Amikor a rendszer kéri az eszköz futtatását, válassza az Engedélyezés lehetőséget ezen a munkaterületen , hogy ne kelljen továbbra is engedélyt adnia. A prompt futtatása után visszakapjuk a Hello World válasz adatokat, és a függvény végrehajtásának adatai a naplókba kerülnek.
Most válasszon ki egy kódot az egyik projektfájlban, és futtassa a következő parancssort:
```
Save this snippet as snippet1
```
A Copilot tárolja a kódrészletet, és információt ad arról, hogyan lehet az eszközt használva megszerezni a kódrészletet. Ismét áttekintheti a függvény végrehajtását a naplókban, és ellenőrizheti, hogy a saveSnippets függvény futott-e.
A Copilot-csevegésben futtassa ezt az utasítást:
```
Retrieve snippet1 and apply to NewFile
```
A Copilot lekéri a kódrészleteket, hozzáadja őket egy nevű NewFilefájlhoz, és bármit megtesz, ami szükséges ahhoz, hogy a kódrészlet működjön a projektben. A Függvénynaplók azt mutatják, hogy a getSnippets végpontot meghívták.
Ha befejezte a tesztelést, a Ctrl+C billentyűkombinációt lenyomva állítsa le a Functions-gazdagépet.

A kód áttekintése (nem kötelező)

Áttekintheti az MCP-kiszolgálóeszközöket meghatározó kódot:

Az MCP-kiszolgálóeszközök függvénykódja a src mappában van definiálva. Az McpToolTrigger attribútum MCP Server-eszközökként teszi elérhetővé a függvényeket:

[Function(nameof(SayHello))]
public string SayHello(
    [McpToolTrigger(HelloToolName, HelloToolDescription)] ToolInvocationContext context
)
{
    logger.LogInformation("Saying hello");
    return "Hello I am MCP Tool!";
}

    [Function(nameof(GetSnippet))]
    public object GetSnippet(
        [McpToolTrigger(GetSnippetToolName, GetSnippetToolDescription)]
            ToolInvocationContext context,
        [BlobInput(BlobPath)] string snippetContent
    )
    {
        return snippetContent;
    }

    [Function(nameof(SaveSnippet))]
    [BlobOutput(BlobPath)]
    public string SaveSnippet(
        [McpToolTrigger(SaveSnippetToolName, SaveSnippetToolDescription)]
            ToolInvocationContext context,
        [McpToolProperty(SnippetNamePropertyName, SnippetNamePropertyDescription, true)]
            string name,
        [McpToolProperty(SnippetPropertyName, SnippetPropertyDescription, true)]
            string snippet
    )
    {
        return snippet;
    }
}

A teljes projektsablont az Azure Functions .NET MCP Server GitHub-adattárban tekintheti meg.

Az MCP-kiszolgálóeszközök függvénykódja a src/main/java/com/function/ mappában van definiálva. A @McpToolTrigger széljegyzet a függvényeket MCP Server-eszközökként teszi elérhetővé:

            description = "The messages to be logged.",
            isRequired = true,
            isArray = true)
        String messages,
        final ExecutionContext functionExecutionContext
) {
    functionExecutionContext.getLogger().info("Hello, World!");
    functionExecutionContext.getLogger().info("Tool Name: " + mcpToolInvocationContext.getName());
    functionExecutionContext.getLogger().info("Transport Type: " + mcpToolInvocationContext.getTransportType());
    
    // Handle different transport types
    if (mcpToolInvocationContext.isHttpStreamable()) {
        functionExecutionContext.getLogger().info("Session ID: " + mcpToolInvocationContext.getSessionid());
    } else if (mcpToolInvocationContext.isHttpSse()) {
        if (mcpToolInvocationContext.getClientinfo() != null) {
            functionExecutionContext.getLogger().info("Client: " + 
                mcpToolInvocationContext.getClientinfo().get("name").getAsString() + " v" +

    // Write the snippet content to the output blob
    outputBlob.setValue(snippet);
    
    return "Successfully saved snippet '" + snippetName + "' with " + snippet.length() + " characters.";
}

/**
 * Azure Function that handles retrieving a text snippet from Azure Blob Storage.
 * <p>
 * The function is triggered by an MCP Tool Trigger. The snippet name is provided
 * as an MCP tool property, and the snippet content is read from the blob at the 
 * path derived from the snippet name.
 *
 * @param mcpToolInvocationContext The JSON input from the MCP tool trigger.
 * @param snippetName   The name of the snippet to retrieve, provided as an MCP tool property.
 * @param inputBlob     The Azure Blob input binding that fetches the snippet content.
 * @param functionExecutionContext       The execution context for logging.
 */
@FunctionName("GetSnippets")
@StorageAccount("AzureWebJobsStorage")
public String getSnippet(
        @McpToolTrigger(
            name = "getSnippets",
            description = "Gets a text snippet from your snippets collection.")
        String mcpToolInvocationContext,
        @McpToolProperty(
            name = SNIPPET_NAME_PROPERTY_NAME,
            propertyType = "string",
            description = "The name of the snippet.",
            isRequired = true)
        String snippetName,
        @BlobInput(name = "inputBlob", path = BLOB_PATH)
        String inputBlob,
        final ExecutionContext functionExecutionContext
) {
    // Log the entire incoming JSON for debugging
    functionExecutionContext.getLogger().info(mcpToolInvocationContext);

    // Log the snippet name and the fetched snippet content from the blob

A teljes projektsablont az Azure Functions Java MCP Server GitHub-adattárában tekintheti meg.

Az MCP-kiszolgálóeszközök függvénykódja a src/function_app.py fájlban van definiálva. Az MCP-függvény széljegyzetei ezeket a függvényeket MCP Server-eszközökként teszik elérhetővé:

tool_properties_save_snippets_json = json.dumps([prop.to_dict() for prop in tool_properties_save_snippets_object])
tool_properties_get_snippets_json = json.dumps([prop.to_dict() for prop in tool_properties_get_snippets_object])


@app.generic_trigger(
    arg_name="context",
    type="mcpToolTrigger",
    toolName="hello_mcp",
    description="Hello world.",
    toolProperties="[]",
)
def hello_mcp(context) -> None:
    """


@app.generic_trigger(
    arg_name="context",
    type="mcpToolTrigger",
    toolName="save_snippet",
    description="Save a snippet with a name.",
    toolProperties=tool_properties_save_snippets_json,
)
@app.generic_output_binding(arg_name="file", type="blob", connection="AzureWebJobsStorage", path=_BLOB_PATH)
def save_snippet(file: func.Out[str], context) -> str:
    content = json.loads(context)
    snippet_name_from_args = content["arguments"][_SNIPPET_NAME_PROPERTY_NAME]
    snippet_content_from_args = content["arguments"][_SNIPPET_PROPERTY_NAME]

    if not snippet_name_from_args:
        return "No snippet name provided"

    if not snippet_content_from_args:
        return "No snippet content provided"

    file.set(snippet_content_from_args)
    logging.info(f"Saved snippet: {snippet_content_from_args}")
    return f"Snippet '{snippet_content_from_args}' saved successfully"

A teljes projektsablont az Azure Functions Python MCP Server GitHub-adattárában tekintheti meg.

Az MCP-kiszolgálóeszközök függvénykódja a src mappában van definiálva. Az MCP-függvényregisztráció ezeket a függvényeket MCP-kiszolgálóeszközökként teszi elérhetővé:

export async function mcpToolHello(_toolArguments:unknown, context: InvocationContext): Promise<string> {
    console.log(_toolArguments);
    // Get name from the tool arguments
    const mcptoolargs = context.triggerMetadata.mcptoolargs as {
        name?: string;
    };
    const name = mcptoolargs?.name;

    console.info(`Hello ${name}, I am MCP Tool!`);
    
    return `Hello ${name || 'World'}, I am MCP Tool!`;
}

// Register the hello tool
app.mcpTool('hello', {
    toolName: 'hello',
    description: 'Simple hello world MCP Tool that responses with a hello message.',
    toolProperties:{
        name: arg.string().describe('Required property to identify the caller.').optional()
    },
    handler: mcpToolHello
});

// SaveSnippet function - saves a snippet with a name
export async function saveSnippet(
  _toolArguments: unknown,
  context: InvocationContext
): Promise<string> {
  console.info("Saving snippet");

  // Get snippet name and content from the tool arguments
  const mcptoolargs = context.triggerMetadata.mcptoolargs as {
    snippetname?: string;
    snippet?: string;
  };

  const snippetName = mcptoolargs?.snippetname;
  const snippet = mcptoolargs?.snippet;

  if (!snippetName) {
    return "No snippet name provided";
  }

  if (!snippet) {
    return "No snippet content provided";
  }

  // Save the snippet to blob storage using the output binding
  context.extraOutputs.set(blobOutputBinding, snippet);

  console.info(`Saved snippet: ${snippetName}`);
  return snippet;
}

A teljes projektsablont az Azure Functions TypeScript MCP Server GitHub-adattárban tekintheti meg.

Az MCP-kiszolgáló eszközeinek helyi ellenőrzése után közzéteheti a projektet az Azure-ban.

Telepítés az Azure-ra

Ez a projekt úgy van konfigurálva, hogy a parancs használatával telepítse ezt a azd up projektet egy új függvényalkalmazásban egy Rugalmas használatú csomagban az Azure-ban. A projekt olyan Bicep-fájlokat tartalmaz, amelyek azd a legjobb gyakorlatokat követve biztonságos üzembe helyezést biztosítanak egy Flex fogyasztási tervben.

A Visual Studio Code-ban nyomja le az F1 billentyűt a parancskatalógus megnyitásához. Keresse meg és futtassa a parancsot Azure Developer CLI (azd): Package, Provison and Deploy (up). Ezután jelentkezzen be az Azure-fiókjával.
Ha még nem jelentkezett be, jelentkezzen be az Azure-fiókjával.

Amikor a rendszer kéri, adja meg a szükséges üzembehelyezési paramétereket:

Paraméter	Description
Azure-előfizetés	Előfizetés, amelyben az erőforrások létrejönnek.
Azure-hely	Azure-régió, amelyben létre kell hozni az új Azure-erőforrásokat tartalmazó erőforráscsoportot. Csak azok a régiók jelennek meg, amelyek jelenleg támogatják a Rugalmas felhasználás csomagot.

A parancs sikeres végrehajtása után megjelennek a létrehozott erőforrásokra mutató hivatkozások.

Csatlakozás a távoli MCP-kiszolgálóhoz

Az MCP-kiszolgáló most már az Azure-ban fut. Az eszközök elérésekor egy rendszerkulcsot kell tartalmaznia a kérésben. Ez a kulcs bizonyos fokú hozzáférés-vezérlést biztosít a távoli MCP-kiszolgálóhoz hozzáférő ügyfelek számára. A kulcs lekérése után csatlakoztathatja a GitHub Copilotot a távoli kiszolgálóhoz.

Futtassa ezt a szkriptet, amely az Azure CLI-t használja azd az MCP-kiszolgáló URL-címének és az eszközök eléréséhez szükséges rendszerkulcs (mcp_extension) kinyomtatásához:

Linux/macOS
Windows

eval $(azd env get-values --output dotenv)
MCP_EXTENSION_KEY=$(az functionapp keys list --resource-group $AZURE_RESOURCE_GROUP \
    --name $AZURE_FUNCTION_NAME --query "systemKeys.mcp_extension" -o tsv)
printf "MCP Server URL: %s\n" "https://$SERVICE_API_NAME.azurewebsites.net/runtime/webhooks/mcp"
printf "MCP Server key: %s\n" "$MCP_EXTENSION_KEY"

azd env get-values --output dotenv | ForEach-Object { 
    if ($_ -match "^([^=]+)=(.*)$") { 
        Set-Variable -Name $matches[1] -Value ($matches[2] -replace '"', '')
    } 
}
$MCP_EXTENSION_KEY = az functionapp keys list --resource-group $AZURE_RESOURCE_GROUP `
    --name $AZURE_FUNCTION_NAME --query "systemKeys.mcp_extension" -o tsv
Write-Host "MCP Server URL: https://$SERVICE_API_NAME.azurewebsites.net/runtime/webhooks/mcp"
Write-Host "MCP Server key: $MCP_EXTENSION_KEY"

A Visual Studio Code-ban nyomja le az F1 billentyűt a parancspaletta megnyitásához, keresse meg és futtassa a parancsot MCP: Open Workspace Folder MCP Configuraton, amely megnyitja a mcp.json konfigurációs fájlt.
A konfigurációban mcp.json keresse meg a korábban hozzáadott nevesített MCP-kiszolgálót, módosítsa az url értéket a távoli MCP-kiszolgáló URL-címére, és adjon hozzá egy headers.x-functions-key elemet, amely tartalmazza a másolt MCP-kiszolgáló hozzáférési kulcsát, ahogyan az ebben a példában látható:
```
{
    "servers": {
        "remote-mcp-function": {
            "type": "http",
            "url": "https://contoso.azurewebsites.net/runtime/webhooks/mcp",
            "headers": {
                "x-functions-key": "A1bC2dE3fH4iJ5kL6mN7oP8qR9sT0u..."
            }
        }
    }
}
```
A távoli MCP-kiszolgáló újraindításához válassza a megnyitásban a kiszolgáló neve fölötti mcp.json gombot, ezúttal az üzembe helyezett alkalmazással.

Az üzembe helyezés ellenőrzése

A GitHub Copilot mostantól ugyanúgy használhatja a távoli MCP-eszközöket, mint helyileg, de a kód most már biztonságosan fut az Azure-ban. A korábban használt parancsok visszajátszásával gondoskodhat arról, hogy minden megfelelően működjön.

Erőforrások tisztítása

Ha végzett az MCP-kiszolgálóval és a kapcsolódó erőforrásokkal, ezzel a paranccsal törölheti a függvényalkalmazást és annak kapcsolódó erőforrásait az Azure-ból a további költségek elkerülése érdekében:

azd down --no-prompt

Megjegyzés:

A --no-prompt beállítás utasítja azd az erőforráscsoport törlésére megerősítés nélkül. Ez a parancs nincs hatással a helyi kódprojektre.

Következő lépések

Beépített MCP-kiszolgáló engedélyezésének konfigurálása

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-01