Identité gérée Azure avec BYOK

Ce guide montre comment utiliser l'API Azure DefaultAzureCredential Identity SDK pour s'authentifier auprès de Microsoft modèles Foundry via le SDK Copilot.

Fonctionnement

Le point de terminaison de Microsoft Foundry compatible avec OpenAI accepte les jetons porteurs de Microsoft Entra ID au lieu de clés API statiques. Le modèle est :

1. Utilisez DefaultAzureCredential pour obtenir un jeton pour la portée https://ai.azure.com/.default
2. Transmettez le jeton comme bearer_token dans la configuration du fournisseur BYOK
3. Actualisez le jeton avant d’expirer (les jetons sont généralement valides pendant environ 1 heure)

Exemples de code

Prerequisites

Installez les packages Azure Identity et Copilot SDK pour votre langue :

dotnet add package GitHub.Copilot.SDK
dotnet add package Azure.Core

pip install github-copilot-sdk azure-identity

npm install @github/copilot-sdk @azure/identity

Utilisation de base

Obtenez un jeton à l’aide DefaultAzureCredential et transmettez-le en tant que jeton du porteur dans la configuration de votre fournisseur :

using Azure.Core;
using Azure.Identity;
using GitHub.Copilot;

DefaultAzureCredential credential = new(
    DefaultAzureCredential.DefaultEnvironmentVariableName);
AccessToken token = await credential.GetTokenAsync(
    new TokenRequestContext(new[] { "https://ai.azure.com/.default" }));

await using CopilotClient client = new();
string? foundryUrl = Environment.GetEnvironmentVariable("FOUNDRY_RESOURCE_URL");

await using CopilotSession session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-5.5",
    Provider = new ProviderConfig
    {
        Type = "openai",
        BaseUrl = $"{foundryUrl!.TrimEnd('/')}/openai/v1/",
        BearerToken = token.Token,
        WireApi = "responses",
    },
});

AssistantMessageEvent? response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello from Managed Identity!" });
Console.WriteLine(response?.Data.Content);

import asyncio
import os

from azure.identity import DefaultAzureCredential
from copilot import CopilotClient
from copilot.session import PermissionHandler, ProviderConfig

SCOPE = "https://ai.azure.com/.default"

async def main():
    # Get a token using Managed Identity, Azure CLI, or other credential chain
    credential = DefaultAzureCredential(require_envvar=True)
    token = credential.get_token(SCOPE).token

    foundry_url = os.environ["FOUNDRY_RESOURCE_URL"]

    client = CopilotClient()
    await client.start()

    session = await client.create_session(
        on_permission_request=PermissionHandler.approve_all,
        model="gpt-5.5",
        provider=ProviderConfig(
            type="openai",
            base_url=f"{foundry_url.rstrip('/')}/openai/v1/",
            bearer_token=token,  # Short-lived bearer token
            wire_api="responses",
        ),
    )

    response = await session.send_and_wait("Hello from Managed Identity!")
    print(response.data.content)

    await client.stop()

asyncio.run(main())

import { DefaultAzureCredential } from "@azure/identity";
import { CopilotClient } from "@github/copilot-sdk";

const credential = new DefaultAzureCredential({
  requiredEnvVars: ["AZURE_TOKEN_CREDENTIALS"],
});
const tokenResponse = await credential.getToken(
  "https://ai.azure.com/.default"
);

const client = new CopilotClient();

const session = await client.createSession({
  model: "gpt-5.5",
  provider: {
    type: "openai",
    baseUrl: `${process.env.FOUNDRY_RESOURCE_URL}/openai/v1/`,
    bearerToken: tokenResponse.token,
    wireApi: "responses",
  },
});

const response = await session.sendAndWait({ prompt: "Hello!" });
console.log(response?.data.content);

await client.stop();

Renouvellement du jeton pour les applications à longue durée d'exécution

Les jetons du porteur expirent (généralement après environ 1 heure). Pour les serveurs ou les agents de longue exécution, actualisez le jeton avant de créer chaque session. L’exemple de Python suivant illustre ce modèle :

from azure.identity import DefaultAzureCredential
from copilot import CopilotClient
from copilot.session import PermissionHandler, ProviderConfig

SCOPE = "https://ai.azure.com/.default"

class ManagedIdentityCopilotAgent:
    """Copilot agent that refreshes Microsoft Entra tokens for Microsoft Foundry."""

    def __init__(self, foundry_url: str, model: str = "gpt-5.5"):
        self.foundry_url = foundry_url.rstrip("/")
        self.model = model
        self.credential = DefaultAzureCredential(require_envvar=True)
        self.client = CopilotClient()

    def _get_provider_config(self) -> ProviderConfig:
        """Build a ProviderConfig with a fresh bearer token."""
        token = self.credential.get_token(SCOPE).token
        return ProviderConfig(
            type="openai",
            base_url=f"{self.foundry_url}/openai/v1/",
            bearer_token=token,
            wire_api="responses",
        )

    async def chat(self, prompt: str) -> str:
        """Send a prompt and return the response text."""
        # Fresh token for each session
        session = await self.client.create_session(
            on_permission_request=PermissionHandler.approve_all,
            model=self.model,
            provider=self._get_provider_config(),
        )

        response = await session.send_and_wait(prompt)
        await session.disconnect()

        return response.data.content if response else ""

Configuration de l’environnement

Aucune variable d’environnement de clé API n’est nécessaire : l’authentification est gérée par DefaultAzureCredential, qui prend automatiquement en charge :

• ** Identité managée** (affectée par le système ou affectée par l’utilisateur) : pour les applications hébergées par Azure
• Azure CLI (az login) : pour le développement local
• Variables d’environnement (AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET) : pour les entités de service.
• Identité de la charge de travail : pour Kubernetes

Consultez la documentation DefaultAzureCredential sur la chaîne complète d’authentification :

• .NET
• Python
• TypeScript

Quand utiliser ce modèle

Voir aussi

• BYOK (apportez votre propre clé) : Configuration de la clé API statique
• Configuration des services principaux : Déploiement côté serveur
• Documentation relative aux identités Azure