Authentication

Authentifizierungsmethoden

Angemeldeter GitHub-Benutzer

Dies ist die Standardauthentifizierungsmethode beim interaktiven Ausführen der Copilot CLI. Benutzer authentifizieren sich über GitHub OAuth-Gerätefluss, und das SDK verwendet ihre gespeicherten Anmeldeinformationen.

Funktionsweise:

1. Der Benutzer führt copilot CLI aus und meldet sich über GitHub OAuth an.
2. Anmeldeinformationen werden sicher im Systemschlüsselbund gespeichert.
3. SDK verwendet automatisch gespeicherte Anmeldeinformationen.

SDK-Konfiguration:

using GitHub.Copilot;

// Default: uses logged-in user credentials
await using CopilotClient client = new();

import copilot "github.com/github/copilot-sdk/go"

// Default: uses logged-in user credentials
client := copilot.NewClient(nil)

import com.github.copilot.CopilotClient;

// Default: uses logged-in user credentials
var client = new CopilotClient();
client.start().get();

from copilot import CopilotClient

# Default: uses logged-in user credentials
client = CopilotClient()
await client.start()

use github_copilot_sdk::{Client, ClientOptions};

// Default: uses logged-in user credentials
let client = Client::start(ClientOptions::default()).await?;

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

// Default: uses logged-in user credentials
const client = new CopilotClient();

Wann verwenden:

• Desktopanwendungen, in denen Benutzer direkt interagieren
• Entwicklungs- und Testumgebungen
• Jedes Szenario, in dem sich ein Benutzer interaktiv anmelden kann

GitHub OAuth-App

Verwenden Sie eine OAuth-GitHub-App, um Benutzer über Ihre Anwendung zu authentifizieren und ihre Anmeldeinformationen an das SDK zu übergeben. Auf diese Weise kann Ihre Anwendung Copilot API-Anforderungen im Namen von Benutzern vornehmen, die Ihre App autorisieren.

Funktionsweise:

1. Der Benutzer autorisiert Ihre OAuth-GitHub-App
2. Ihre App empfängt ein Benutzerzugriffstoken (gho_ oder ghu_ Präfix)
3. Übergeben des Tokens an das SDK über die Clientkonfiguration

SDK-Konfiguration:

using GitHub.Copilot;

await using var client = new CopilotClient(new CopilotClientOptions
{
    GitHubToken = userAccessToken,     // Token from OAuth flow
    UseLoggedInUser = false,           // Don't use stored CLI credentials
});

import copilot "github.com/github/copilot-sdk/go"

client := copilot.NewClient(&copilot.ClientOptions{
    GitHubToken:       userAccessToken,      // Token from OAuth flow
    UseLoggedInUser:   copilot.Bool(false),  // Don't use stored CLI credentials
})

import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient(new CopilotClientOptions()
    .setGitHubToken(userAccessToken)  // Token from OAuth flow
    .setUseLoggedInUser(false)        // Don't use stored CLI credentials
);
client.start().get();

from copilot import CopilotClient

client = CopilotClient({
    "github_token": user_access_token,  # Token from OAuth flow
    "use_logged_in_user": False,        # Don't use stored CLI credentials
})
await client.start()

use github_copilot_sdk::{Client, ClientOptions};

let client = Client::start(
    ClientOptions::default()
        .with_github_token(user_access_token)
        .with_use_logged_in_user(false),
).await?;

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

const client = new CopilotClient({
    gitHubToken: userAccessToken,  // Token from OAuth flow
    useLoggedInUser: false,        // Don't use stored CLI credentials
});

Unterstützte Tokentypen:

• gho_ – OAuth-Benutzerzugriffstoken
• ghu_ – GitHub App-Benutzerzugriffstoken
• github_pat_ – Feinkörnige persönliche Zugriffstoken

Nicht unterstützt:

• ghp_ - Klassische persönliche Zugriffstoken (veraltet)

Wann verwenden:

• Webanwendungen, in denen sich Benutzer über GitHub anmelden
• SaaS-Anwendungen, die auf Copilot aufbauen
• Jede Mehrbenutzeranwendung, in der Sie Anforderungen im Namen verschiedener Benutzer stellen müssen

Weitere Informationen findest du unter Einrichtung von GitHub OAuth.

Rotation sitzungsgebundener GitHub-Token

Konfigurieren Sie für Dienste und Integrationen für mehrere Benutzer für jede Sitzung einen Tokenanbieter, anstatt ein langlebiges Token zu speichern. Die Laufzeit ruft den Anbieter für den effektiven GitHub Host auf und identifiziert die Anforderung als initial oder refresh. Die Sitzungs-ID ist nur nicht vorhanden, wenn eine Cloudsitzung ihre ID noch nicht erhalten hat.

