configuration de GitHub OAuth

Idéal pour : applications multiutilisateurs, outils internes avec contrôle d’accès par organisation, produits SaaS, applications dont les utilisateurs ont des comptes GitHub.

Fonctionnement

Vous créez une application OAuth GitHub (ou GitHub Application), les utilisateurs l’autorisent et vous transmettez leur jeton d’accès au KIT de développement logiciel (SDK). Les requêtes Copilot sont effectuées au nom de chaque utilisateur authentifié, à l’aide de son abonnement Copilot.

Principales caractéristiques :

• Chaque utilisateur s’authentifie avec son propre compte GitHub
• L’utilisation de Copilot est facturée sur l’abonnement de chaque utilisateur
• Prend en charge les organisations GitHub et les comptes Enterprise
• Votre application ne gère jamais les clés API de modèle, GitHub gère tout

Architecture

Étape 1 : créer une application OAuth GitHub

1. Accédez à GitHub Settings → Developer Settings → OAuth Apps → New OAuth App (ou pour les organisations : Organization Settings → Developer Settings)

2. Renseignez :

   • Nom de l’application : nom de votre application
   • URL de la page d’accueil : URL de votre application
   • URL de rappel d’autorisation : votre point de terminaison de rappel OAuth (par exemple, https://yourapp.com/auth/callback)

3. Notez votre ID client et générez une clé secrète client

GitHub App vs OAuth App : Les deux fonctionnent. GitHub Apps offrent des autorisations plus précises et sont recommandées pour les nouveaux projets. Les applications OAuth sont plus simples à configurer. Le flux de jetons est le même du point de vue du Kit de développement logiciel (SDK).

Étape 2 : implémenter le flux OAuth

Votre application gère le flux OAuth standard GitHub. Voici l’échange de jetons côté serveur :

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

Étape 3 : passer le jeton au Kit de développement logiciel (SDK)

Créez un client sdk pour chaque utilisateur authentifié, en transmettant son jeton :

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-4.1",
});

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

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-4.1", session_id=f"user-{user_id}-session")

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

package main

import (
    "context"
    "fmt"
    copilot "github.com/github/copilot-sdk/go"
)

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

func main() {
    ctx := context.Background()
    userID := "user1"

    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-4.1",
    })
    response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
    _ = response
}

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-4.1",
})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})

using GitHub.Copilot;

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

var userId = "user1";

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

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

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-4.1",
});

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

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

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-4.1")
        .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    ).get();

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

Accès des entreprises et des organisations

GitHub OAuth prend naturellement en charge les scénarios d’entreprise. Lorsque les utilisateurs s’authentifient avec GitHub, leur appartenance à des organisations et leurs associations à une entreprise sont également prises en compte.

Vérifier l’appartenance à l’organisation

Après OAuth, vérifiez que l’utilisateur appartient à votre organisation :

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

Utilisateurs gérés par l’entreprise (UEM)

Pour GitHub Enterprise Managed Users, le processus est identique : les utilisateurs EMU s’authentifient avec GitHub OAuth comme n’importe quel autre utilisateur. Leurs stratégies d’entreprise (restrictions IP, SSO SAML) sont appliquées automatiquement par GitHub.

// 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,
});

Types de jetons pris en charge

Cycle de vie des jetons

Important: Votre application est responsable du stockage de jetons, de l’actualisation et de la gestion de l’expiration. Le Kit de développement logiciel (SDK) utilise le jeton que vous fournissez . Il ne gère pas le cycle de vie OAuth.

Modèle d’actualisation des jetons

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

Modèles multi-utilisateurs

Un client par utilisateur (recommandé)

Chaque utilisateur obtient son propre client sdk avec son propre jeton. Cela offre l’isolation la plus forte.

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

Interface CLI partagée avec des jetons par requête

Pour une empreinte de ressource plus légère, vous pouvez exécuter un seul serveur CLI externe et transmettre des jetons par session. Consultez Configuration des services principaux pour ce modèle.

Limitations

Quand se déplacer

Étapes suivantes

• Authentification : Référence de méthode d’authentification complète
• Configuration des services principaux : Exécuter le SDK côté serveur
• Mise à l’échelle et multilocation : Gérer de nombreux utilisateurs à grande échelle