Správa serverů MCP prostřednictvím kódu programu ve službě API Management

V tomto článku se dozvíte, jak vytvářet a spravovat servery MCP v Azure API Management pomocí rozhraní REST API, šablon ARM, Bicep, Azure CLI a Terraformu. 

Important

Funkce pro správu serveru MCP popsané v tomto článku vyžadují rozhraní REST API služby API Management ve verzi 2025-09-01-preview nebo novější. Připněte tuto verzi v každé žádosti. 

Základní informace o možnostech serveru MCP najdete v tématu o serverech MCP v Azure API Management.

Prerequisites

Model prostředků

Azure Resource Manager představuje servery MCP následujícím způsobem:

  • Server MCP: Prostředek API služby API Management typuMCP

  • Průchozí server: Ukazuje na existující externí backend MCP. Prostředek serveru MCP deklaruje back-endovou adresu URL a typ přenosu (streamovatelné HTTP nebo SSE).

  • Nástroj: Podprostředek serveru MCP typu API nástroj. Prostředky nástrojů můžete bezpečně spravovat z CI/CD. Nástroje můžete přidat, přejmenovat nebo odebrat bez opětovného vytvoření serveru MCP.

  • Politiky: Stejně jako u běžných rozhraní API připojte zásady rozhraní API nebo dílčí prostředky zásad k serveru MCP.

  • Produkty: Vazba produktu je samostatný podřazený vztah (products/{productId}/apis/{mcpServerId}), který umožňuje nezávislé nasazení a vazbu k více produktům.

Příklady REST

Pro názornost uvádějí následující příklady zkrácená těla odpovědí. Úplná schémata odpovědí najdete v referenčních informacích k rozhraní REST API služby API Management.

Přidání hlavičky If-Match: * do příkladů volání metod PUT a DELETE zajistí, že požadavky budou idempotentní. Tato hlavička platí bez ohledu na to, zda prostředek již existuje, což je doporučený postup pro CI/CD pipeline.

Než začnete

Před spuštěním libovolného příkladu nastavte následující proměnné. Všechny příklady v této části odkazují na tyto proměnné.

SUBSCRIPTION_ID="<your-subscription-id>"
RESOURCE_GROUP="<your-resource-group>"
APIM_NAME="<your-api-management-service-name>"
API_VERSION="2025-09-01-preview"
BASE_URL="https://management.azure.com/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RESOURCE_GROUP}/providers/Microsoft.ApiManagement/service/${APIM_NAME}"
TOKEN=$(az account get-access-token --resource https://management.azure.com --query accessToken -o tsv)

Výpis serverů MCP

Vrátí všechna rozhraní API v instanci filtrovaná podle typu mcp. $top Pomocí parametrů dotazu $skip můžete procházet velké sady výsledků.

Reference: API – Seznam podle služby

curl -sG "${BASE_URL}/apis" \
  --data-urlencode "api-version=${API_VERSION}" \
  --data-urlencode "\$filter=type eq 'mcp'" \
  -H "Authorization: Bearer ${TOKEN}"

Odpověď (200 OK)

{
  "count": 1,
  "value": [
    {
      "id": "/subscriptions/.../apis/my-mcp-server",
      "name": "my-mcp-server",
      "type": "Microsoft.ApiManagement/service/apis",
      "properties": {
        "type": "mcp",
        "displayName": "My MCP Server",
        "path": "my-mcp",
        "protocols": [ "https" ]
      }
    }
  ]
}

Běžná chyba:401 Unauthorized Platnost nosného tokenu vypršela. Znovu spusťte příkaz k získání tokenu.

Získání jednoho serveru MCP

Referenční informace: Api – Get

MCP_SERVER_ID="my-mcp-server"

curl -s "${BASE_URL}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}"

Odpověď (200 OK)

{
  "id": "/subscriptions/.../apis/my-mcp-server",
  "name": "my-mcp-server",
  "type": "Microsoft.ApiManagement/service/apis",
  "properties": {
    "type": "mcp",
    "displayName": "My MCP Server",
    "path": "my-mcp",
    "protocols": [ "https" ],
    "serviceUrl": "https://api.contoso.com"
  }
}

Běžná chyba:404 Not Found Ověřte, že mcpServerId odpovídá name poli vrácené operací Seznam.

Vytvoření serveru MCP založeného na rozhraní REST API

Vytvoří prostředek serveru MCP. Po vytvoření přidejte do ní nástroje jednotlivě pomocí operace Přidat nebo aktualizovat nástroj . Každý nástroj odkazuje na konkrétní operaci v záložním prostředku rozhraní REST API.

Reference: API – Vytvořit nebo aktualizovat

MCP_SERVER_ID="my-mcp-server"

curl -s -X PUT \
  "${BASE_URL}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -H "If-Match: *" \
  -d '{
    "properties": {
      "type": "mcp",
      "path": "my-mcp",
      "displayName": "My MCP Server",
      "description": "MCP server backed by a REST API",
      "protocols": ["https"]
    }
  }'

