GitHub Copilot em Codespaces com Contêineres Pré-construídos: Configuração

Você tem um Codespace do GitHub com um contêiner pré-construído e deseja que o GitHub Copilot funcione dentro dele sem instalação manual de extensões ou configuração a cada vez. Contêineres pré-construídos economizam tempo de inicialização armazenando em cache seu ambiente de desenvolvimento, mas a configuração do Copilot deve ser incorporada nessa imagem ou no devcontainer.json do Codespace. Se o Copilot estiver ausente ou não ativado após o carregamento do Codespace, o pré-build não é a causa — as etapas de configuração foram ignoradas. Este artigo explica como configurar o Copilot em um contêiner Codespace pré-construído para que ele esteja pronto no momento em que seu ambiente iniciar.

Por que o Copilot Pode Estar Ausente em um Codespace Pré-construído

Um Codespace pré-construído é um snapshot do seu contêiner após uma compilação bem-sucedida. O GitHub aciona um pré-build a cada push para o seu repositório e armazena a imagem resultante. Quando você abre um novo Codespace a partir desse branch, ele puxa a imagem pré-construída em vez de reconstruir do zero. Isso reduz minutos do tempo de inicialização.

No entanto, se o devcontainer.json original não incluir a extensão do Copilot, a imagem pré-construída também não a conterá. O processo de pré-build executa o mesmo devcontainer.json que um Codespace normal. Se a matriz de extensões estiver vazia ou ausente, nenhuma extensão do VS Code será instalada. O Copilot não aparecerá na lista de extensões instaladas e o ícone do Copilot na barra de atividades estará ausente.

Outra causa é uma definição de pré-build mal configurada. Você pode criar vários pré-builds para diferentes branches ou caminhos de devcontainer.json. Se o pré-build apontar para um devcontainer.json que não inclui o Copilot, a imagem resultante não o terá. A correção é sempre a mesma: verifique se o devcontainer.json usado pelo pré-build contém os IDs corretos das extensões.

Passos para Adicionar o Copilot a um Contêiner Codespace Pré-construído

Método 1: Editar o devcontainer.json Diretamente

1. Abra a pasta .devcontainer do seu repositório
   Navegue até a raiz do seu repositório. Se você não tiver uma pasta .devcontainer, crie uma. Dentro dela, crie ou edite um arquivo chamado devcontainer.json.
2. Adicione os IDs das extensões do Copilot à matriz de extensões
   Localize ou crie a chave “extensions”. Adicione “GitHub.copilot” e “GitHub.copilot-chat”. Seu arquivo deve ficar assim:
   {
"name": "My Codespace",
"extensions": [
"GitHub.copilot",
"GitHub.copilot-chat"
]
}
3. Faça commit e push da alteração
   Adicione o arquivo devcontainer.json ao stage, faça commit com uma mensagem como “Adicionar extensões do Copilot ao devcontainer” e envie para o branch que aciona seu pré-build.
4. Acione um novo pré-build
   Vá para o seu repositório no GitHub.com. Clique na aba Settings, depois Codespaces, e depois Prebuild configuration. Encontre a definição de pré-build para o seu branch e clique no menu de três pontos. Selecione New prebuild. Isso reconstrói a imagem do contêiner com as extensões atualizadas.
5. Crie um novo Codespace a partir do pré-build atualizado
   Na página principal do repositório, clique no botão Code, selecione o branch e escolha Codespaces. Clique em Create codespace on branch. Aguarde o ambiente carregar. Abra o painel de Extensões no VS Code e confirme se o Copilot e o Copilot Chat estão instalados.

Método 2: Usar um Dockerfile Personalizado com Copilot Pré-instalado

1. Crie ou atualize seu Dockerfile
   Coloque um Dockerfile dentro da pasta .devcontainer. O Dockerfile é executado antes das extensões do devcontainer.json serem aplicadas. Você pode instalar o Copilot no nível da imagem usando um comando do VS Code, mas a abordagem recomendada é confiar na matriz de extensões, pois é mais simples. Se preferir um Dockerfile, use uma imagem base que já inclua o Copilot, como uma imagem de contêiner de desenvolvimento fornecida pela Microsoft que inclui a extensão.