Gibt ein markiertes Tokenergebnis oder einen expliziten Abbruch zurück. Jedes Tokenergebnis muss folgendes enthalten expiresIn: die positive Anzahl der verbleibenden Sekunden, wenn der Rückruf abgeschlossen ist. GitHub-Tokens für die Produktion sind in der Regel acht Stunden gültig, daher ist 8 * 60 * 60 ein gängiger Wert. Legen Sie nicht sowohl das statische Token pro Sitzung als auch den Anbieter fest.

const session = await client.createSession({
    gitHubTokenProvider: async ({ host, sessionId, reason }) => {
        const token = await acquireGitHubToken({ host, sessionId, reason });
        return {
            kind: "token",
            accessToken: token.value,
            expiresIn: token.secondsRemaining,
        };
    },
});

async def provide_github_token(args):
    token = await acquire_github_token(
        host=args["host"],
        session_id=args["session_id"],
        reason=args["reason"],
    )
    return {
        "kind": "token",
        "accessToken": token.value,
        "expiresIn": token.seconds_remaining,
    }

session = await client.create_session(github_token_provider=provide_github_token)

session, err := client.CreateSession(ctx, &copilot.SessionConfig{
    GitHubTokenProvider: func(args copilot.GitHubTokenProviderArgs) (*copilot.GitHubTokenProviderResult, error) {
        token, secondsRemaining, err := acquireGitHubToken(args.Host, args.SessionID, args.Reason)
        if err != nil {
            return nil, err
        }
        return copilot.GitHubTokenResult(&copilot.GitHubToken{
            AccessToken: token,
            ExpiresIn:   secondsRemaining,
        }), nil
    },
})

await using var session = await client.CreateSessionAsync(new SessionConfig
{
    GitHubTokenProvider = async args =>
    {
        var token = await AcquireGitHubTokenAsync(args.Host, args.SessionId, args.Reason);
        return GitHubTokenProviderResult.FromToken(new GitHubToken
        {
            AccessToken = token.Value,
            ExpiresIn = token.SecondsRemaining,
        });
    },
});