Odpověď (201 Vytvořeno)

{
  "id": "/subscriptions/.../apis/my-mcp-server",
  "name": "my-mcp-server",
  "type": "Microsoft.ApiManagement/service/apis",
  "properties": {
    "type": "mcp",
    "displayName": "My MCP Server",
    "path": "my-mcp",
    "protocols": ["https"],
    "provisioningState": "InProgress"
  }
}

Note

provisioningState: InProgress očekává se u asynchronních operací PUT. Ověřte dokončení dotazováním adresy URL vrácené v hlavičce odpovědi Azure-AsyncOperation.

Běžná chyba:400 Bad Request Zajistěte, aby type byl "mcp" a aby path byl v rámci instance služby jedinečný.

Vytvoření předávacího serveru MCP

Předávací server předává všechny požadavky MCP přímo externímu back-endu MCP. Nastavte mcpProperties.transportType tak, aby odpovídal transportu, který implementuje váš backend.

Před vytvořením serveru passthrough ověřte, že backend je dosažitelný z brány API Management a že na cestách koncových bodů, které nakonfigurujete, implementuje vybraný přenos MCP. Pokud back-end vyžaduje ověření, nakonfigurujte požadované přihlašovací údaje nebo hlavičky pomocí zásad služby API Management nebo konfigurace back-endu.

Reference: API – Vytvořit nebo aktualizovat

Přenos HTTP s možností streamování

Používá se streamable pro back-endy, které implementují aktuální specifikaci přenosu HTTP s možností streamování MCP. Vyžaduje se jedna definice koncového bodu.

MCP_SERVER_ID="my-mcp-passthrough"

curl -s -X PUT \
  "${BASE_URL}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -H "If-Match: *" \
  -d '{
    "properties": {
      "type": "mcp",
      "path": "my-mcp-passthrough",
      "displayName": "My Passthrough MCP Server",
      "description": "Passthrough MCP server using streamable HTTP transport",
      "protocols": ["https"],
      "serviceUrl": "https://mcp-backend.contoso.com",
      "mcpProperties": {
        "transportType": "streamable",
        "endpoints": [
          { "name": "message", "uriTemplate": "/mcp" }
        ]
      }
    }
  }'

Odpověď (201 Vytvořeno)

{
  "id": "/subscriptions/.../apis/my-mcp-passthrough",
  "name": "my-mcp-passthrough",
  "type": "Microsoft.ApiManagement/service/apis",
  "properties": {
    "type": "mcp",
    "displayName": "My Passthrough MCP Server",
    "path": "my-mcp-passthrough",
    "protocols": ["https"],
    "serviceUrl": "https://mcp-backend.contoso.com",
    "provisioningState": "InProgress",
    "mcpProperties": {
      "transportType": "streamable",
      "endpoints": [ { "name": "message", "uriTemplate": "/mcp" } ]
    }
  }
}

Doprava SSE

Použijte sse pro backendy, které podporují transport HTTP+SSE (Server-Sent Events). Definujte dva koncové body: jeden pro stream událostí SSE a jeden pro kanál zpráv.

MCP_SERVER_ID="my-mcp-sse"

