.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();
```
**Quando usar:**
* Aplicativos da área de trabalho em que os usuários interagem diretamente
* Ambientes de desenvolvimento e teste
* Qualquer cenário em que um usuário possa entrar interativamente
## Aplicativo OAuth do GitHub
Use um aplicativo GitHub OAuth para autenticar usuários por meio do aplicativo e passar suas credenciais para o SDK. Isso permite que seu aplicativo faça Copilot solicitações de API em nome de usuários que autorizam seu aplicativo.
**Como funciona**:
1. Usuário autoriza seu aplicativo OAuth do GitHub
2. Seu aplicativo recebe um token de acesso do usuário (com o prefixo `gho_` ou `ghu_`)
3. Passar o token para o SDK por meio de sua configuração de cliente
**Configuração do 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
});
```
**Tipos de token com suporte:**
* `gho_` – Tokens de acesso do usuário OAuth
* `ghu_` – tokens de acesso do usuário do aplicativo GitHub
* `github_pat_` — Tokens de acesso pessoal refinados
**Sem suporte:**
* `ghp_` - Tokens de acesso pessoal clássicos (preteridos)
**Quando usar:**
* Aplicativos Web em que os usuários se inscrevem por meio de GitHub
* Aplicativos SaaS baseados em Copilot
* Qualquer aplicativo multiusuário em que você precisa fazer solicitações em nome de usuários diferentes
Para obter mais informações, consulte [Configuração do OAuth do GitHub](/pt/copilot/how-tos/copilot-sdk/setup/github-oauth).
## Variáveis de ambiente
Para automação, pipelines de CI/CD e cenários de servidor para servidor, você pode se autenticar usando variáveis de ambiente.
Para automação atribuída pela organização que não deve usar o token de acesso pessoal de um usuário, consulte [Autenticação de servidor para servidor](/pt/copilot/how-tos/copilot-sdk/auth/server-to-server-tokens).
**Variáveis de ambiente com suporte (em ordem de prioridade):**
1. `COPILOT_GITHUB_TOKEN` – Recomendado para uso explícito do Copilot
2. `GH_TOKEN` – compatível com a CLI GitHub
3. `GITHUB_TOKEN` – compatível com GitHub Actions
**Como funciona**:
1. Definir uma das variáveis de ambiente com suporte com um token válido
2. O SDK detecta e usa automaticamente o token
**Configuração do SDK:**
Nenhuma alteração de código necessária – o SDK detecta automaticamente variáveis de ambiente:
.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();
```
**Quando usar:**
* Pipelines de CI/CD (GitHub Actions, Jenkins e mais)
* Teste automatizado
* Aplicativos do lado do servidor com contas de serviço
* Desenvolvimento quando você não quiser usar logon interativo
## BYOK (Bring Your Own Key - traga sua própria chave)
O BYOK permite que você use suas próprias chaves de API de provedores de modelo, como Microsoft Foundry, OpenAI ou Anthropic. Isso contorna totalmente a autenticação do GitHub Copilot.
**Principais benefícios:**
* Nenhuma assinatura de GitHub Copilot necessária
* Usar implantações de modelo empresarial
* Cobrança direta com seu fornecedor de modelo
* Suporte ao Microsoft Foundry, OpenAI, Anthropic e endpoints compatíveis com OpenAI
**Consulte o [BYOK (Bring Your Own Key - traga sua própria chave)](/pt/copilot/how-tos/copilot-sdk/auth/byok) para obter detalhes completos**, incluindo:
* configuração do Microsoft Foundry
* Opções de configuração do provedor
* Limitações e considerações
* Exemplos de código completos
## Prioridade de autenticação
Quando vários métodos de autenticação estão disponíveis, o SDK os usa nesta ordem de prioridade:
1. **Explícito `gitHubToken`** — Token passado diretamente para o cliente SDK ou configuração de sessão
2. **Token de API direto** - `GITHUB_COPILOT_API_TOKEN` com `COPILOT_API_URL`
3. **Tokens de variáveis de ambiente** - `COPILOT_GITHUB_TOKEN` → `GH_TOKEN` → `GITHUB_TOKEN`
4. **Credenciais OAuth armazenadas** – Do logon anterior `copilot` da CLI
5. **GitHub CLI** - `gh auth` credenciais
Para o modo de servidor multiusuário, passe um `gitHubToken` por sessão para que cada sessão seja executada com a identidade de GitHub correta; consulte [Multilocação e implantações de servidores](/pt/copilot/how-tos/copilot-sdk/setup/multi-tenancy).
## Desabilitando o logon automático
Para impedir que o SDK use automaticamente credenciais armazenadas ou `gh` autenticação via CLI, configure-o para desativar o recurso de fallback para o usuário conectado:
.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
});
```
## Próximas Etapas
* [BYOK (Bring Your Own Key - traga sua própria chave)](/pt/copilot/how-tos/copilot-sdk/auth/byok) – Saiba como usar suas próprias chaves de API
* [Crie seu primeiro aplicativo com tecnologia do Copilot](/pt/copilot/how-tos/copilot-sdk/getting-started) - Crie seu primeiro aplicativo com tecnologia do Copilot
* [Usando servidores MCP com o SDK do GitHub Copilot](/pt/copilot/how-tos/copilot-sdk/features/mcp) – Conectar-se a ferramentas externas