2. Referencie o Dockerfile no devcontainer.json
   Adicione a propriedade “build” apontando para o seu Dockerfile:
   {
"build": {
"dockerfile": "Dockerfile"
},
"extensions": [
"GitHub.copilot",
"GitHub.copilot-chat"
]
}
3. Faça commit, push e acione um pré-build
   Igual aos passos 3 e 4 do Método 1. O pré-build usará o Dockerfile para construir o contêiner e depois instalará as extensões listadas.

Método 3: Habilitar o Copilot via postCreateCommand

1. Adicione um postCreateCommand ao devcontainer.json
   Este comando é executado após a criação do contêiner. Use-o para instalar o Copilot se a matriz de extensões não estiver disponível por algum motivo. Adicione isso ao devcontainer.json:
   "postCreateCommand": "code --install-extension GitHub.copilot && code --install-extension GitHub.copilot-chat"
2. Faça commit, push e acione um pré-build
   Como antes. Observe que o postCreateCommand é executado durante o pré-build, então as extensões se tornam parte da imagem em cache.

Se o Copilot Ainda Tiver Problemas Após a Configuração

O Copilot Está Instalado, mas Não Mostra Sugestões

Abra a Paleta de Comandos com Ctrl+Shift+P e execute Copilot: Sign In. Se você não estiver autenticado, o Copilot não pode fornecer sugestões. Certifique-se de que sua conta do GitHub tenha uma assinatura ativa do Copilot. Para organizações, verifique se a política do Copilot permite o uso de Codespaces.

O Pré-build Falha Após Adicionar Extensões do Copilot

Verifique os logs do pré-build no GitHub.com em Settings > Codespaces > Prebuild configuration. Clique na definição do pré-build e veja a execução mais recente. Uma falha geralmente indica um erro de sintaxe no devcontainer.json. Valide seu JSON com um linter. Se a matriz de extensões contiver um erro de digitação, o pré-build falhará silenciosamente e a imagem não será atualizada.

O Copilot Chat Está Ausente Mesmo com o Copilot Presente

Os IDs das extensões são separados. Confirme que tanto “GitHub.copilot” quanto “GitHub.copilot-chat” estão na matriz de extensões. Se você adicionou apenas o primeiro, o painel de Chat não aparecerá. Após adicionar o ID ausente, acione um novo pré-build.

Configuração de Extensões no devcontainer.json vs Dockerfile: Principais Diferenças

Item	Matriz de Extensões no devcontainer.json	Dockerfile Personalizado
Complexidade de configuração	Baixa — adicione duas linhas de JSON	Média — requer escrever e manter um Dockerfile
Compatibilidade com pré-build	Totalmente suportado — as extensões são instaladas durante o pré-build	Suportado, mas a instalação de extensões ainda depende do devcontainer.json
Controle de versão da extensão	Sempre obtém a versão mais recente do marketplace	Você pode fixar uma versão específica no Dockerfile
Portabilidade	Funciona em qualquer Codespace, independentemente da imagem base	Requer que o Dockerfile esteja presente no repositório
Frequência de atualização	Automática em cada pré-build	Manual — você deve reconstruir a imagem para atualizar as extensões

Para a maioria das equipes, a matriz de extensões é a melhor escolha. É mais simples, atualiza automaticamente o Copilot e não requer manter um Dockerfile separado. Use um Dockerfile personalizado apenas quando precisar controlar a versão exata do Copilot ou quando estiver agrupando outras ferramentas na mesma imagem.

Depois de configurar o Copilot em seu Codespace pré-construído, verifique a configuração abrindo um arquivo Python, JavaScript ou TypeScript. Digite um comentário como // função para calcular fibonacci e pressione Enter. O Copilot deve gerar uma sugestão de código em um a dois segundos. Se não gerar, execute o comando de login na Paleta de Comandos.

Você também pode habilitar as sugestões inline do Copilot por padrão. Adicione isso ao seu settings.json dentro do devcontainer.json: "editor.inlineSuggest.enabled": true. Isso garante que as sugestões apareçam sem pressionar Alt+\. Para equipes, armazene essa configuração em um arquivo .vscode/settings.json que seja commitado no repositório, para que todos os usuários do Codespace tenham o mesmo comportamento.