.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();
```
**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) :**
.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
});
```
**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](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/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](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/server-to-server-tokens).
**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 :
.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();
```
**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](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/byok)**, 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](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy).
## 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é :
.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
});
```
## Étapes suivantes
* [BYOK (apportez votre propre clé)](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth/byok) - Découvrez comment utiliser vos propres clés API
* [Créez votre première application avec Copilot](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/getting-started) - Créez votre première application basée sur Copilot
* [Utilisation de serveurs MCP avec le SDK GitHub Copilot](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/mcp) - Se connecter à des outils externes