curl -s -X PUT \
  "${BASE_URL}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -H "If-Match: *" \
  -d '{
    "properties": {
      "type": "mcp",
      "path": "my-mcp-sse",
      "displayName": "My SSE MCP Server",
      "description": "Passthrough MCP server using SSE transport",
      "protocols": ["https"],
      "serviceUrl": "https://mcp-backend.contoso.com",
      "mcpProperties": {
        "transportType": "sse",
        "endpoints": [
          { "name": "sse",     "uriTemplate": "/sse" },
          { "name": "message", "uriTemplate": "/messages" }
        ]
      }
    }
  }'

Běžné chyby:

  • 400 Bad Request. Neplatný mcpProperties. Ověřte transportType , zda je streamable nebo sse, a každé uriTemplate začíná na /.
  • 400 Bad Request. Transport SSE vyžaduje právě dva koncové body (sse a message). Streamovatelný přenos vyžaduje jednu položku (message).

Přidání nebo aktualizace nástroje

Přidá nový nástroj na server MCP s podporou rozhraní REST API nebo aktualizuje existující. Pole operationId propojí nástroj s konkrétní operací v záložním prostředku rozhraní REST API. Nástroje můžete přidávat, aktualizovat nebo odebírat nezávisle bez opětovného vytvoření nadřazeného serveru.

Referenční informace: Nástroj api – Vytvoření nebo aktualizace

MCP_SERVER_ID="my-mcp-server"
TOOL_ID="listOrders"
BACKING_API_ID="orders-api"
BACKING_OP_ID="list-orders"
OP_ID="/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RESOURCE_GROUP}/providers/Microsoft.ApiManagement/service/${APIM_NAME}/apis/${BACKING_API_ID}/operations/${BACKING_OP_ID}"

curl -s -X PUT \
  "${BASE_URL}/apis/${MCP_SERVER_ID}/tools/${TOOL_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -H "If-Match: *" \
  --data-raw "{
    \"properties\": {
      \"displayName\": \"listOrders\",
      \"description\": \"List all orders for a customer\",
      \"operationId\": \"${OP_ID}\"
    }
  }"

Odpověď (201 Vytvořeno)

{
  "id": "/subscriptions/.../apis/my-mcp-server/tools/listOrders",
  "name": "listOrders",
  "type": "Microsoft.ApiManagement/service/apis/tools",
  "properties": {
    "displayName": "listOrders",
    "description": "List all orders for a customer",
    "operationId": "/subscriptions/.../apis/orders-api/operations/list-orders"
  }
}

Běžné chyby:

  • 400 Bad Request. Cesta operationId je poškozená nebo odkazovaná operace neexistuje.
  • 404 Not Found. Nadřazený server MCP neexistuje. Před přidáním nástrojů vytvořte server.

Odstraňte nástroj

Odebere nástroj ze serveru MCP. Odstraňte nástroje před odstraněním backingových operací rozhraní REST API, na které odkazují; jinak odstranění selže s chybou závislosti.

Referenční informace: API Tool – Odstranit

MCP_SERVER_ID="my-mcp-server"
TOOL_ID="listOrders"

curl -s -X DELETE \
  "${BASE_URL}/apis/${MCP_SERVER_ID}/tools/${TOOL_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "If-Match: *"

Reakce:200 OK o úspěchu.

Běžná chyba:412 Precondition Failed — If-Match je vyžadováno pro odstranění. Použijte If-Match: * k porovnání s libovolným tagem ETag.

Použití zásad v oboru MCP

Vytvoří nebo nahradí dokument zásad připojený k serveru MCP. Server vyhodnocuje zásady v tomto rozsahu pro každé vyvolání nástroje. Formát rawxml přijímá nekódované XML zásad.

Referenční informace: Zásady rozhraní API – Vytvoření nebo aktualizace

MCP_SERVER_ID="my-mcp-server"
POLICY='<policies><inbound><base /><rate-limit calls="100" renewal-period="60" /></inbound><backend><forward-request /></backend><outbound><base /></outbound></policies>'

