.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();
```
**Cuándo usar:**
* Aplicaciones de escritorio en las que los usuarios interactúan directamente
* Entornos de desarrollo y pruebas
* Cualquier escenario en el que un usuario pueda iniciar sesión de forma interactiva
## Aplicación OAuth de GitHub
Use una aplicación de OAuth GitHub para autenticar a los usuarios a través de la aplicación y pasar sus credenciales al SDK. Esto permite a la aplicación realizar solicitudes de API Copilot en nombre de los usuarios que autorizan la aplicación.
**Cómo funciona:**
1. El usuario autoriza la aplicación OAuth de GitHub
2. La aplicación recibe un token de acceso de usuario (`gho_` o `ghu_` prefijo)
3. Pasar el token al SDK a través de su configuración de cliente
**Configuración del 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 admitidos:**
* `gho_` - Tokens de acceso de usuario de OAuth
* `ghu_`: tokens de acceso de usuario de GitHub App
* `github_pat_` - Tokens de acceso personal específico
**No se admite:**
* `ghp_` - Tokens de acceso personal clásicos (en desuso)
**Cuándo usar:**
* Aplicaciones web en las que los usuarios inician sesión a través de GitHub
* Aplicaciones SaaS basadas en Copilot
* Cualquier aplicación multiusuario en la que necesite realizar solicitudes en nombre de distintos usuarios
Para obtener más información, vea [Configuración de OAuth de GitHub](/es/copilot/how-tos/copilot-sdk/setup/github-oauth).
## Variables de entorno
Para la automatización, las canalizaciones de CI/CD y los escenarios de servidor a servidor, puede autenticarse mediante variables de entorno.
Para la automatización con atributos de la organización que no deben usar el token de acceso personal de un usuario, consulte [Autenticación de servidor a servidor](/es/copilot/how-tos/copilot-sdk/auth/server-to-server-tokens).
**Variables de entorno admitidas (en orden de prioridad):**
1. `COPILOT_GITHUB_TOKEN`: recomendado para el uso explícito de Copilot
2. `GH_TOKEN` - Compatible con GitHub CLI
3. `GITHUB_TOKEN` - Compatible con Acciones de GitHub
**Cómo funciona:**
1. Establecer una de las variables de entorno admitidas con un token válido
2. El SDK detecta y usa automáticamente el token.
**Configuración del SDK:**
No se necesitan cambios de código: el SDK detecta automáticamente las variables de entorno:
.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();
```
**Cuándo usar:**
* Pipelines de CI/CD (Acciones de GitHub, Jenkins, entre otros)
* Pruebas automatizadas
* Aplicaciones del lado servidor con cuentas de servicio
* Desarrollo cuando no desea usar el inicio de sesión interactivo
## BYOK (traiga su propia clave)
BYOK permite usar sus propias claves de API de proveedores de modelos como Microsoft Foundry, OpenAI o Anthropic. Esto elude por completo la autenticación de GitHub Copilot.
**Ventajas clave:**
* No se requiere ninguna suscripción GitHub Copilot
* Uso de implementaciones de modelos empresariales
* Facturación directa con su proveedor de modelos
* Compatibilidad con Microsoft Foundry, OpenAI, Anthropic y puntos de conexión compatibles con OpenAI
**Consulte [BYOK (traiga su propia clave)](/es/copilot/how-tos/copilot-sdk/auth/byok) para obtener detalles completos**, entre los que se incluyen:
* configuración de Microsoft Foundry
* Opciones de configuración del proveedor
* Limitaciones y consideraciones
* Ejemplos de código completos
## Prioridad de autenticación
Cuando hay varios métodos de autenticación disponibles, el SDK los usa en este orden de prioridad:
1. **Explícito `gitHubToken`** - Testigo pasado directamente al cliente del SDK o a la configuración de la sesión
2. **Token de API directa** - `GITHUB_COPILOT_API_TOKEN` con `COPILOT_API_URL`
3. **Tokens de variables de entorno** - `COPILOT_GITHUB_TOKEN` → `GH_TOKEN` → `GITHUB_TOKEN`
4. **Credenciales de OAuth almacenadas** : desde el inicio de sesión anterior `copilot` de la CLI
5. **GitHub CLI** - `gh auth` credenciales
Para el modo de servidor multiusuario, pase una `gitHubToken` por sesión para que cada sesión se ejecute con la identidad de GitHub correcta; vea [Multiinquilino e implementaciones de servidor](/es/copilot/how-tos/copilot-sdk/setup/multi-tenancy).
## Deshabilitación del inicio de sesión automático
Para evitar que el SDK utilice automáticamente las credenciales almacenadas o la `gh` autenticación por CLI, configúralo para desactivar el recurso de reserva del usuario que ha iniciado sesión:
.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
});
```
## Pasos siguientes
* [BYOK (traiga su propia clave)](/es/copilot/how-tos/copilot-sdk/auth/byok) : aprenda a usar sus propias claves de API
* [Crea tu primera aplicación con tecnología Copilot](/es/copilot/how-tos/copilot-sdk/getting-started): compile la primera aplicación con tecnología de Copilot
* [Uso de servidores MCP con el SDK de GitHub Copilot](/es/copilot/how-tos/copilot-sdk/features/mcp) : conexión a herramientas externas