Authentification

Méthodes d’authentification

Utilisateur connecté à GitHub

Il s’agit de la méthode d’authentification par défaut lors de l’exécution interactive de l’interface CLI Copilot. Les utilisateurs s’authentifient via le flux d’appareils OAuth de GitHub, et le SDK utilise leurs identifiants enregistrés.

Fonctionnement :

1. L’utilisateur exécute copilot CLI et se connecte via GitHub OAuth
2. Les informations d’identification sont stockées de manière sécurisée dans le trousseau de clés du système
3. Le Kit de développement logiciel (SDK) utilise automatiquement les informations d’identification stockées

Configuration du Kit de développement logiciel (SDK) :

using GitHub.Copilot;

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

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

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

import com.github.copilot.CopilotClient;

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

from copilot import CopilotClient

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

use github_copilot_sdk::{Client, ClientOptions};

// Default: uses logged-in user credentials
let client = Client::start(ClientOptions::default()).await?;

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

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

Quand utiliser :

• Applications de bureau où les utilisateurs interagissent directement
• les environnements de développement et de test ;
• Tout scénario dans lequel un utilisateur peut se connecter de manière interactive

application OAuth GitHub

Utilisez une application OAuth GitHub pour authentifier les utilisateurs via votre application et transmettre leurs informations d’identification au Kit de développement logiciel (SDK). Cela permet à votre application d’effectuer des requêtes à l’API Copilot pour le compte des utilisateurs qui autorisent votre application.

Fonctionnement :

1. L’utilisateur autorise votre application OAuth GitHub
2. Votre application reçoit un jeton d’accès utilisateur (gho_ ou ghu_ préfixe)
3. Transmettre le jeton au Kit de développement logiciel (SDK) par le biais de sa configuration cliente

Configuration du Kit de développement logiciel (SDK) :

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

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

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

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

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

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

Types de jetons pris en charge :

• gho_ - Jetons d’accès utilisateur OAuth
• ghu_ - jetons d’accès utilisateur de l’application GitHub
• github_pat_ - Jetons d’accès personnels à granularité fine

Non pris en charge :

• ghp_ - Jetons d’accès personnels classiques (déconseillés)

Quand utiliser :

• Applications web où les utilisateurs se connectent via GitHub
• Applications SaaS reposant sur Copilot
• Toute application multi-utilisateur dans laquelle vous devez effectuer des demandes pour le compte de différents utilisateurs

Pour plus d’informations, consultez « configuration de GitHub OAuth ».

Variables d’environnement

Pour les scénarios d’automatisation, ci/CD et serveur à serveur, vous pouvez vous authentifier à l’aide de variables d’environnement.

Pour l’automatisation attribuée par l’organisation qui ne doit pas utiliser le jeton d’accès personnel d’un utilisateur, consultez Authentification serveur à serveur.

Variables d’environnement prises en charge (par ordre de priorité) :

1. COPILOT_GITHUB_TOKEN - Recommandé pour un usage explicite de Copilot
2. GH_TOKEN - compatible avec GitHub CLI
3. GITHUB_TOKEN - compatible avec GitHub Actions

Fonctionnement :

1. Définir l’une des variables d’environnement prises en charge avec un jeton valide
2. Le Kit de développement logiciel (SDK) détecte et utilise automatiquement le jeton

Configuration du Kit de développement logiciel (SDK) :

Aucune modification du code n’est nécessaire : le SDK détecte automatiquement les variables d’environnement :

using GitHub.Copilot;

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

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

// Token is read from environment variable automatically
client := copilot.NewClient(nil)

import com.github.copilot.CopilotClient;

// Token is read from environment variable automatically
var client = new CopilotClient();
client.start().get();

from copilot import CopilotClient

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

use github_copilot_sdk::{Client, ClientOptions};

// Token is read from environment variable automatically
let client = Client::start(ClientOptions::default()).await?;

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

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

Quand utiliser :

• pipelines CI/CD (GitHub Actions, Jenkins et plus encore)
• Tests automatisés
• Applications côté serveur avec des comptes de service
• Développement lorsque vous ne souhaitez pas utiliser la connexion interactive

BYOK (apportez votre propre clé)

BYOK vous permet d’utiliser vos propres clés API à partir de fournisseurs de modèles tels que Microsoft Foundry, OpenAI ou Anthropic. Cela contourne entièrement l’authentification GitHub Copilot.

Principaux avantages :

• Aucun abonnement GitHub Copilot requis
• Utiliser des déploiements de modèles d’entreprise
• Facturation directe avec votre fournisseur de modèles
• Prise en charge de Microsoft Foundry, d’OpenAI, d’Anthropic et des points de terminaison compatibles avec OpenAI

Pour plus d’informations, consultez autoTITLE, notamment :

• configuration de Microsoft Foundry
• Options de configuration du fournisseur
• Limitations et considérations
• Exemples de code complets

Priorité d’authentification

Lorsque plusieurs méthodes d’authentification sont disponibles, le SDK les utilise dans cet ordre de priorité :

1. Explicite gitHubToken - Jeton transmis directement au client du SDK ou à la configuration de session
2. Jeton d’API direct - GITHUB_COPILOT_API_TOKEN avec COPILOT_API_URL
3. Jetons de variable d’environnement - COPILOT_GITHUB_TOKEN → GH_TOKEN → GITHUB_TOKEN
4. Informations d’identification OAuth stockées - À partir de la connexion CLI précédente copilot
5. GitHub CLI - gh auth informations d’identification

Pour le mode serveur multi-utilisateur, passez un gitHubToken par session afin que chaque session s’exécute avec l’identité de GitHub correcte ; consultez Multilocataire et déploiements de serveurs.

Désactivation de la connexion automatique

Pour empêcher le SDK d’utiliser automatiquement les informations d’identification stockées ou gh l’authentification CLI, configurez-le pour désactiver le mécanisme de secours de l’utilisateur connecté :

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

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

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

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

use github_copilot_sdk::{Client, ClientOptions};

let client = Client::start(
    ClientOptions::default().with_use_logged_in_user(false),
).await?;

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

Étapes suivantes

• BYOK (apportez votre propre clé) - Découvrez comment utiliser vos propres clés API
• Créez votre première application avec Copilot - Créez votre première application basée sur Copilot
• Utilisation de serveurs MCP avec le SDK GitHub Copilot - Se connecter à des outils externes