curl -s -X PUT \
  "${BASE_URL}/apis/${MCP_SERVER_ID}/policies/policy?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -H "If-Match: *" \
  --data-raw "{\"properties\":{\"format\":\"rawxml\",\"value\":\"${POLICY}\"}}"

Odpověď (200 OK)

{
  "id": "/subscriptions/.../apis/my-mcp-server/policies/policy",
  "name": "policy",
  "type": "Microsoft.ApiManagement/service/apis/policies",
  "properties": {
    "value": "<policies>...</policies>"
  }
}

Běžná chyba:400 Bad Request Poškozený kód XML zásad. Před odesláním dokument ověřte.

Vytvoření vazby serveru MCP k produktu

Přidruží server MCP k produktu, aby odběratelé tohoto produktu mohli volat nástroje tohoto serveru. Požadavek nemá žádný text.

Když svážete server MCP s produktem, zpřístupníte ho prostřednictvím daného produktu, ale klienti stále potřebují přístup podle konfigurace produktu. Pokud produkt vyžaduje předplatná, musí klient pro tento produkt použít platný klíč předplatného.

Referenční informace: Rozhraní API produktu – Vytvoření nebo aktualizace

MCP_SERVER_ID="my-mcp-server"
PRODUCT_ID="my-product"

curl -s -X PUT \
  "${BASE_URL}/products/${PRODUCT_ID}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Length: 0"

Odpověď:201 Created s kontraktem API serveru MCP v těle.

Běžná chyba:404 Not Found Před vytvořením vazby ověřte, že obě productId a mcpServerId existují.

Odstranění serveru MCP

Odstraní server MCP a všechny jeho nástroje a dílčí prostředky zásad. Před odstraněním serveru odeberte všechny nástroje, které odkazují na operace v backingových rozhraních API; jinak tyto operace nemůžete odstranit, pokud odkaz na nástroj existuje.

Reference: API – Odstranit

MCP_SERVER_ID="my-mcp-server"

curl -s -X DELETE \
  "${BASE_URL}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "If-Match: *"

Reakce:200 OK o úspěchu.

Běžná chyba:412 Precondition Failed If-Match je vyžadováno pro odstranění. Použijte If-Match: * k obejití kontroly ETag.

Šablony ARM a Bicep

Následující šablony nasazují úplnou konfiguraci serveru MCP v jednom nasazení. Každá šablona předpokládá existující instanci služby API Management a používá tabulku parametrů, abyste mohli znovu použít stejný soubor napříč prostředími tak, že změníte pouze hodnoty parametrů.

Server MCP založený na rozhraní REST API

Tyto šablony vytvoří server MCP, definují jeden nástroj mapovaný na operaci v existujícím podkladovém rozhraní REST API, přiřadí zásadu omezení rychlosti na úrovni serveru a propojí server se stávajícím produktem. Všechny tyto úlohy můžete provádět v jednom nasazení.

Požadavky: existující služba API Management, rozhraní REST API (backingApiId) s alespoň jednou operací (backingOperationId) a existujícím produktem (productId).

Parameter Povinné Default Description
serviceName Ano — Název existující instance služby API Management
mcpServerId Ne orders-mcp Název prostředku pro nový server MCP Musí být v rámci služby jedinečný.
backingApiId Ano — Název prostředku existujícího rozhraní REST API, který zálohuje tento server MCP.
backingOperationId Ano — Název prostředku pro operaci, která se má zpřístupnit jako nástroj.
toolId Ne sampleTool Název prostředku a zobrazovaný název nástroje MCP, který se má vytvořit.
productId Ne starter Název zdroje existujícího produktu, ke kterému se má server přidružit. 
@description('Name of the existing API Management service instance.')
param serviceName string

@description('Resource name for the new MCP server.')
param mcpServerId string = 'orders-mcp'

@description('Resource name of the existing REST API that backs this MCP server.')
param backingApiId string

@description('Resource name of the operation in the backing REST API to expose as a tool.')
param backingOperationId string

@description('Resource name and display name of the MCP tool to create.')
param toolId string = 'sampleTool'

@description('Resource name of the existing product to bind the MCP server to.')
param productId string = 'starter'

resource apimService 'Microsoft.ApiManagement/service@2025-09-01-preview' existing = {
  name: serviceName
}

resource mcpServer 'Microsoft.ApiManagement/service/apis@2025-09-01-preview' = {
  parent: apimService
  name: mcpServerId
  properties: {
    type: 'mcp'
    displayName: 'Orders MCP Server'
    description: 'MCP server backed by the Orders REST API'
    path: mcpServerId
    protocols: [ 'https' ]
    subscriptionRequired: true
  }
}

resource mcpTool 'Microsoft.ApiManagement/service/apis/tools@2025-09-01-preview' = {
  parent: mcpServer
  name: toolId
  properties: {
    displayName: toolId
    description: 'MCP tool backed by an API operation'
    operationId: resourceId(
      'Microsoft.ApiManagement/service/apis/operations',
      serviceName, backingApiId, backingOperationId
    )
  }
}

resource mcpPolicy 'Microsoft.ApiManagement/service/apis/policies@2025-09-01-preview' = {
  parent: mcpServer
  name: 'policy'
  properties: {
    format: 'rawxml'
    value: '''<policies>
  <inbound>
    <base />
    <rate-limit calls="100" renewal-period="60" />
  </inbound>
  <backend>
    <forward-request />
  </backend>
  <outbound>
    <base />
  </outbound>
</policies>'''
  }
}

resource product 'Microsoft.ApiManagement/service/products@2025-09-01-preview' existing = {
  parent: apimService
  name: productId
}

resource productBinding 'Microsoft.ApiManagement/service/products/apis@2025-09-01-preview' = {
  parent: product
  name: mcpServerId
  dependsOn: [ mcpServer ]
}

Nasazení:

# Use orders-mcp.json if you're deploying the ARM template.
az deployment group create \
  --resource-group <resource-group> \
  --template-file orders-mcp.bicep \
  --parameters serviceName=<api-management-name> \
               backingApiId=orders-api \
               backingOperationId=get-orders \
               toolId=getOrders

Průchozí server MCP

Tyto šablony vytvoří předávací server MCP, který používá streamovatelný přenos HTTP. Obor serveru má zásadu omezení rychlosti a server se sváže s existujícím produktem. Šablony nedefinuje žádné dílčí prostředky nástroje. Externí back-end určuje plochu nástroje.

Note

Následující šablony používají transportType: streamable, který implementuje aktuální specifikaci pro streamovatelné HTTP v MCP. Chcete-li místo toho použít přenos SSE, nastavte transportType na sse a nahraďte pole endpoints dvěma položkami: { "name": "sse", "uriTemplate": "/sse" } a { "name": "message", "uriTemplate": "/messages" }. V Bicepu použijte stejné hodnoty s řetězci v jednoduchých uvozovkách.

Požadavky: existující služba API Management, dosažitelná adresa URL back-endu MCP (backendUrl), která implementuje vybrané cesty přenosu a koncového bodu a existující produkt (productId).

Parameter Povinné Default Description
serviceName Ano — Název existující instance služby API Management
mcpServerId Ne external-mcp Název prostředku pro nový server MCP Musí být v rámci služby jedinečný.
backendUrl Ano — Absolutní adresa URL externího back-endu MCP
productId Ne starter Název zdroje existujícího produktu, ke kterému se má server přidružit. 
@description('Name of the existing API Management service instance.')
param serviceName string

@description('Resource name for the new MCP server.')
param mcpServerId string = 'external-mcp'

@description('Absolute URL of the external MCP backend.')
param backendUrl string

@description('Resource name of the existing product to bind the MCP server to.')
param productId string = 'starter'

resource apimService 'Microsoft.ApiManagement/service@2025-09-01-preview' existing = {
  name: serviceName
}

resource mcpServer 'Microsoft.ApiManagement/service/apis@2025-09-01-preview' = {
  parent: apimService
  name: mcpServerId
  properties: {
    type: 'mcp'
    displayName: 'External MCP Server'
    description: 'Passthrough MCP server using streamable HTTP transport'
    path: mcpServerId
    protocols: [ 'https' ]
    serviceUrl: backendUrl
    subscriptionRequired: true
    mcpProperties: {
      transportType: 'streamable'
      endpoints: [
        {
          name: 'message'
          uriTemplate: '/mcp'
        }
      ]
    }
  }
}

resource mcpPolicy 'Microsoft.ApiManagement/service/apis/policies@2025-09-01-preview' = {
  parent: mcpServer
  name: 'policy'
  properties: {
    format: 'rawxml'
    value: '''<policies>
  <inbound>
    <base />
    <rate-limit calls="100" renewal-period="60" />
  </inbound>
  <backend>
    <forward-request />
  </backend>
  <outbound>
    <base />
  </outbound>
</policies>'''
  }
}

resource product 'Microsoft.ApiManagement/service/products@2025-09-01-preview' existing = {
  parent: apimService
  name: productId
}

resource productBinding 'Microsoft.ApiManagement/service/products/apis@2025-09-01-preview' = {
  parent: product
  name: mcpServerId
  dependsOn: [ mcpServer ]
}

Nasazení:

# Use external-mcp.json if you're deploying the ARM template.
az deployment group create \
  --resource-group <resource-group> \
  --template-file external-mcp.bicep \
  --parameters serviceName=<api-management-name> \
               backendUrl=https://mcp-backend.contoso.com

Azure CLI

V současné době můžete použít az rest k přímému volání REST API. Následující skript vytvoří předávací server MCP, připojí zásadu omezení rychlosti a vytvoří vazbu s produktem. Tento proces popisuje stejný scénář jako šablona Bicep v předchozí části.

Nastavte proměnné a pak spusťte čtyři az rest volání v pořadí.

Note

az rest používá přihlašovací údaje z vaší aktuální az login relace. Nepotřebujete samostatný krok ověřování.

# Variables. Edit these for your environment
SUBSCRIPTION_ID=$(az account show --query id -o tsv)
RESOURCE_GROUP="<your-resource-group>"
APIM_NAME="<your-apim-service-name>"
MCP_SERVER_ID="external-mcp"
BACKEND_URL="https://mcp-backend.contoso.com"
PRODUCT_ID="starter"
API_VERSION="2025-09-01-preview"

BASE="https://management.azure.com/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RESOURCE_GROUP}/providers/Microsoft.ApiManagement/service/${APIM_NAME}"

# 1. Create the passthrough MCP server

az rest --method PUT \
  --uri "${BASE}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}" \
  --headers "If-Match=*" \
  --body '{
    "properties": {
      "type": "mcp",
      "displayName": "External MCP Server",
      "description": "Passthrough MCP server using streamable HTTP transport",
      "path": "external-mcp",
      "protocols": ["https"],
      "serviceUrl": "'"${BACKEND_URL}"'",
      "subscriptionRequired": true,
      "mcpProperties": {
        "transportType": "streamable",
        "endpoints": [
          { "name": "message", "uriTemplate": "/mcp" }
        ]
      }
    }
  }'

