# Einrichtung von GitHub OAuth

Ermöglichen Sie Benutzern die Authentifizierung mit ihren GitHub-Konten, Copilot über Ihre Anwendung zu verwenden. Dies unterstützt einzelne Konten, Organisationsmitgliedschaften und Unternehmensidentitäten.

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

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

**Best for:** Multi-User Apps, interne Tools mit Organisationszugriffskontrolle, SaaS-Produkte, Apps, bei denen Benutzer über GitHub Konten verfügen.

## So funktioniert es

Sie erstellen eine GitHub OAuth-App (oder GitHub App), benutzer autorisieren sie, und Sie übergeben ihr Zugriffstoken an das SDK. Copilot Anfragen werden im Namen jedes authentifizierten Benutzers unter Verwendung seines Copilot-Abonnements vorgenommen.

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

**Wichtige Merkmale:**

* Jeder Benutzer authentifiziert sich mit einem eigenen GitHub Konto
* Die Copilot-Nutzung wird dem Abonnement jedes Benutzers in Rechnung gestellt.
* Unterstützt GitHub Organisationen und Unternehmenskonten
* Ihre App verarbeitet niemals Modell-API-Schlüssel – GitHub verwaltet alles

## Aufbau

![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-1.png)

## Schritt 1: Erstellen einer GitHub OAuth-App

1. Wechseln Sie zu **GitHub Einstellungen → Entwicklereinstellungen → OAuth-Apps → neue OAuth-App** (oder für Organisationen: **Organisierungseinstellungen → Entwicklereinstellungen**)

2. Ausfüllen:
   * **Anwendungsname**: Name Ihrer App
   * **Homepage-URL**: Url Ihrer App
   * **Autorisierungsrückruf-URL**: Ihr OAuth-Rückrufendpunkt (z. B. `https://yourapp.com/auth/callback`)

3. Notieren Sie Sich Ihre **Client-ID**, und generieren Sie einen **geheimen Clientschlüssel**.

> **GitHub App vs OAuth App:** Beide funktionieren. GitHub Apps bieten detailliertere Berechtigungen und werden für neue Projekte empfohlen. OAuth-Apps sind einfacher einzurichten. Der Tokenfluss ist aus Sicht des SDK identisch.

## Schritt 2: Implementieren des OAuth-Flusses

Ihre Anwendung behandelt den Standard-GitHub OAuth-Fluss. Hier sehen Sie den serverseitigen Tokenaustausch:

```typescript
// Server-side: Exchange authorization code for user token
async function handleOAuthCallback(code: string): Promise<string> {
    const response = await fetch("https://github.com/login/oauth/access_token", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
        },
        body: JSON.stringify({
            client_id: process.env.GITHUB_CLIENT_ID,
            client_secret: process.env.GITHUB_CLIENT_SECRET,
            code,
        }),
    });

    const data = await response.json();
    return data.access_token; // gho_xxxx or ghu_xxxx
}
```

## Schritt 3: Übergeben des Tokens an das SDK

Erstellen Sie einen SDK-Client für jeden authentifizierten Benutzer, und übergeben Sie ihr Token:

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

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

// Create a client for an authenticated user
function createClientForUser(userToken: string): CopilotClient {
    return new CopilotClient({
        gitHubToken: userToken,
        useLoggedInUser: false,  // Don't fall back to CLI login
    });
}

// Usage
const client = createClientForUser("gho_user_access_token");
const session = await client.createSession({
    sessionId: `user-${userId}-session`,
    model: "gpt-5.4",
});

const response = await session.sendAndWait({ prompt: "Hello!" });
```

</div>

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

```python
from copilot import CopilotClient
from copilot.session import PermissionHandler

def create_client_for_user(user_token: str) -> CopilotClient:
    return CopilotClient({
        "github_token": user_token,
        "use_logged_in_user": False,
    })

# Usage
client = create_client_for_user("gho_user_access_token")
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-5.4", session_id=f"user-{user_id}-session")

response = await session.send_and_wait("Hello!")
```

</div>

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

```golang
func createClientForUser(userToken string) *copilot.Client {
    return copilot.NewClient(&copilot.ClientOptions{
        GitHubToken:     userToken,
        UseLoggedInUser: copilot.Bool(false),
    })
}

// Usage
client := createClientForUser("gho_user_access_token")
client.Start(ctx)
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
    SessionID: fmt.Sprintf("user-%s-session", userID),
    Model:     "gpt-5.4",
})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
```

</div>

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

```csharp
CopilotClient CreateClientForUser(string userToken) =>
    new CopilotClient(new CopilotClientOptions
    {
        GitHubToken = userToken,
        UseLoggedInUser = false,
    });

// Usage
await using var client = CreateClientForUser("gho_user_access_token");
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    SessionId = $"user-{userId}-session",
    Model = "gpt-5.4",
});

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });
```

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

CopilotClient createClientForUser(String userToken) throws Exception {
    var client = new CopilotClient(new CopilotClientOptions()
        .setGitHubToken(userToken)
        .setUseLoggedInUser(false)
    );
    client.start().get();
    return client;
}

// Usage — use try-with-resources to ensure cleanup
var userId = "user1";
try (var client = createClientForUser("gho_user_access_token")) {
    var session = client.createSession(new SessionConfig()
        .setSessionId(String.format("user-%s-session", userId))
        .setModel("gpt-5.4")
        .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    ).get();

    var response = session.sendAndWait(new MessageOptions()
        .setPrompt("Hello!")).get();
}
```

</div>

</div>

## Unternehmens- und Organisationszugriff

GitHub OAuth unterstützt natürlich Unternehmensszenarien. Wenn sich Benutzer mit GitHub authentifizieren, kommen ihre Organisationsmitgliedschaften und Unternehmenszuordnungen zusammen.

