управляемое удостоверение Azure с помощью BYOK

В этом руководстве показано, как использовать API пакета SDK Azure identity SDK для проверки подлинности с помощью моделей Microsoft Foundry с помощью пакета SDK GitHub Copilot. Большинство языков используетсяDefaultAzureCredential; Rust используется DeveloperToolsCredential локально и ManagedIdentityCredential в Azure.

Принцип работы

Microsoft конечная точка OpenAI, совместимая с OpenAI,https://<resource-name>.openai.azure.com/openai/v1/ принимает маркеры носителя из Microsoft Entra ID вместо статических ключей API. В этом руководстве используется обратный вызов поставщика маркеров, поэтому среда выполнения пакета SDK GitHub Copilot может запрашивать новые токены по запросу.

В качестве примера используется Python поток:

Настройте DefaultAzureCredential среду.
Передайте обратный вызов в bearer_token_provider конфигурации поставщика BYOK, которая используется DefaultAzureCredential для получения маркера для https://ai.azure.com/.default области.
Пусть пакет SDK GitHub Copilot запрашивает новые маркеры по запросу через этот обратный вызов.

Диаграмма: диаграмма последовательностей, показывающая описанный процесс.

Примеры кода

Необходимые условия

Установите пакеты SDK для удостоверений Azure и GitHub Copilot для вашего языка:

Языки кода navigation

.NET

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

go get github.com/github/copilot-sdk/go
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Java

<dependency>
    <groupId>com.github</groupId>
    <artifactId>copilot-sdk-java</artifactId>
    <version>${copilot.sdk.version}</version>
</dependency>

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>${azure.identity.version}</version>
</dependency>

Python

pip install github-copilot-sdk azure-identity

Rust

cargo add github-copilot-sdk azure_identity azure_core
cargo add tokio --features macros,rt-multi-thread

TypeScript

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

Использование обратного вызова поставщика маркеров

Используйте этот подход, если требуется, чтобы среда выполнения пакета SDK GitHub Copilot запрашивала новые маркеры по запросу через предоставленный обратный вызов. Пакет SDK для идентификации Azure обрабатывает кэширование маркеров и время обновления.

Ниже приведены реализации, относящиеся к языку:

Языки кода navigation

.NET

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