var session = client.createSession(new SessionConfig()
    .setGitHubTokenProvider(args ->
        acquireGitHubToken(args.host(), args.sessionId(), args.reason())
            .thenApply(token -> GitHubTokenProviderResult.token(
                token.value(), token.secondsRemaining())))
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

let provider = Arc::new(|args: GitHubTokenProviderArgs| async move {
    let token = acquire_github_token(&args.host, args.session_id.as_ref(), args.reason).await?;
    Ok(GitHubTokenProviderResult::Token(GitHubToken::new(
        token.value,
        token.seconds_remaining,
    )))
});

let session = client
    .create_session(SessionConfig::default().with_github_token_provider(provider))
    .await?;

Die Laufzeit nimmt den initial Abruf als Teil der Sitzungserstellung oder -fortsetzung vor. Ein abgebrochener Kauf, Anbieterfehler, ungültige Antwort oder Token ohne stabile Kontoidentität lehnt den Erstellungs- oder Fortsetzungsvorgang ab. Die Laufzeit fällt nicht auf die Umgebungsauthentifizierung zurück.

Nachdem die Sitzung hergestellt wurde, führt die Laufzeit vor jedem Vorgang, bei dem Anmeldeinformationen verwendet werden, eine asynchrone Vorabprüfung durch. Es fordert ein refresh an, wenn das aktuelle Token noch eine Stunde oder weniger gültig ist. Inaktive Sitzungen werden erst dann aktualisiert, wenn der nächste Vorgang erfolgt, der Anmeldeinformationen verwendet. Die Laufzeit verwendet keine Hintergrundtimer, ablehnungsgesteuerte Wiedergabe, 401/403-Abfrageverteilung oder UpScope für diesen Rückruf.

Umgebungsvariablen

Für Automatisierungs-, CI/CD-Pipelines und Server-zu-Server-Szenarien können Sie sich mithilfe von Umgebungsvariablen authentifizieren.

Informationen zur vom Unternehmen zugewiesenen Automatisierung, die das persönliche Zugriffstoken eines Benutzers nicht verwenden sollte, finden Sie unter Server-zu-Server-Authentifizierung.

Unterstützte Umgebungsvariablen (in Prioritätsreihenfolge):

1. COPILOT_GITHUB_TOKEN – Empfohlen für explizite Copilot Nutzung
2. GH_TOKEN - GitHub CLI kompatibel
3. GITHUB_TOKEN - GitHub Actions kompatibel

Funktionsweise:

1. Festlegen einer der unterstützten Umgebungsvariablen mit einem gültigen Token
2. Das SDK erkennt und verwendet das Token automatisch.

SDK-Konfiguration:

Es sind keine Codeänderungen erforderlich. Das SDK erkennt automatisch Umgebungsvariablen:

using GitHub.Copilot;

// Token is read from environment variable automatically
await using CopilotClient client = new();

import copilot "github.com/github/copilot-sdk/go"

// Token is read from environment variable automatically
client := copilot.NewClient(nil)

import com.github.copilot.CopilotClient;

// Token is read from environment variable automatically
var client = new CopilotClient();
client.start().get();

from copilot import CopilotClient

# Token is read from environment variable automatically
client = CopilotClient()
await client.start()

use github_copilot_sdk::{Client, ClientOptions};

// Token is read from environment variable automatically
let client = Client::start(ClientOptions::default()).await?;

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

// Token is read from environment variable automatically
const client = new CopilotClient();

Wann verwenden:

• CI/CD-Pipelines (GitHub Actions, Jenkins und mehr)
• Automatisiertes Testen
• Serverseitige Anwendungen mit Dienstkonten
• Entwicklung, wenn Sie die interaktive Anmeldung nicht verwenden möchten

Bring Your Own Key (BYOK)

BYOK ermöglicht es Ihnen, Ihre eigenen API-Schlüssel von Modellanbietern wie Microsoft Foundry, OpenAI oder Anthropic zu verwenden. Dadurch wird GitHub Copilot Authentifizierung vollständig umgangen.

Wichtige Vorteile:

• Kein GitHub Copilot Abonnement erforderlich
• Verwenden von Enterprise-Modellbereitstellungen
• Direkte Abrechnung mit Ihrem Modellanbieter
• Unterstützung für Microsoft Foundry-, OpenAI-, Anthropic- und OpenAI-kompatible Endpunkte

Ausführliche Informationen finden Sie im Bring Your Own Key (BYOK), einschließlich:

• Setup von Microsoft Foundry
• Anbieterkonfigurationsoptionen
• Einschränkungen und Überlegungen
• Vollständige Codebeispiele

Authentifizierungspriorität

Wenn mehrere Authentifizierungsmethoden verfügbar sind, verwendet das SDK sie in dieser Prioritätsreihenfolge:

1. Explizit gitHubToken – Token, das direkt an den SDK-Client oder die Sitzungskonfiguration übergeben wird
2. Direktes API-Token - GITHUB_COPILOT_API_TOKEN mit COPILOT_API_URL
3. Umgebungsvariablen-Token - COPILOT_GITHUB_TOKEN → GH_TOKEN → GITHUB_TOKEN
4. Gespeicherte OAuth-Anmeldeinformationen – Aus vorheriger copilot CLI-Anmeldung
5. GitHub CLI - gh auth Anmeldeinformationen

Übergeben Sie für den Mehrbenutzer-Servermodus für jede Sitzung ein eigenes gitHubToken, damit jede Sitzung unter der richtigen GitHub-Identität ausgeführt wird; siehe Mandantenfähigkeit und Serverbereitstellungen.

Deaktivieren der automatischen Anmeldung

Um zu verhindern, dass das SDK automatisch gespeicherte Anmeldeinformationen oder gh CLI-Authentifizierung verwendet, konfigurieren Sie es so, dass der Fallback des angemeldeten Benutzers deaktiviert wird:

await using var client = new CopilotClient(new CopilotClientOptions
{
    UseLoggedInUser = false,  // Only use explicit tokens
});

client := copilot.NewClient(&copilot.ClientOptions{
    UseLoggedInUser: copilot.Bool(false),  // Only use explicit tokens
})

import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient(new CopilotClientOptions()
    .setUseLoggedInUser(false)  // Only use explicit tokens
);
client.start().get();

client = CopilotClient({
    "use_logged_in_user": False,  # Only use explicit tokens
})

use github_copilot_sdk::{Client, ClientOptions};

let client = Client::start(
    ClientOptions::default().with_use_logged_in_user(false),
).await?;

const client = new CopilotClient({
    useLoggedInUser: false,  // Only use explicit tokens
});

Nächste Schritte

• Bring Your Own Key (BYOK) – Erfahren Sie, wie Sie Ihre eigenen API-Schlüssel verwenden.
• Build your first Copilot-powered app – Erstellen Ihrer ersten Copilot-basierten App
• Verwenden von MCP-Servern mit dem GitHub Copilot SDK – Herstellen einer Verbindung mit externen Tools