# configuration de GitHub OAuth

Permettre aux utilisateurs de s’authentifier auprès de leurs comptes GitHub d’utiliser Copilot via votre application. Cela prend en charge les comptes individuels, les appartenances à l’organisation et les identités d’entreprise.

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

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

**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.

![Diagramme : diagramme de séquence montrant le processus décrit.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-0.png)

**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

![Diagramme : Organigramme montrant le processus décrit.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-1.png)

## É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 :

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

## É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 :

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

## 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.

![Diagramme : Organigramme montrant le processus décrit.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-2.png)

### Vérifier l’appartenance à l’organisation

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

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

### 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.

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

## Types de jetons pris en charge

| Préfixe de jeton | Source                                            | Fonctionne? |
| ---------------- | ------------------------------------------------- | ----------- |
| `gho_`           | Jeton d’accès utilisateur OAuth                   | ✅           |
| `ghu_`           | jeton d’accès utilisateur de l’application GitHub | ✅           |
| `github_pat_`    | Jeton d’accès personnel granulaire                | ✅           |
| `ghp_`           | Jeton d’accès personnel classique                 |             |
| ❌ (déconseillé)  |                                                   |             |

## Cycle de vie des jetons

![Diagramme : Organigramme montrant le processus décrit.](/assets/images/help/copilot/copilot-sdk/setup-github-oauth-diagram-3.png)

**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

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

## 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.

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

### 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](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/backend-services) pour ce modèle.

## Limitations

| Limitation                                         | Détails                                                                   |
| -------------------------------------------------- | ------------------------------------------------------------------------- |
| **Abonnement Copilot requis**                      | Chaque utilisateur a besoin d’un abonnement actif Copilot                 |
| **La gestion des jetons est votre responsabilité** | Stocker, actualiser et gérer l’expiration                                 |
| compte **GitHub requis**                           | Les utilisateurs doivent avoir des comptes GitHub                         |
| **Limites de débit par utilisateur**               | Sous réserve des limites de débit de Copilot propres à chaque utilisateur |

## Quand se déplacer

| Besoin                                                                                                                  | Guide suivant |
| ----------------------------------------------------------------------------------------------------------------------- | ------------- |
| Utilisateurs sans comptes GitHub                                                                                        |               |
| [BYOK (apportez votre propre clé)](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/byok)                   |               |
| Exécuter le Kit de développement logiciel (SDK) sur les serveurs                                                        |               |
| [Configuration des services principaux](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/backend-services) |               |
| Gérer de nombreux utilisateurs simultanés                                                                               |               |
| [Mise à l'échelle et multilocataire](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/scaling)             |               |

## Étapes suivantes

* **[Authentification](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/authenticate)** : Référence de méthode d’authentification complète
* **[Configuration des services principaux](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/backend-services)** : Exécuter le SDK côté serveur
* **[Mise à l'échelle et multilocataire](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/scaling)** : Gérer de nombreux utilisateurs à grande échelle