# 2. Attach a rate-limit policy at the server scope

az rest --method PUT \
  --uri "${BASE}/apis/${MCP_SERVER_ID}/policies/policy?api-version=${API_VERSION}" \
  --headers "If-Match=*" \
  --body '{
    "properties": {
      "format": "rawxml",
      "value": "<policies><inbound><base /><rate-limit calls=\"100\" renewal-period=\"60\" /></inbound><backend><forward-request /></backend><outbound><base /></outbound></policies>"
    }
  }'


# 3. Bind the server to a product

az rest --method PUT \
  --uri "${BASE}/products/${PRODUCT_ID}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}"

Každý krok je idempotentní. Opětovné spuštění skriptu aktualizuje prostředek na místě. Pokud chcete ověřit vytvoření serveru, spusťte následující příkaz:

az rest --method GET \
  --uri "${BASE}/apis/${MCP_SERVER_ID}?api-version=${API_VERSION}"

Terraform

Poskytovatel AzureRM Terraform zatím nemá nativní prostředky pro servery MCP. V současné době můžete použít azapi_resource typ prostředku od poskytovatele AzAPI, který umožňuje spravovat jakýkoli typ prostředku Azure proti jakékoli verzi rozhraní API. Následující příklad odpovídá šabloně Bicep pro passthrough server MCP.