DefaultAzureCredential credential = new(
    DefaultAzureCredential.DefaultEnvironmentVariableName);
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}/openai/v1/",
        BearerTokenProvider = async _ =>
        {
            AccessToken token = await credential.GetTokenAsync(
                new TokenRequestContext(["https://ai.azure.com/.default"]));
            return token.Token;
        },
        WireApi = "responses",
    },
});

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

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    copilot "github.com/github/copilot-sdk/go"
)
func main() {
    opts := azidentity.DefaultAzureCredentialOptions{RequireAzureTokenCredentials: true}
    credential, err := azidentity.NewDefaultAzureCredential(&opts)
    if err != nil {
        log.Fatal(err)
    }

    getBearerToken := func(args copilot.ProviderTokenArgs) (string, error) {
        token, err := credential.GetToken(context.Background(), policy.TokenRequestOptions{
            Scopes: []string{"https://ai.azure.com/.default"},
        })
        if err != nil {
            return "", err
        }
        return token.Token, nil
    }

    client := copilot.NewClient(nil)
    if err := client.Start(context.Background()); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    foundryURL := os.Getenv("FOUNDRY_RESOURCE_URL")

    session, err := client.CreateSession(context.Background(), &copilot.SessionConfig{
        Model: "gpt-5.5",
        Provider: &copilot.ProviderConfig{
            Type:                "openai",
            BaseURL:             fmt.Sprintf("%s/openai/v1/", foundryURL),
            BearerTokenProvider: getBearerToken,
            WireAPI:             "responses",
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    defer session.Disconnect()

    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    response, err := session.SendAndWait(ctx, copilot.MessageOptions{
        Prompt: "Hello from Managed Identity!",
    })
    if err != nil {
        log.Fatal(err)
    }

    if response != nil {
        if data, ok := response.Data.(*copilot.AssistantMessageData); ok {
            fmt.Println(data.Content)
        }
    }
}

Java

import com.azure.core.credential.TokenRequestContext;
import com.azure.identity.AzureIdentityEnvVars;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.github.copilot.CopilotClient;
import com.github.copilot.generated.AssistantMessageEvent;
import com.github.copilot.rpc.BearerTokenProvider;
import com.github.copilot.rpc.MessageOptions;
import com.github.copilot.rpc.ProviderConfig;
import com.github.copilot.rpc.SessionConfig;

public class ManagedIdentityExample {
    public static void main(String[] args) throws Exception {
        var credential = new DefaultAzureCredentialBuilder()
                .requireEnvVars(AzureIdentityEnvVars.AZURE_TOKEN_CREDENTIALS)
                .build();
        BearerTokenProvider tokenProvider = providerArgs ->
            credential
                .getToken(new TokenRequestContext().addScopes("https://ai.azure.com/.default"))
                .map(accessToken -> accessToken.getToken())
                .toFuture();
        String foundryUrl = System.getenv("FOUNDRY_RESOURCE_URL");

        try (var client = new CopilotClient()) {
            client.start().get();

            var session = client.createSession(new SessionConfig()
                    .setModel("gpt-5.5")
                    .setProvider(new ProviderConfig()
                            .setType("openai")
                            .setBaseUrl(foundryUrl + "/openai/v1/")
                            .setBearerTokenProvider(tokenProvider)
                            .setWireApi("responses")))
                .get();

            AssistantMessageEvent response = session
                    .sendAndWait(new MessageOptions().setPrompt("Hello from Managed Identity!"))
                    .get();
            System.out.println(response.getData().content());

            session.disconnect().get();
        }
    }
}

Python

import asyncio
import os

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

async def main():
    credential = DefaultAzureCredential(require_envvar=True)
    async def get_bearer_token(_args) -> str:
        token = await credential.get_token("https://ai.azure.com/.default")
        return token.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_provider=get_bearer_token,
            wire_api="responses",
        ),
    )

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

    await client.stop()
    await credential.close()

asyncio.run(main())

Rust

use std::sync::Arc;

use azure_core::credentials::TokenCredential;
use azure_identity::{DeveloperToolsCredential, ManagedIdentityCredential};
use github_copilot_sdk::{BearerTokenError, Client, ClientOptions, MessageOptions, ProviderTokenArgs};
use github_copilot_sdk::types::{ProviderConfig, SessionConfig};

fn credential_for_environment() -> azure_core::Result<Arc<dyn TokenCredential>> {
    match std::env::var("AZURE_TOKEN_CREDENTIALS").as_deref() {
        Ok("ManagedIdentityCredential") => Ok(ManagedIdentityCredential::new(None)?),
        _ => Ok(DeveloperToolsCredential::new(None)?),
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let credential = credential_for_environment()?;
    let foundry_url = std::env::var("FOUNDRY_RESOURCE_URL")?;

    let get_bearer_token = {
        let credential = credential.clone();
        move |_args: ProviderTokenArgs| {
            let credential = credential.clone();
            async move {
                let token = credential
                    .get_token(&["https://ai.azure.com/.default"], None)
                    .await
                    .map_err(|err| BearerTokenError::message(err.to_string()))?;
                Ok(token.token.secret().to_string())
            }
        }
    };

    let mut provider = ProviderConfig::default();
    provider.provider_type = Some("openai".to_string());
    provider.base_url = format!("{}/openai/v1/", foundry_url.trim_end_matches('/'));
    provider.bearer_token_provider = Some(Arc::new(get_bearer_token));
    provider.wire_api = Some("responses".to_string());

    let mut config = SessionConfig::default();
    config.model = Some("gpt-5.5".to_string());
    config.provider = Some(provider);

    let client = Client::start(ClientOptions::default()).await?;
    let session = client.create_session(config).await?;

    session
        .send_and_wait(MessageOptions::new("Hello from Managed Identity!"))
        .await?;

    session.disconnect().await?;
    client.stop().await?;
    Ok(())
}

TypeScript

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

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

const client = new CopilotClient();

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

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

await client.stop();

Конфигурация среды

Переменная	Description	Пример
`AZURE_TOKEN_CREDENTIALS`	При запуске в Azure установите на `ManagedIdentityCredential`. При локальном запуске установите его либо `dev` на имя учетных `AzureCliCredential`данных инструмента разработчика, например .	`ManagedIdentityCredential`
`AZURE_CLIENT_ID`
Необязательное поле. При запуске в Azure задайте для этого идентификатор клиента управляемого удостоверения, назначаемого пользователем при использовании`ManagedIdentityCredential`. Если этот параметр не задан, Azure использует управляемое удостоверение, назначаемое системой.	`11111111-2222-3333-4444-555555555555`
`FOUNDRY_RESOURCE_URL`	Ваш URL ресурса Microsoft Foundry	`https://<my-resource>.openai.azure.com`

Переменная среды ключа API не требуется. Проверка подлинности обрабатывается учетными данными удостоверения Azure. В .NET, Go, Java, Python и TypeScript DefaultAzureCredential автоматически поддерживает следующее:

Управляемое удостоверение (назначаемое системой или назначаемое пользователем): для Azure размещенных приложений
Azure CLI (az login): для местного развития
Переменные среды (AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET): для принципов сервисов
Идентификация рабочей нагрузки: для Kubernetes

В .NET, Go, Java, Python и TypeScript ManagedIdentityCredential считываетсяAZURE_CLIENT_ID, чтобы выбрать управляемое удостоверение, назначаемое пользователем. Rust — это исключение из этого руководства.

В Rust используется DeveloperToolsCredential для локальной разработки и ManagedIdentityCredential выполнения в Azure. Сведения о других языках см. в DefaultAzureCredential документации по полной цепочке учетных данных:

Когда следует использовать этот шаблон

Scenario	Recommendation
Azure-хостируемое приложение с управляемой идентичностью
✅ Используйте этот шаблон
Приложение с существующим принципом сервиса Microsoft Entra
✅ Используйте этот шаблон
Местное развитие с `az login`
✅ Используйте этот шаблон
Не-Azure среда со статическим API-ключом	Используйте автозаголовок
Доступна подписка GitHub Copilot	Используйте автозаголовок

См. также

БЁК (принеси свой ключ): Статическая конфигурация ключа API
Настройка серверных сервисов: Развертывание на стороне сервера

управляемое удостоверение Azure с помощью BYOK

В этой статье

Языки кода navigation

Языки кода navigation