Utilisation d’Azure Managed Identity avec le Kit de développement logiciel (SDK) Copilot

Remarque

          Kit de développement logiciel (SDK) Copilot est actuellement en préversion technique. Les fonctionnalités et la disponibilité sont susceptibles de changer.

Étant donné que les déploiements Azure utilisent souvent l’identité managée (ID Entra) au lieu de clés de longue durée, vous devez effectuer des étapes supplémentaires pour utiliser le mode BYOK en Kit de développement logiciel (SDK) Copilot. Étant donné que le Kit de développement logiciel (SDK) ne prend pas en charge en mode natif l’authentification d’ID Entra, vous pouvez utiliser un jeton de porteur de courte durée via le champ de jeton du porteur de la configuration du fournisseur (bearer_token en Python, bearerToken dans Node.js/TypeScript et .NET).

Ce guide montre comment utiliser DefaultAzureCredential à partir de la bibliothèque Azure Identity pour s’authentifier auprès des modèles Azure AI Foundry via Kit de développement logiciel (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 l’étendue https://cognitiveservices.azure.com/.default.
Transmettez le jeton à l’aide du champ de jeton du porteur dans la configuration du fournisseur BYOK (bearer_token en Python, bearerToken dans Node.js/TypeScript et .NET).
Actualisez le jeton avant son expiration. Les jetons sont généralement valides pendant environ une heure.

Diagramme montrant le flux d’authentification pour Azure Managed Identity avec le Kit de développement logiciel (SDK) Copilot.

Prerequisites

Un abonnement Azure avec une ressource Azure AI Foundry déployée.
Bibliothèque Azure Identity installée (azure-identity pour Python, @azure/identity pour Node.jsou Azure.Identity pour .NET).

        Kit de développement logiciel (SDK) Copilot Installé. Pour plus d’informations, consultez « [AUTOTITLE](/copilot/how-tos/copilot-sdk/sdk-getting-started) ».

exemple de Python

Installer des dépendances

pip install github-copilot-sdk azure-identity

Utilisation de base

import asyncio
import os

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

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={
            "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({"prompt": "Hello from Managed Identity!"})
    print(response.data.content)

    await client.stop()

asyncio.run(main())

Remplacez AZURE_AI_FOUNDRY_RESOURCE_URL par la variable d’environnement contenant votre URL de ressource Azure AI Foundry (par exemple). https://myresource.openai.azure.com

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

Les jetons du porteur expirent après environ une 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, PermissionHandler

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) -> dict:
        """Build a provider config dict with a fresh bearer token."""
        token = self.credential.get_token(COGNITIVE_SERVICES_SCOPE).token
        return {
            "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
        provider = self._get_provider_config()
        session = await self.client.create_session(
            on_permission_request=PermissionHandler.approve_all,
            model=self.model,
            provider=provider,
        )

        response = await session.send_and_wait({"prompt": 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 .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

La variable d’environnement suivante est requise :

Variable	Description	Exemple
`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 entités de service.

        **Identité de charge de travail** pour Kubernetes.

Pour obtenir la chaîne d'identification complète, consultez la documentation DefaultAzureCredential.

Quand utiliser ce modèle

Scénario	Recommandation
Application hébergée par Azure avec l’identité managée	Utilisez ce modèle.
Application avec un principal de service Azure AD existant	Utilisez ce modèle.
Développement local avec `az login`	Utilisez ce modèle.
Environnement non-Azure avec clé API statique	Utilisez BYOK standard. Pour plus d’informations, consultez BYOK dans le `github/copilot-sdk` référentiel.

          GitHub Copilot abonnement disponible | Utilisez GitHub OAuth. Pour plus d’informations, consultez [GitHub OAuth](https://github.com/github/copilot-sdk/blob/main/docs/setup/github-oauth.md) dans le `github/copilot-sdk` référentiel. |

Lectures complémentaires

Pour obtenir la configuration de la clé API statique, consultez BYOK dans le github/copilot-sdk référentiel.
Pour le déploiement côté serveur, consultez Configuration du Kit de développement logiciel (SDK) Copilot pour les services principaux.
Pour la documentation de la bibliothèque Azure Identity, consultez l’aperçu de la bibliothèque cliente Azure Identity.