Codestin Search App

Este guia mostra como usar DefaultAzureCredential da biblioteca Azure Identity para autenticar com modelos Fábrica de IA do Azure por meio do SDK do Copilot.

Como funciona

O ponto de extremidade compatível com OpenAI do Microsoft Foundry aceita tokens de portador do Entra ID em vez de chaves de API estáticas. O padrão é:

Usar DefaultAzureCredential para obter um token no escopo https://cognitiveservices.azure.com/.default
Passe o token como bearer_token na configuração do provedor BYOK
Atualize o token antes de expirar (os tokens normalmente são válidos por aproximadamente 1 hora)

Diagrama: diagrama de sequência mostrando o processo descrito.

Exemplo de Python

Pré-requisitos

pip install github-copilot-sdk azure-identity

Uso Básico

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

Atualização de token para aplicativos de execução prolongada

Os tokens de portador expiram (normalmente após cerca de 1 hora). Para servidores ou agentes de execução longa, atualize o token antes de criar cada sessão:

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

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

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

Configuração do ambiente

Variable	Description	Example
`AZURE_AI_FOUNDRY_RESOURCE_URL`	Sua URL de recurso do Fábrica de IA do Azure	`https://myresource.openai.azure.com`

Nenhuma variável de ambiente de chave de API é necessária– a autenticação é tratada por DefaultAzureCredential, que dá suporte automaticamente a:

Managed Identity (atribuído pelo sistema ou atribuído pelo usuário): para aplicativos hospedados Azure
CLI do Azure (az login): para desenvolvimento local

          **Variáveis de ambiente** (`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`): para entidades de serviço

Identidade da carga de trabalho: para Kubernetes

Consulte a documentação do DefaultAzureCredential para obter a cadeia completa de credenciais.

Quando usar esse padrão

Scenario	Recomendação
Aplicativo hospedado no Azure com Identidade Gerenciada
✅ Usar esse padrão
App com serviço principal existente do Azure AD
✅ Usar esse padrão
Desenvolvimento local com `az login`
✅ Usar esse padrão
Ambiente não Azure com chave de API estática	Usar BYOK (Bring Your Own Key - traga sua própria chave)
GitHub Copilot assinatura disponível	Usar Configuração do OAuth do GitHub

Consulte também

BYOK (Bring Your Own Key - traga sua própria chave): Configuração de chave de API estática
Configuração de serviços de back-end: Implantação do lado do servidor
documentação do Azure Identity

Identidade gerenciada do Azure com BYOK

Neste artigo