Beheer modellen en hulpprogramma's in de AI Gateway-laag (preview)

VAN TOEPASSING OP: AI Gateway-laag (preview)

Gebruik AI Gateway-laag (preview) om de modellen en tools te beheren die applicaties en agenten aanroepen. Importeer modellen om één bestuurd eindpunt te bieden voor modelverzoeken. Voeg MCP-servers toe om goedgekeurde tools bloot te stellen via een beheerd Model Context Protocol (MCP)-eindpunt. Applicaties en agenten authenticeren zich bij de gateway met runtime access keys. De gateway gebruikt de backend-authenticatie die je configureert voor elke modelprovider of toolbackend.

Prerequisites

• Een exemplaar van een AI Gateway-laag.
• Toestemming om de AI Gateway tier-instantie te beheren.
• Toegang tot het providermodel of backend dat je wilt toevoegen.
• Voor managed identity backend-authenticatie is er toestemming om de vereiste rol toe te wijzen op de backend-resource.

Modellen importeren

Gebruik de Add Models wizard om AI Gateway-tier te verbinden met Microsoft Foundry, Azure OpenAI, AWS Bedrock, Google Vertex, OpenAI, Anthropic of aangepaste endpoints. De gateway biedt elk model aan via de eindpunten die door de backend ervan worden ondersteund, onder het prefix https://<gateway>.azure-api.net/default/models. Het volgende padsegment is het provider-API-formaat. Zo worden OpenAI-compatibele modellen bediend bij .../default/models/openai/v1 (zoals /chat/completions en /responses), en Anthropic modellen bij .../default/models/anthropic/v1/messages. De verbindingsvelden die de wizard nodig heeft, verschillen per provider.

Kies Importeren vanuit Foundry wanneer je model draait in een Microsoft Foundry-resource, die Azure OpenAI- en Azure AI Services-implementaties omvat — de wizard ontdekt automatisch de implementaties van de resource. Kies Voeg een aangepast model toe voor AWS Bedrock, Google Vertex, OpenAI, Anthropic of een ander ondersteund endpoint, waarbij je zelf de endpoint- en modelnamen invoert.

Gebruik beheerde identiteit wanneer de provider Microsoft Entra ID backend-authenticatie ondersteunt, zoals Microsoft Foundry. Verleen de gateway-identiteit de vereiste rol op de backend-resource vóór import. Anders kun je tijdens de import de API-sleutel of het geheim van de provider opgeven. De gateway slaat het inloggegevens op en beschermt het.

Aanroepers verwijzen naar het model met de modelnaam in het model veld:

{
  "model": "gpt-5.6-sol",
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ]
}

De model waarde is de modelnaam die door het geïmporteerde model wordt gegeven.

Om modellen toe te voegen, open je de pagina Modellen en selecteer je Modellen toevoegen. Kies hoe je wilt verbinden.

Import van Microsoft Foundry

1. Selecteer Importeren uit Foundry.
2. Kies bij Select resource het abonnement en de Foundry resource. De wizard vermeldt de modelimplementaties in die bron.
3. Op Provider-gegevens voert u een providernaam en weergavenaam in, voegt u een optionele beschrijving toe en kiest u de authenticatiemethode - Beheerde identiteit (aanbevolen, indien beschikbaar) of Key-based.
4. Klik op Creëren. De gateway importeert de implementaties van de resource als modellen die bellers op naam aanvragen.

Een aangepast model toevoegen

1. Selecteer Een aangepast model toevoegen.
2. Voer in Provider een weergavenaam en provider in, en een optionele beschrijving.
3. Op Endpoint voer je de basis-endpoint-URL, de naam van de authenticatieheader (bijvoorbeeld Authorization), en de API-sleutel in.
4. Op Modellen voer je elke modelnaam in en selecteer je de ondersteunde eindpunten - OpenAI-chatvoltooiingen, OpenAI-antwoorden, Anthropic-berichten of Overig. Selecteer model toevoegen voor elk model dat je definieert.
5. Klik op Creëren.

Er is geen aparte validatiestap. De gateway zet de verbinding op wanneer je de provider aanmaakt. Nadat je een model hebt toegevoegd, kun je de authenticatie of het beleid bijwerken, of het verwijderen als het niet meer nodig is.

Nadat het model is toegevoegd, stuur je een testverzoek via het gateway-eindpunt:

curl "https://<gateway>.azure-api.net/default/models/openai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "api-key: <runtime-access-key>" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      { "role": "user", "content": "Write a one-sentence status update." }
    ]
  }'