Požadavky: existující služba API Management, dosažitelná adresa URL back-endu MCP a existující produkt. Pokud tam poskytovatel AzAPI ještě není, přidejte ho do bloku terraform.

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = ">= 3.0"
    }
    azapi = {
      source  = "Azure/azapi"
      version = ">= 1.13"
    }
  }
}

provider "azurerm" {
  features {}
}

provider "azapi" {}

Proměnné

variable "resource_group_name" {
  description = "Name of the resource group containing the API Management service."
  type        = string
}

variable "service_name" {
  description = "Name of the existing API Management service instance."
  type        = string
}

variable "mcp_server_id" {
  description = "Resource name for the new MCP server."
  type        = string
  default     = "external-mcp"
}

variable "backend_url" {
  description = "Absolute URL of the external MCP backend."
  type        = string
}

variable "product_id" {
  description = "Resource name of the existing product to bind the server to."
  type        = string
  default     = "starter"
}

Resources

# Reference the existing API Management service
data "azurerm_api_management" "apim" {
  name                = var.service_name
  resource_group_name = var.resource_group_name
}

# 1. Create the passthrough MCP server
resource "azapi_resource" "mcp_server" {
  type      = "Microsoft.ApiManagement/service/apis@2025-09-01-preview"
  name      = var.mcp_server_id
  parent_id = data.azurerm_api_management.apim.id

  body = {
    properties = {
      type                = "mcp"
      displayName         = "External MCP Server"
      description         = "Passthrough MCP server using streamable HTTP transport"
      path                = var.mcp_server_id
      protocols           = ["https"]
      serviceUrl          = var.backend_url
      subscriptionRequired = true
      mcpProperties = {
        transportType = "streamable"
        endpoints = [
          {
            name        = "message"
            uriTemplate = "/mcp"
          }
        ]
      }
    }
  }
}

