# Azure verwaltete Identität mit BYOK

Das Bring Your Own Key (BYOK) des GitHub Copilot SDK unterstützt statische API-Schlüssel, aber Azure Bereitstellungen verwenden häufig verwaltete Identität (Microsoft Entra ID) anstelle von langlebigen Schlüsseln. Das GitHub Copilot-SDK ist so konzipiert, dass es für maximale Flexibilität mit dem Azure Identity-SDK zusammenarbeitet. Stellen Sie einen Bearertokenanbieterrückruf bereit, der frische Token bei Bedarf mithilfe einer Azure Identity SDK-API abrufen kann.

<!-- markdownlint-disable GHD046 GHD005 -->

<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->

In diesem Handbuch wird gezeigt, wie Sie Azure Identity SDK-APIs zum Authentifizieren mit Microsoft Foundry-Modellen über das GitHub Copilot SDK verwenden. Die meisten Sprachen verwenden `DefaultAzureCredential`; Rost verwendet `DeveloperToolsCredential` lokal und `ManagedIdentityCredential` in Azure.

## So funktioniert es

Der OpenAI-kompatible Endpunkt von Microsoft Foundry (`https://<resource-name>.openai.azure.com/openai/v1/`) akzeptiert Bearer-Token von Microsoft Entra ID anstelle statischer API-Schlüssel. In diesem Handbuch wird ein Tokenanbieterrückruf verwendet, sodass die GitHub Copilot SDK-Laufzeit frische Token bei Bedarf anfordern kann.

Am Beispiel von Python ergibt sich folgender Ablauf:

1. Konfigurieren Sie `DefaultAzureCredential` für Ihre Umgebung.
2. Übergeben Sie in `bearer_token_provider` der BYOK-Anbieterkonfiguration einen Callback, der `DefaultAzureCredential` verwendet, um ein Token für den Scope `https://ai.azure.com/.default` abzurufen.
3. Lassen Sie das GitHub Copilot SDK bei Bedarf über diesen Callback neue Tokens anfordern.

![Diagramm: Sequenzdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/setup-azure-managed-identity-diagram-0.png)

## Codebeispiele

### Voraussetzungen

Installieren Sie die Azure Identity- und GitHub Copilot SDK-Pakete für Ihre Sprache:

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

<!-- docs-validate: skip -->

```xml
<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>
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

<!-- docs-validate: skip -->

```bash
pip install github-copilot-sdk azure-identity
```

</div>

<div class="ghd-codetab" data-lang="rust" data-label="Rust"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Rust</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

<!-- docs-validate: skip -->

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

</div>

</div>

### Verwenden Sie die Rückruffunktion eines Tokenanbieters

Verwenden Sie diesen Ansatz, wenn die GitHub Copilot SDK-Laufzeit frische Token bei Bedarf über einen von Ihnen bereitgestellten Rückruf anfordern soll. Das Azure Identity SDK übernimmt die Zwischenspeicherung von Token und die Aktualisierungszeitpunkte.

Hier sind sprachspezifische Implementierungen:

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

<!-- docs-validate: skip -->

```csharp
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);
```

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

<!-- docs-validate: skip -->

```golang
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)
        }
    }
}
```

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="rust" data-label="Rust"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Rust</div>

<!-- docs-validate: skip -->

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

</div>

<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

<!-- docs-validate: skip -->

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

</div>

</div>

## Umgebungskonfiguration

| Variable                                                                                                                                                                                                                                                                          | Description                                                                                                                                                                                                                                        | Example                                  |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
| `AZURE_TOKEN_CREDENTIALS`                                                                                                                                                                                                                                                         | Wenn sie in **Azure** ausgeführt wird, legen Sie sie auf `ManagedIdentityCredential`. Wenn es **lokal** ausgeführt wird, setzen Sie es entweder auf `dev` oder auf den Anmeldeinformationsnamen eines Entwicklertools, z. B. `AzureCliCredential`. | `ManagedIdentityCredential`              |
| `AZURE_CLIENT_ID`                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                    |                                          |
| *Optional.* Wenn sie in **Azure** ausgeführt wird, legen Sie dies auf die Client-ID einer vom Benutzer zugewiesenen verwalteten Identität bei Verwendung `ManagedIdentityCredential`fest. Wenn nicht festgelegt, verwendet Azure die vom System zugewiesene verwaltete Identität. | `11111111-2222-3333-4444-555555555555`                                                                                                                                                                                                             |                                          |
| `FOUNDRY_RESOURCE_URL`                                                                                                                                                                                                                                                            | URL Ihrer Microsoft Foundry-Ressource                                                                                                                                                                                                              | `https://<my-resource>.openai.azure.com` |

Es ist keine API-Schlüsselumgebungsvariable erforderlich – die Authentifizierung wird von Azure Identitätsanmeldeinformationen behandelt. In .NET unterstützt Go, Java, Python und TypeScript `DefaultAzureCredential` automatisch Folgendes:

* **Verwaltete Identität** (vom System zugewiesen oder vom Benutzer zugewiesen): für Azure gehostete Apps
* **Azure CLI** (`az login`): für die lokale Entwicklung
* **Umgebungsvariablen** (`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`): für Dienstprinzipale
* **Workload-Identität**: für Kubernetes

In .NET, Go, Java, Python und TypeScript liest `ManagedIdentityCredential``AZURE_CLIENT_ID`, um eine benutzerzugewiesene verwaltete Identität auszuwählen. Rost ist eine Ausnahme in dieser Anleitung.

Verwenden Sie `DeveloperToolsCredential` in Rust für die lokale Entwicklung und `ManagedIdentityCredential` bei der Ausführung in Azure. Für andere Sprachen finden Sie in der `DefaultAzureCredential` Dokumentation die vollständige Kette der Anmeldeinformationen:

* [.NET](https://aka.ms/azsdk/net/identity/credential-chains#defaultazurecredential-overview)
* [Go](https://aka.ms/azsdk/go/identity/credential-chains#defaultazurecredential-overview)
* [Java](https://aka.ms/azsdk/java/identity/credential-chains#defaultazurecredential-overview)
* [Python](https://aka.ms/azsdk/python/identity/credential-chains#defaultazurecredential-overview)
* [TypeScript](https://aka.ms/azsdk/js/identity/credential-chains#defaultazurecredential-overview)

## Wann dieses Muster verwenden

| Szenario                                                  | Recommendation                                                                                   |
| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| Von Azure gehostete App mit verwalteter Identität         |                                                                                                  |
| ✅ Verwenden Sie dieses Muster.                            |                                                                                                  |
| App mit einem vorhandenen Microsoft Entra-Dienstprinzipal |                                                                                                  |
| ✅ Verwenden Sie dieses Muster.                            |                                                                                                  |
| Lokale Entwicklung mit `az login`                         |                                                                                                  |
| ✅ Verwenden Sie dieses Muster.                            |                                                                                                  |
| Nicht-Azure-Umgebung mit statischem API-Schlüssel         | Verwenden von [Bring Your Own Key (BYOK)](/de/copilot/how-tos/copilot-sdk/auth/byok)             |
| GitHub Copilot Abonnement verfügbar                       | Verwenden von [Einrichtung von GitHub OAuth](/de/copilot/how-tos/copilot-sdk/setup/github-oauth) |

## Siehe auch

* [Bring Your Own Key (BYOK)](/de/copilot/how-tos/copilot-sdk/auth/byok): Konfiguration des statischen API-Schlüssels
* [Einrichtung von Back-End-Diensten](/de/copilot/how-tos/copilot-sdk/setup/backend-services): Serverseitige Bereitstellung