Autenticação

O SDK do GitHub Copilot dá suporte a vários métodos de autenticação para atender a diferentes casos de uso. Escolha o método que melhor corresponde ao seu cenário de implantação.

Neste artigo

Métodos de autenticação

MétodoCaso de usoAssinatura de Copilot necessária
GitHub usuário conectadoAplicativos interativos em que os usuários entrarão com GitHubYes
OAuth GitHub AppAplicativos que atuam em nome dos usuários por meio do OAuthYes
Variáveis de ambienteCI/CD, automação, servidor para servidorYes
BYOK (bring your own key)Usando suas próprias chaves de API (Fábrica de IA do Azure, OpenAI etc.)Não

Usuário conectado do GitHub

Esse é o método de autenticação padrão ao executar a CLI Copilot interativamente. Os usuários se autenticam por meio do fluxo de dispositivo OAuth do GitHub, e o SDK usa suas credenciais armazenadas.

Como funciona:

  1. O usuário executa copilot CLI e entra por GitHub OAuth
  2. As credenciais são armazenadas com segurança no conjunto de chaves do sistema
  3. O SDK usa automaticamente as credenciais armazenadas

Configuração do SDK:

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

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

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

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

func main() {
    // Default: uses logged-in user credentials
    client := copilot.NewClient(nil)
    _ = client
}

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

// Default: uses logged-in user credentials
client := copilot.NewClient(nil)
.NET
using GitHub.Copilot;

// Default: uses logged-in user credentials
await using var client = new CopilotClient();
Java
import com.github.copilot.sdk.CopilotClient;

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

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

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 da gitHubToken opção

Configuração do SDK:

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
});
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()
Go
package main

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

func main() {
    userAccessToken := "token"
    client := copilot.NewClient(&copilot.ClientOptions{
        GitHubToken:     userAccessToken,
        UseLoggedInUser: copilot.Bool(false),
    })
    _ = client
}

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
})
.NET
using GitHub.Copilot;

var userAccessToken = "token";
await using var client = new CopilotClient(new CopilotClientOptions
{
    GitHubToken = userAccessToken,
    UseLoggedInUser = false,
});

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
});
Java
import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.json.*;

var client = new CopilotClient(new CopilotClientOptions()
    .setGitHubToken(userAccessToken)  // Token from OAuth flow
    .setUseLoggedInUser(false)        // Don't use stored CLI credentials
);
client.start().get();

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

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.

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:

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

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

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

Quando usar:

  • Pipelines de CI/CD (GitHub Actions, Jenkins etc.)
  • 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 Fábrica de IA do Azure, 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 para pontos de extremidade compatíveis com AZure AI Foundry, OpenAI, Antropic e OpenAI

Consulte o BYOK (bring your own key) para obter detalhes completos, incluindo:

  • Configuração do Fábrica de IA do Azure
  • 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 construtor do SDK
  2. Chave - CAPI_HMAC_KEY HMAC ou COPILOT_HMAC_KEY variáveis de ambiente
  3. Token de API direto - GITHUB_COPILOT_API_TOKEN com COPILOT_API_URL
  4. Tokens de variáveis de ambiente - COPILOT_GITHUB_TOKEN → GH_TOKEN → GITHUB_TOKEN
  5. Credenciais OAuth armazenadas – Do logon anterior copilot da CLI
  6. GitHub CLI - gh auth credenciais

Desabilitando o logon automático

Para impedir que o SDK use automaticamente credenciais armazenadas ou gh autenticação da CLI, use a opção useLoggedInUser: false :

TypeScript
const client = new CopilotClient({
    useLoggedInUser: false,  // Only use explicit tokens
});
Python
from copilot import CopilotClient

client = CopilotClient({
    "use_logged_in_user": False,
})

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

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

func main() {
    client := copilot.NewClient(&copilot.ClientOptions{
        UseLoggedInUser: copilot.Bool(false),
    })
    _ = client
}

client := copilot.NewClient(&copilot.ClientOptions{
    UseLoggedInUser: copilot.Bool(false),  // Only use explicit tokens
})
.NET
await using var client = new CopilotClient(new CopilotClientOptions
{
    UseLoggedInUser = false,  // Only use explicit tokens
});
Java
import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.json.*;

var client = new CopilotClient(new CopilotClientOptions()
    .setUseLoggedInUser(false)  // Only use explicit tokens
);
client.start().get();

Próximas Etapas