Codestin Search App

Ce guide montre comment utiliser DefaultAzureCredential à partir de la bibliothèque Azure Identity pour s’authentifier auprès de modèles Azure AI Foundry via le kit SDK Copilot.

Fonctionnement

Le point de terminaison d'Azure AI Foundry compatible avec OpenAI accepte les jetons porteurs d’Entra ID à la place des clés API statiques. Le modèle est :

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

Diagramme : diagramme de séquence montrant le processus décrit.

exemple de Python

Prerequisites

pip install github-copilot-sdk azure-identity

Utilisation de base

import asyncio
import os

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

COGNITIVE_SERVICES_SCOPE = "https://cognitiveservices.azure.com/.default"

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

    foundry_url = os.environ["AZURE_AI_FOUNDRY_RESOURCE_URL"]

    client = CopilotClient()
    await client.start()

    session = await client.create_session(
        on_permission_request=PermissionHandler.approve_all,
        model="gpt-4.1",
        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())

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 durée, actualisez le jeton avant de créer chaque session :

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

COGNITIVE_SERVICES_SCOPE = "https://cognitiveservices.azure.com/.default"

class ManagedIdentityCopilotAgent:
    """Copilot agent that refreshes Entra ID tokens for Azure AI Foundry."""

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

    def _get_provider_config(self) -> ProviderConfig:
        """Build a ProviderConfig with a fresh bearer token."""
        token = self.credential.get_token(COGNITIVE_SERVICES_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 ""

exemple Node.js/TypeScript

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

const credential = new DefaultAzureCredential();
const tokenResponse = await credential.getToken(
  "https://cognitiveservices.azure.com/.default"
);

const client = new CopilotClient();

const session = await client.createSession({
  model: "gpt-4.1",
  provider: {
    type: "openai",
    baseUrl: `${process.env.AZURE_AI_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();

exemple de .NET

using Azure.Identity;
using GitHub.Copilot;

var credential = new DefaultAzureCredential();
var token = await credential.GetTokenAsync(
    new Azure.Core.TokenRequestContext(
        new[] { "https://cognitiveservices.azure.com/.default" }));

await using var client = new CopilotClient();
var foundryUrl = Environment.GetEnvironmentVariable("AZURE_AI_FOUNDRY_RESOURCE_URL");

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

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

Configuration de l’environnement

Variable	Description	Example
`AZURE_AI_FOUNDRY_RESOURCE_URL`	URL de votre ressource Azure AI Foundry	`https://myresource.openai.azure.com`

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 principaux de service
Identité de la charge de travail : pour Kubernetes

Consultez la documentation de DefaultAzureCredential pour la chaîne complète d’informations d’identification.

Quand utiliser ce modèle

Scénario	Recommandation
Application hébergée par Azure avec l’identité managée
✅ Utiliser ce modèle
Application avec un principal de service Azure AD existant
✅ Utiliser ce modèle
Développement local avec `az login`
✅ Utiliser ce modèle
Environnement non-Azure avec clé API statique	Utiliser BYOK (apportez votre propre clé)
abonnement GitHub Copilot disponible	Utiliser configuration de GitHub OAuth

Voir aussi

BYOK (apportez votre propre clé) : Configuration de la clé API statique
Configuration des services principaux : Déploiement côté serveur
documentation Azure Identity

Identité gérée Azure avec BYOK

Dans cet article