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:

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

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

from copilot import CopilotClient

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

package main

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

func main() {
    // Default: uses logged-in user credentials
    client := copilot.NewClient(nil)
    _ = client
}

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

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

using GitHub.Copilot;

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

import com.github.copilot.sdk.CopilotClient;

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

Wann verwenden:

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

OAuth GitHub-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. Das Token über die Option gitHubToken an das SDK übergeben

SDK-Konfiguration:

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

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

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

package main

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

func main() {
    userAccessToken := "token"
    client := copilot.NewClient(&copilot.ClientOptions{
        GitHubToken:     userAccessToken,
        UseLoggedInUser: copilot.Bool(false),
    })
    _ = client
}

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

using GitHub.Copilot;

var userAccessToken = "token";
await using var client = new CopilotClient(new CopilotClientOptions
{
    GitHubToken = userAccessToken,
    UseLoggedInUser = false,
});

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 com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.json.*;

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

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

Umgebungsvariablen

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

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:

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

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

from copilot import CopilotClient

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

Wann verwenden:

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

BYOK (Bring Your Own Key)

BYOK ermöglicht Es Ihnen, Ihre eigenen API-Schlüssel von Modellanbietern wie Azure AI 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 Azure AI Foundry , OpenAI, Anthropic und OpenAI-kompatible Endpunkte

Ausführliche Informationen finden Sie im BYOK (bring your own key), einschließlich:

• Azure AI Foundry -Einrichtung
• 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-Konstruktor übergeben wird
2. HMAC-Taste - CAPI_HMAC_KEY oder COPILOT_HMAC_KEY Umgebungsvariablen
3. Direktes API-Token - GITHUB_COPILOT_API_TOKEN mit COPILOT_API_URL
4. Umgebungsvariablen-Token - COPILOT_GITHUB_TOKEN → GH_TOKEN → GITHUB_TOKEN
5. Gespeicherte OAuth-Anmeldeinformationen – Aus vorheriger copilot CLI-Anmeldung
6. GitHub CLI - gh auth Anmeldeinformationen

Deaktivieren der automatischen Anmeldung

Um zu verhindern, dass das SDK automatisch gespeicherte Anmeldeinformationen oder gh CLI-Authentifizierung verwendet, verwenden Sie die useLoggedInUser: false Option:

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

from copilot import CopilotClient

client = CopilotClient({
    "use_logged_in_user": False,
})

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

package main

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

func main() {
    client := copilot.NewClient(&copilot.ClientOptions{
        UseLoggedInUser: copilot.Bool(false),
    })
    _ = client
}

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

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

import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.json.*;

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

Nächste Schritte

• BYOK (bring your own key) – Erfahren Sie, wie Sie Ihre eigenen API-Schlüssel verwenden.
• Erstellen Sie Ihre erste Copilot-gestützte App – Erstellen Ihrer ersten Copilot-basierten App
• Using MCP servers with the GitHub Copilot SDK – Herstellen einer Verbindung mit externen Tools