Als je nog geen runtime access key hebt gemaakt, maak er dan een aan vanaf de Keys-pagina . Applicaties hebben geen directe provider-inloggegevens nodig. Gebruik monitoringweergaven om het aanvraagvolume, latentie, tokengebruik en fouten op modelnaam te bekijken.

Anthropic Messages API passthrough

Verschillende providers maken verschillende API-formaten beschikbaar, en de gateway bedient elk op zijn eigen pad onder /default/models. Anthropic-modellen gebruiken de Anthropic Messages API in passthrough-modus: de gateway bewaart het native Anthropic Messages-verzoek- en responsformaat en stuurt aanroepen door naar Anthropic op /default/models/anthropic/v1/messages. Gebruik het wanneer applicaties al de Anthropic SDK gebruiken of /v1/messages.

Om een Anthropic model toe te voegen, gebruik je Add models> Voegeen aangepast model toe:

1. Voer op Provider een weergavenaam en providernaam in voor Anthropic.
2. Op Endpoint zet je de basis-endpoint-URL op https://api.anthropic.com, zet de naam van de authenticatieheader op x-api-key, en voer de Anthropic API-sleutel in. De gateway slaat de sleutel op en injecteert deze in backend-aanroepen.
3. Bij Models voer je de naam in van het Anthropic-model dat callers verzenden (zoals claude-fable-5) en selecteer je het eindpunt Anthropic messages.
4. Klik op Creëren. De gateway verzorgt de doorgifte van Anthropic Messages via /default/models/anthropic/v1/messages.

Clients roepen het pad van de gateway aan. De gateway slaat het inloggegevens op, injecteert de backend x-api-keyen stuurt de anthropic-version header van de beller door naar Anthropic.

curl -X POST "https://<gateway>.azure-api.net/default/models/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -H "api-key: <runtime-access-key>" \
  -d '{"model":"claude-fable-5","max_tokens":256,"messages":[{"role":"user","content":"Write a product description for a trail running backpack."}]}'

De Anthropic Python SDK werkt wanneer je naar het gatewaypad wijstbase_url. Standaard verzendt de standaard-SDK de referenties in de header x-api-key, dus geef de gateway runtime access key door in de header api-key met default_headers. De api_key="unused" waarde voldoet alleen aan het vereiste argument van de SDK; de gateway negeert dit en injecteert de opgeslagen backend Anthropic key. Stel model in op de modelnaam van Anthropic.

from anthropic import Anthropic

client = Anthropic(api_key="unused", base_url="https://<gateway>.azure-api.net/default/models/anthropic", default_headers={"api-key": "<runtime-access-key>"})
message = client.messages.create(model="claude-fable-5", max_tokens=256, messages=[{"role":"user","content":"Hello"}])
print(message.content[0].text)

Valideer time-outs en responsafhandeling vóór productie, vooral als beleid lichamen inspecteert.

MCP-servers toevoegen

De AI Gateway-laag stelt platformteams in staat om MCP-servers achter één beheerd MCP-eindpunt te publiceren. De configuratieworkflow is: maak een MCP-server, koppel één of meer backends aan en stel geselecteerde backendmogelijkheden bloot als tools. Een enkele MCP-server kan drie soorten backends combineren: externe MCP-servers (via URL), tools gegenereerd vanuit een OpenAPI-specificatie, en ingebouwde connectors voor gangbare SaaS-apps (meer dan 1.000 vooraf gebouwde integraties, zonder server om te hosten).

Gebruik MCP-servers wanneer agenten bedrijfssystemen, ontwikkelaarstools, kennisopslag of interne API's moeten aanroepen. Agenten authenticeren zich één keer bij de gateway en hebben geen aparte inloggegevens nodig voor elke backend. Voor elke backend kies je hoe de gateway zich ermee authenticeert: None, API Key, OAuth 2.0 of Managed identity.

Een enkele MCP-server federeert één of meer backends. Elke backend levert tools aan, en de gateway voorziet de tools van elke backend van een naamruimte met de naam van de backend, zodat tools met dezelfde naam uit verschillende backends niet met elkaar in conflict komen. Bijvoorbeeld, een create_issue tool van een backend met de naam github wordt blootgesteld aan agenten onder de github namespace, anders dan een create_issue tool op een andere backend.

Elke bron draagt op een andere manier bij met tools:

• MCP-server — federeert de tools van een externe MCP-endpoint die je al host.
• OpenAPI-specificatie — zet de door jou geselecteerde API-operaties om in tools; De samenvatting of beschrijving van de operatie wordt de toolbeschrijving.
• Ingebouwde connector — gebruikt een beheerde verbinding met een SaaS-app zoals Office 365, SharePoint, GitHub of Salesforce. OAuth-connectoren vragen om toestemming wanneer je de verbinding opzet.

Om een MCP-server te maken:

1. Selecteer in het AI Gateway-tierportaal MCP-servers.
2. Selecteer MCP-server toevoegen.
3. Kies bij Source een backendtype om mee te beginnen: MCP-server, OpenAPI-specificatie of ingebouwde connector. Je kunt daarna meer backends toevoegen.
4. Geef de backend een unieke naam. De gateway voorziet de tools van die backend in de gecombineerde MCP-server van een voorvoegsel met die naam.
5. Configureer de backend en kies hoe de gateway zich daarop authenticeert: None, API Key, OAuth 2.0 of Managed identity. Voor API Key voer je de naam en waarde van de header in; waarden worden in rust versleuteld.
6. Om meer services achter hetzelfde eindpunt te federeren, voeg je een extra backend toe en herhaal je dit.
7. Selecteer Bevestigen en vervolgens Aanmaken.

Er is geen aparte connectiviteitsteststap. De gateway zet elke backend op en controleert deze wanneer je de server aanmaakt.

De gateway creëert één MCP-eindpunt dat alle geselecteerde backends federeert. Clients roepen het bestuurde endpoint aan en authenticeren zich met een runtime toegangssleutel.

Agenten roepen de MCP-server aan:

https://<gateway>.azure-api.net/default/toolservers/<server-name>/mcp

Verstuur de runtime-toegangssleutel in de api-key header. Wijs elk MCP-compatibel client- of agentframework naar deze URL. Geef bijvoorbeeld de beschikbare tools op met een JSON-RPC tools/list verzoek:

curl "https://<gateway>.azure-api.net/default/toolservers/<server-name>/mcp" \
  -H "Content-Type: application/json" \
  -H "api-key: <runtime-access-key>" \
  -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list" }'

import requests

url = "https://<gateway>.azure-api.net/default/toolservers/<server-name>/mcp"
response = requests.post(
    url,
    headers={"api-key": "<runtime-access-key>", "Content-Type": "application/json"},
    json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"},
)
print(response.json())

Als een systeem een REST API heeft maar geen MCP-server, importeer dan de OpenAPI-beschrijving. Selecteer bewerkingen om als tools te exposeren, bewerk toolnamen en beschrijvingen, configureer een ondersteunde backend-authenticatiemethode en maak het MCP-asset aan. De gateway vertaalt toolaanroepen naar REST-operaties.

Gebruik de gateway voor MCP-servers om te centraliseren:

• Discovery — bied één catalogus van goedgekeurde MCP-servers aan voor ontwikkelaars en agenten.
• Authenticatie — clients authenticeren zich bij de gateway. De gateway slaat backend-inloggegevens op, dus clientconfiguratie bevat geen upstream-geheimen.
• Toolblootstelling — kies welke backend-operaties elke server als tools publiceert. In de preview kan elke runtime-toegangssleutel alle gepubliceerde assets in de gateway oproepen.
• Observability — de gateway zendt OpenTelemetry (OTLP) tokengebruiksmetrics uit voor modelverkeer, die je kunt sturen naar Application Insights of een andere OTLP-bestemming. MCP-toolverkeersmonitoring (verzoekvolume, latentie en fouten) is beschikbaar in het portaal wanneer je Application Insights gebruikt; OpenTelemetry (OTLP) export voor MCP-toolverkeer is nog niet beschikbaar.
• Governance — pas dezelfde beleidsregels toe op MCP-verkeer als je gebruikt voor modellen, zoals rate-limits en contentveiligheid.

Nadat je de server hebt gemaakt, configureer je runtime-toegang voordat je deze deelt. Voeg beleidsregels toe zoals contentveiligheid, IP-filters en limieten voor tokens en verzoeken, beperkt tot de gateway of specifieke gepubliceerde assets.

Verwante onderwerpen

• Overzicht van AI Gateway-tiers
• Quickstart: Maak een AI Gateway-tier instantie aan
• AI-gateway-niveau beheren, beveiligen en exploiteren
• Privénetwerken configureren