![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-2.png)

### Überprüfen der Organisationsmitgliedschaft

Überprüfen Sie nach OAuth, ob der Benutzer zu Ihrer Organisation gehört:

```typescript
async function verifyOrgMembership(
    token: string,
    requiredOrg: string
): Promise<boolean> {
    const response = await fetch("https://api.github.com/user/orgs", {
        headers: { Authorization: `Bearer ${token}` },
    });
    const orgs = await response.json();
    return orgs.some((org: any) => org.login === requiredOrg);
}

// In your auth flow
const token = await handleOAuthCallback(code);
if (!await verifyOrgMembership(token, "my-company")) {
    throw new Error("User is not a member of the required organization");
}
const client = createClientForUser(token);
```

### Von Unternehmen verwaltete Benutzer (EMU)

Für GitHub vom Unternehmen verwaltete Benutzer ist der Ablauf identisch – EMU-Benutzer authentifizieren sich über GitHub OAuth wie jeder andere Benutzer. Ihre Unternehmensrichtlinien (IP-Einschränkungen, SAML-SSO) werden von GitHub automatisch erzwungen.

```typescript
// No special SDK configuration needed for EMU
// Enterprise policies are enforced server-side by GitHub
const client = new CopilotClient({
    gitHubToken: emuUserToken,  // Works the same as regular tokens
    useLoggedInUser: false,
});
```

## Unterstützte Tokentypen

| Tokenpräfix   | Source                                 | Funktioniert? |
| ------------- | -------------------------------------- | ------------- |
| `gho_`        | OAuth-Benutzerzugriffstoken            | ✅             |
| `ghu_`        | GitHub App-Benutzerzugriffstoken       | ✅             |
| `github_pat_` | Feinkörniges persönliches Zugangstoken | ✅             |
| `ghp_`        | Klassisches persönliches Zugriffstoken |               |
| ❌ (veraltet)  |                                        |               |

## Tokenlebenszyklus

![Diagramm: Flussdiagramm mit dem beschriebenen Prozess.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-3.png)

**Wichtig:** Ihre Anwendung ist für die Tokenspeicherung, Aktualisierung und Ablaufbehandlung verantwortlich. Das SDK verwendet das von Ihnen bereitgestellte Token – er verwaltet nicht den OAuth-Lebenszyklus.

### Tokenaktualisierungsmuster

```typescript
async function getOrRefreshToken(userId: string): Promise<string> {
    const stored = await tokenStore.get(userId);

    if (stored && !isExpired(stored)) {
        return stored.accessToken;
    }

    if (stored?.refreshToken) {
        const refreshed = await refreshGitHubToken(stored.refreshToken);
        await tokenStore.set(userId, refreshed);
        return refreshed.accessToken;
    }

    throw new Error("User must re-authenticate");
}
```

## Mehrbenutzermuster

### Ein Client pro Benutzer (empfohlen)

Jeder Benutzer erhält einen eigenen SDK-Client mit einem eigenen Token. Dies bietet die stärkste Isolation.

```typescript
const clients = new Map<string, CopilotClient>();

function getClientForUser(userId: string, token: string): CopilotClient {
    if (!clients.has(userId)) {
        clients.set(userId, new CopilotClient({
            gitHubToken: token,
            useLoggedInUser: false,
        }));
    }
    return clients.get(userId)!;
}
```

### Freigegebene CLI mit Token pro Anforderung

Für einen leichteren Ressourcenbedarf können Sie einen einzelnen externen CLI-Server ausführen und Token pro Sitzung übergeben. Siehe [Einrichtung von Back-End-Diensten](/de/copilot/how-tos/copilot-sdk/setup/backend-services) für dieses Muster.

## Einschränkungen

| Einschränkung                                        | Details                                                 |
| ---------------------------------------------------- | ------------------------------------------------------- |
| **Copilot-Abonnement erforderlich**                  | Jeder Benutzer benötigt ein aktives Copilot-Abonnement. |
| **Die Tokenverwaltung liegt in Ihrer Verantwortung** | Speichern, aktualisieren und Ablauf verwalten           |
| **GitHub Konto erforderlich**                        | Benutzer müssen über GitHub Konten verfügen             |
| **Ratenbeschränkungen pro Benutzer**                 | Vorbehaltlich der Copilot-Ratenlimits jedes Benutzers   |

## Wann muss ich fortfahren?

| Bedarf                                                                                      | Nächster Leitfaden |
| ------------------------------------------------------------------------------------------- | ------------------ |
| Benutzer ohne GitHub Konten                                                                 |                    |
| [Bring Your Own Key (BYOK)](/de/copilot/how-tos/copilot-sdk/auth/byok)                      |                    |
| Ausführen des SDK auf Servern                                                               |                    |
| [Einrichtung von Back-End-Diensten](/de/copilot/how-tos/copilot-sdk/setup/backend-services) |                    |
| Behandeln vieler gleichzeitiger Benutzer                                                    |                    |
| [Skalierung und Mehrinstanzenfähigkeit](/de/copilot/how-tos/copilot-sdk/setup/scaling)      |                    |

## Nächste Schritte

* **[Authentication](/de/copilot/how-tos/copilot-sdk/auth/authenticate)**: Vollständige Authentifizierungsmethodereferenz
* **[Einrichtung von Back-End-Diensten](/de/copilot/how-tos/copilot-sdk/setup/backend-services)**: Ausführen des serverseitigen SDK
* **[Skalierung und Mehrinstanzenfähigkeit](/de/copilot/how-tos/copilot-sdk/setup/scaling)**: Viele Benutzer in großem Maßstab verwalten