# 2. Attach a rate-limit policy at the server scope
resource "azapi_resource" "mcp_policy" {
  type      = "Microsoft.ApiManagement/service/apis/policies@2025-09-01-preview"
  name      = "policy"
  parent_id = azapi_resource.mcp_server.id

  body = {
    properties = {
      format = "rawxml"
      value  = "<policies><inbound><base /><rate-limit calls=\"100\" renewal-period=\"60\" /></inbound><backend><forward-request /></backend><outbound><base /></outbound></policies>"
    }
  }

  depends_on = [azapi_resource.mcp_server]
}

# 3. Bind the server to a product
resource "azapi_resource" "product_binding" {
  type      = "Microsoft.ApiManagement/service/products/apis@2025-09-01-preview"
  name      = var.mcp_server_id
  parent_id = "${data.azurerm_api_management.apim.id}/products/${var.product_id}"

  body = {}

  depends_on = [azapi_resource.mcp_server]
}

Nasazení:

Note

azapi_resourcepoužívá ověřování zprostředkovatele AzAPI, které čte ze stejných az login přihlašovacích údajů jako Azure CLI. Při místním spuštění nemusíte konfigurovat samostatné ověřování.

terraform init
terraform apply \
  -var="resource_group_name=<resource-group>" \
  -var="service_name=<api-management-name>" \
  -var="backend_url=https://mcp-backend.contoso.com"

Vzory CI/CD

  • Idempotentní upserts: Odesílejte požadavky PUT s If-Match: "*", aby se stejná šablona použila bez ohledu na to, zda prostředek existuje. 

  • Přesouvejte konfigurace mezi prostředími: S definicemi serveru MCP a seznamy nástrojů zacházejte jako s artefakty spravovanými ve zdrojovém kódu. Parametrizovat pouze hodnoty specifické pro prostředí, jako je název instance a adresa URL back-endu. 

  • Vygenerujte seznam nástrojů ze specifikace rozhraní API: Odvozujte podprostředek nástrojů ze zdrojového souboru OpenAPI, aby rozhraní nástrojů zůstalo synchronizované s podkladovým rozhraním API při jeho vývoji. 

  • Odstraňujte ve správném pořadí: Než odstraníte odkazy na nástroje MCP, odstraňte nejprve podkladová rozhraní API nebo operace, na které tyto odkazy odkazují. V opačném případě se odstranění nezdaří při kontrole cizího klíče. 

Související obsah

  • Last updated on