.NET
```csharp
using GitHub.Copilot;
// Default: uses logged-in user credentials
await using CopilotClient client = new();
```
Go
```golang
import copilot "github.com/github/copilot-sdk/go"
// Default: uses logged-in user credentials
client := copilot.NewClient(nil)
```
Java
```java
import com.github.copilot.CopilotClient;
// Default: uses logged-in user credentials
var client = new CopilotClient();
client.start().get();
```
Python
```python
from copilot import CopilotClient
# Default: uses logged-in user credentials
client = CopilotClient()
await client.start()
```
Rust
```rust
use github_copilot_sdk::{Client, ClientOptions};
// Default: uses logged-in user credentials
let client = Client::start(ClientOptions::default()).await?;
```
TypeScript
```typescript
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:**
.NET
```csharp
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
});
```
Go
```golang
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
})
```
Java
```java
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();
```
Python
```python
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()
```
Rust
```rust
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?;
```
TypeScript
```typescript
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](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/github-oauth).
## 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](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/server-to-server-tokens).
**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:
.NET
```csharp
using GitHub.Copilot;
// Token is read from environment variable automatically
await using CopilotClient client = new();
```
Go
```golang
import copilot "github.com/github/copilot-sdk/go"
// Token is read from environment variable automatically
client := copilot.NewClient(nil)
```
Java
```java
import com.github.copilot.CopilotClient;
// Token is read from environment variable automatically
var client = new CopilotClient();
client.start().get();
```
Python
```python
from copilot import CopilotClient
# Token is read from environment variable automatically
client = CopilotClient()
await client.start()
```
Rust
```rust
use github_copilot_sdk::{Client, ClientOptions};
// Token is read from environment variable automatically
let client = Client::start(ClientOptions::default()).await?;
```
TypeScript
```typescript
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)](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/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](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy).
## 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:
.NET
```csharp
await using var client = new CopilotClient(new CopilotClientOptions
{
UseLoggedInUser = false, // Only use explicit tokens
});
```
Go
```golang
client := copilot.NewClient(&copilot.ClientOptions{
UseLoggedInUser: copilot.Bool(false), // Only use explicit tokens
})
```
Java
```java
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();
```
Python
```python
client = CopilotClient({
"use_logged_in_user": False, # Only use explicit tokens
})
```
Rust
```rust
use github_copilot_sdk::{Client, ClientOptions};
let client = Client::start(
ClientOptions::default().with_use_logged_in_user(false),
).await?;
```
TypeScript
```typescript
const client = new CopilotClient({
useLoggedInUser: false, // Only use explicit tokens
});
```
## Nächste Schritte
* [Bring Your Own Key (BYOK)](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/byok) – Erfahren Sie, wie Sie Ihre eigenen API-Schlüssel verwenden.
* [Erstellen Sie Ihre erste Copilot-gestützte App](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/getting-started) – Erstellen Ihrer ersten Copilot-basierten App
* [Verwenden von MCP-Servern mit dem GitHub Copilot SDK](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/mcp) – Herstellen einer Verbindung mit externen Tools