# Autenticando GitHub Copilot CLI

Autentique-se CLI do Copilot para que você possa usar Copilot diretamente da linha de comando.

## Sobre a autenticação

Se você usar suas próprias chaves de API do provedor LLM (BYOK), GitHub a autenticação não será necessária.

A autenticação é necessária para qualquer outro CLI do GitHub Copilot uso.

Quando a autenticação é necessária, CLI do Copilot dá suporte a três métodos. O método usado depende se você está trabalhando interativamente ou em um ambiente automatizado.

* **Fluxo do dispositivo OAuth**: o método padrão e recomendado para uso interativo. Quando você executa `/login` em CLI do Copilot, a CLI gera um código único e direciona você a se autenticar no navegador. Essa é a maneira mais simples de autenticar. Consulte [Autenticação com OAuth](#authenticating-with-oauth).
* variáveis de ambiente: As recomendadas para pipelines de CI/CD, contêineres e ambientes não interativos. Você define um token com suporte como uma variável de ambiente (`COPILOT_GITHUB_TOKEN`ou `GH_TOKEN``GITHUB_TOKEN`) e a CLI o usa automaticamente sem solicitar. Consulte [Autenticação com variáveis de ambiente](#authenticating-with-environment-variables).
* **
              GitHub CLI fallback**: se você tiver GitHub CLI (`gh`) (observação: a `gh` CLI, não `copilot`) instalada e autenticada, CLI do Copilot poderá usar seu token automaticamente. Esse é o método de prioridade mais baixo e é ativado somente quando nenhuma outra credencial é encontrada. Consulte [Autenticação com GitHub CLI](#authenticating-with-github-cli).

Depois de autenticado, CLI do Copilot lembra o logon e usa automaticamente o token para todas as Copilot solicitações de API. Você pode fazer logon com várias contas e a CLI se lembrará da conta usada pela última vez. O tempo de vida e a expiração do token dependem de como o token foi criado nas configurações de sua conta ou organização.

## Uso não autenticado

Se você configurar CLI do Copilot para usar suas próprias CHAVES de API do provedor LLM (BYOK), GitHub a autenticação **não será necessária**. 
              CLI do Copilot pode se conectar diretamente ao provedor configurado sem uma GitHub conta ou token.

No entanto, sem GitHub autenticação, os seguintes recursos **não estão disponíveis**:

* `/delegate`: requer agente de nuvem Copilot, que é executado nos servidores de GitHub
* GitHub Servidor MCP: requer autenticação para acessar GitHub APIs
* GitHub Pesquisa de Código: requer autenticação para consultar GitHubo índice de pesquisa

Você pode combinar o BYOK com a autenticação GitHub para unir o melhor dos dois mundos: seu modelo preferido para respostas de IA e o acesso a recursos hospedados em GitHub, como `/delegate` e pesquisa de código.

### Modo offline

 Se você definir a variável de ambiente `COPILOT_OFFLINE` para `true`, CLI do Copilot será executada sem entrar em contato com os servidores de GitHub. No modo offline:

* Nenhuma GitHub autenticação será tentada.
* A CLI só faz solicitações de rede para seu provedor BYOK configurado.
* A telemetria está totalmente desabilitada.

O modo offline é **totalmente isolado da Internet** apenas quando o provedor BYOK é local ou está no mesmo ambiente isolado (por exemplo, um modelo executado localmente, sem acesso à rede externa). Se `COPILOT_PROVIDER_BASE_URL` apontar para um endpoint remoto ou acessível pela Internet, os prompts e o contexto de código continuarão a ser enviados pela rede para esse fornecedor. Sem o modo offline, mesmo ao usar BYOK sem GitHub autenticação, a telemetria ainda é enviada normalmente.

### Tipos de token com suporte

| Tipo de token                 | Prefixo        | Suportado | Anotações                                                  |
|----------------------------|---------------|-----------|--------------------------------------------------------|
| Token OAuth (fluxo de dispositivo)  | `gho_`        | Yes       | Método padrão por meio de `copilot login`                     |
| PAT refinado           | `github_pat_` | Yes       | Deve incluir permissões necessárias **Solicitações do Copilot** |
| GitHub aplicativo usuário-para-servidor  | `ghu_`        | Yes       | Por meio da variável de ambiente                               |
| PAT clássico                | `ghp_`        | Não        | Não há suporte para CLI do Copilot |

### Como Copilot CLI armazena credenciais

Por padrão, a CLI armazena o token OAuth no conjunto de chaves do sistema operacional sob o nome `copilot-cli`do serviço:

| Plataforma | Conjunto de chaves |
|---|---|
| macOS | Acesso às Chaves |
| Windows | Gerenciador de Credenciais |
| Linux | libsecret (GNOME Keyring, KWallet) |

Se o keychain do sistema não estiver disponível – por exemplo, em um servidor Linux sem interface gráfica e sem `libsecret` instalado – a CLI solicitará que você armazene o token em um arquivo de configuração de texto simples em `~/.copilot/config.json`.

Ao executar um comando, CLI do Copilot verifique se há credenciais na seguinte ordem:

1.               Variável de ambiente `COPILOT_GITHUB_TOKEN`
1.               Variável de ambiente `GH_TOKEN`
1.               Variável de ambiente `GITHUB_TOKEN`
1. Token OAuth do keychain do sistema
1. Fallback do GitHub CLI (`gh auth token`)

> [!NOTE]
> * Uma variável de ambiente substitui silenciosamente um token OAuth armazenado. Se você definir `GH_TOKEN` para outra ferramenta, a CLI usará esse token em vez do token OAuth de `copilot login`. Para evitar um comportamento inesperado, desconjunta variáveis de ambiente que você não pretende que a CLI use.
> * Quando você configura variáveis de ambiente do provedor BYOK (por exemplo, `COPILOT_PROVIDER_BASE_URL`, ), `COPILOT_PROVIDER_API_KEY`CLI do Copilot usa-as para solicitações de modelo de IA, independentemente do status GitHub de autenticação. 
              GitHub Os tokens são necessários apenas para recursos hospedados em GitHub.

## Autenticação com OAuth

O fluxo do dispositivo OAuth é o método de autenticação padrão para uso interativo. Você pode autenticar executando `/login` a partir de CLI do Copilot ou `copilot login` através de seu terminal.

### Autenticar com `/login`

1. De CLI do Copilot, execute `/login`.

   ```bash copy
   /login
   ```

1. Selecione a conta com a qual você deseja autenticar. Para GitHub Enterprise Cloud com residência de dados, informe o nome do host da sua instância

   ```text
   What account do you want to log into?
    1. GitHub.com
    2. GitHub Enterprise Cloud with data residency (*.ghe.com)
   ```

1. A CLI exibe um código de usuário único, copia-o automaticamente para a sua área de transferência e abre o seu navegador.

   ```text
   Waiting for authorization...
   Enter one-time code: 1234-5678 at https://github.com/login/device
   Press any key to copy to clipboard and open browser...
   ```

1. Navegue até a URL de verificação em `https://github.com/login/device` se o navegador não abrir automaticamente.
1. Cole o código único no campo na página.
1. Se sua organização usar o SSO do SAML, clique em **Authorize** ao lado de cada organização à qual você deseja conceder access.
1. Examine as permissões solicitadas e clique em **Authorize GitHub Copilot CLI**.
1. Retorne ao terminal. A CLI exibe uma mensagem de êxito quando a autenticação é concluída.

   ```text
   Signed in successfully as Octocat. You can now use Copilot.
   ```

### Autenticar com `copilot login`

1. No terminal, execute `copilot login`. Se você estiver usando GitHub Enterprise Cloud com residência de dados, forneça o nome do host da instância.

   ```bash copy
   copilot login
   ```

   Para GitHub Enterprise Cloud:

   ```bash copy
   copilot login --host HOSTNAME
   ```

   A CLI exibe um código de usuário único, copia-o automaticamente para a sua área de transferência e abre o seu navegador.

   ```text
   To authenticate, visit https://github.com/login/device and enter code 1234-5678.
   ```

1. Navegue até a URL de verificação em `https://github.com/login/device` se o navegador não abrir automaticamente.
1. Cole o código único no campo na página.
1. Se sua organização usar o SSO do SAML, clique em **Authorize** ao lado de cada organização à qual você deseja conceder access.
1. Examine as permissões solicitadas e clique em **Authorize GitHub Copilot CLI**.
1. Retorne ao terminal. A CLI exibe uma mensagem de êxito quando a autenticação é concluída.

   ```text
   Signed in successfully as Octocat.
   ```

## Autenticação com variáveis de ambiente

Para ambientes não interativos, você pode autenticar definindo uma variável de ambiente com um token com suporte. Isso é ideal para pipelines de CI/CD, contêineres ou servidores sem cabeça.

1. Visite [Fine-grained personal access tokens](https://github.com/settings/personal-access-tokens/new).
1. Em "Permissões", clique em **Adicionar permissões** e selecione **Copilot Solicitações**.
1. Clique em **Gerar token**.
1. Exporte o token na configuração do terminal ou do ambiente. Use a variável de ambiente `COPILOT_GITHUB_TOKEN`, `GH_TOKEN` ou `GITHUB_TOKEN` (em ordem de precedência).

## Autenticação com GitHub CLI

Se você tiver GitHub CLI instalado e autenticado, CLI do Copilot poderá usar seu token como um fallback. Esse método tem a prioridade mais baixa e é ativado somente quando nenhuma variável de ambiente é definida e nenhum token armazenado é encontrado.

1. 
              GitHub CLI Verifique se ele está autenticado.

    ```bash copy
    gh auth status
    ```

    Se você usar GitHub Enterprise Cloud com residência de dados, verifique se o nome do host correto está autenticado.

    ```bash copy
    gh auth status --hostname HOSTNAME
    ```

1. Execute `copilot`. A CLI do Copilot usa o token GitHub CLI automaticamente.
1. Execute `/user` para verificar sua conta autenticada na CLI.

## Como alternar entre contas

              CLI do Copilot dá suporte a várias contas. Você pode listar as contas disponíveis e alternar entre elas de dentro da CLI. Para listar as contas disponíveis, execute `/user list` no CLI do Copilot prompt. Para alternar para uma conta diferente, digite `/user switch` no prompt.

Para adicionar outra conta, execute `copilot login` em uma nova sessão de terminal ou execute o comando de logon de dentro da CLI e autorize com a outra conta.

## Sair e remover credenciais

Para sair, digite `/logout` no prompt CLI do Copilot. Isso remove o token armazenado localmente, mas não o revoga no GitHub.

Para revogar a autorização GitHub do aplicativo OAuth e impedir que ela seja usada em outro lugar, siga estas etapas.

1. Navegue até **Configurações** > **Aplicativos** > **Aplicativos OAuth autorizados**.
1. Navegue até a página de configurações:
   1. No canto superior direito de qualquer página em GitHub, clique na sua imagem de perfil. 
   1. Clique em **Configurações**.
1. Na barra lateral esquerda, clique em **Aplicativos**.
1. Em **Authorized OAuth Apps**, clique em <svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-kebab-horizontal" aria-label="The horizontal kebab icon" role="img"><path d="M8 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3ZM1.5 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Zm13 0a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path></svg> ao lado de **GitHub CLI** para expandir o menu e selecionar **Revoke**.