Identidad administrada de Azure con BYOK

En esta guía se muestra cómo usar la API del DefaultAzureCredential SDK de Azure Identity para autenticarse con modelos de Microsoft Foundry a través del SDK de Copilot.

Cómo funciona

El punto de conexión de Microsoft Foundry compatible con OpenAI acepta tokens de portador de Microsoft Entra ID en lugar de claves de API estáticas. El patrón es:

1. Uso DefaultAzureCredential para obtener un token para el https://ai.azure.com/.default ámbito
2. Pase el token como bearer_token en la configuración del proveedor BYOK
3. Actualice el token antes de que expire (los tokens suelen ser válidos durante aproximadamente 1 hora)

Ejemplos de código

Prerequisites

Instale los paquetes Azure Identity y Copilot SDK para el idioma:

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

Uso básico

Obtenga un token mediante DefaultAzureCredential y páselo como token de portador en la configuración del proveedor:

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();

Actualización de tokens para aplicaciones de ejecución prolongada

Los tokens de portador expiran (normalmente después de aproximadamente 1 hora). En el caso de los servidores o agentes de ejecución prolongada, actualice el token antes de crear cada sesión. En el ejemplo de Python siguiente se muestra este patrón:

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 ""

Configuración de entorno

No se necesita ninguna variable de entorno de clave de API: la autenticación se controla mediante DefaultAzureCredential, que admite automáticamente:

• Managed Identity (asignada por el sistema o asignada por el usuario): para aplicaciones hospedadas Azure
• CLI de Azure (az login): para el desarrollo local
• Variables de entorno (AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET): para entidades de servicio
• Identidad de carga de trabajo: para Kubernetes

Consulte la documentación de DefaultAzureCredential para ver la cadena completa de credenciales:

• .NET
• Python
• TypeScript

Cuándo usar este patrón

Consulte también

• BYOK (traiga su propia clave): configuración de clave de API estática
• Configuración de servicios back-end: implementación del lado servidor
• Documentación de Azure Identity