Copilot Extensions e Marketplace
GitHub Copilot foi projetado para ser extensível. Através do Extensões do copiloto, é possível expandir as capacidades do assistente de IA com integrações de terceiros, ferramentas personalizadas e agentes especializados. As extensões eles permitem que você conecte o Copilot a bancos de dados, serviços em nuvem, plataformas de teste, ferramentas monitoramento e muito mais, transformando-o em um hub centralizado para todo o fluxo de trabalho de desenvolvimento.
Neste artigo exploraremos o ecossistema de extensões, os tipos disponíveis, como integrá-los ao seu fluxo de trabalho e como criar extensões personalizadas para as necessidades específicas de sua equipe.
Visão geral da Série Completa
| # | Artigo | Foco |
|---|---|---|
| 1 | Fundamentos e Mindset | Setup e mentalidade |
| 2 | Ideação e Requisitos | Da ideia ao MVP |
| 3 | Arquitetura Backend/Frontend | API e banco de dados |
| 4 | Estrutura de Código | Organizzazione e naming |
| 5 | Prompt Engineering | Prompts e Agentes MCP |
| 6 | Testes e Qualidade | Unitários, Integração, E2E |
| 7 | Documentação | README, API Docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evolução | Escalabilidade e manutenção |
| 10 | Coding Agent | Agente autonomo GitHub |
| 11 | Code Review | Review automatizzata |
| 12 | Copilot Edits | Edição multi-arquivo |
| 13 | GitHub Spark | Microaplicativos sem código |
| 14 | Copilot Spaces | Contexto compartilhado |
| 15 | Modelos de IA | Multi-model e seleção |
| 16 | Personalização | Instruções e configuração |
| 17 | Enterprise e Business | Piani, analytics, policy |
| 18 | Você está aqui → Extensions e Marketplace | Extensions e integrazioni |
| 19 | Segurança e Uso Responsabile | Segurança e compliance |
Visão geral das extensões do Copilot
Extensões Copilot são aplicativos que estendem a funcionalidade do GitHub Copilot. Eles estão disponíveis em Mercado GitHub e pode ser instalado tanto a nível individual como organizacional. As extensões são integradas diretamente com o Copilot Chat, permitindo que os desenvolvedores interajam com ferramentas externas sem sair do seu IDE ou navegador.
Arquitetura de extensões
As extensões do Copilot são construídas como Aplicativos GitHub, o que garante compatibilidade entre plataformas e um modelo robusto de autenticação e autorização. Quando um usuário invoca uma extensão por meio do Copilot Chat, a solicitação é roteada através da infraestrutura do GitHub até o endpoint de extensão, que processa a solicitação e retorna uma resposta.
Fluxo de uma extensão copiloto
| Step | Attore | Azione | Detalhe |
|---|---|---|---|
| 1 | Utente | Invoca l'extension in chat | @extension-name come posso...? |
| 2 | GitHub | Autenticar a solicitação | Verifica permessi utente e app |
| 3 | GitHub | Encaminhar para o endpoint | HTTP POST para o servidor de extensão |
| 4 | Extension | Processar a solicitação | Chiama API esterne, analizza dati |
| 5 | Extension | Genera risposta | Testo, codice, link, azioni |
| 6 | GitHub | Restituisce risposta | Formatado no bate-papo do Copilot |
Tipos de extensões
O GitHub distingue dois tipos principais de extensões, cada uma com características e diferentes complexidades de implementação.
Full Extensions (Agents)
- Aplicativos completos com lógica do lado do servidor
- Possono chiamare API esterne
- Eles gerenciam estado e sessões
- Supportano flussi complessi multi-step
- Eles exigem sua própria infraestrutura de hospedagem
- Maggiore flessibilità' e potenza
- Tempo de desenvolvimento: semanas/meses
Skillsets (Lightweight)
- Extensions leggere e task-specific
- Definite tramite configurazione, poco codice
- Concentre-se em uma única capacidade'
- Rápido de construir e implantar
- Nessuna infrastruttura complessa richiesta
- Ideal para automações simples
- Tempo de desenvolvimento: horas/dias
Skillsets: Extensions Leggere
As habilidades são a maneira mais fácil de estender o Copilot com funcionalidades personalizadas. Eles são ideais para tarefas específicas e repetitivas que não exigem lógica complexa. Um conjunto de habilidades é essencialmente uma definição de ferramentas que o Copilot pode usar para responder a solicitações específicas.
Estrutura de um conjunto de habilidades
{
"name": "db-query-helper",
"description": "Helps developers write and optimize SQL queries for PostgreSQL",
"version": "1.0.0",
"skills": [
{
"name": "explain-query",
"description": "Analyze and explain a SQL query step by step",
"parameters": {
"query": {
"type": "string",
"description": "The SQL query to analyze"
},
"database": {
"type": "string",
"description": "Target database type",
"enum": ["postgresql", "mysql", "sqlite"],
"default": "postgresql"
}
}
},
{
"name": "optimize-query",
"description": "Suggest optimizations for a SQL query including index recommendations",
"parameters": {
"query": {
"type": "string",
"description": "The SQL query to optimize"
},
"table_info": {
"type": "string",
"description": "Table schemas and current indexes"
},
"expected_rows": {
"type": "number",
"description": "Expected number of rows in result"
}
}
},
{
"name": "generate-migration",
"description": "Generate a database migration script from a description",
"parameters": {
"description": {
"type": "string",
"description": "Description of schema changes"
},
"format": {
"type": "string",
"description": "Migration format",
"enum": ["flyway", "liquibase", "prisma", "raw-sql"],
"default": "flyway"
}
}
}
]
}Casos de uso para qualificações
Conjuntos de habilidades comuns para equipes de desenvolvimento
| Skillset | Função | Trigger | Output |
|---|---|---|---|
| Code Formatter | Formate o código de acordo com os padrões da empresa | @formatter format this code | Codice formattato + diff |
| Regex Builder | Gerar regex a partir da descrição natural | @regex validate Italian fiscal code | Pattern regex + test cases |
| API Mock Generator | Gere dados simulados do esquema OpenAPI | @mock generate 10 users | JSON com dados realistas |
| Changelog Writer | Gerar changelog do histórico de commits | @changelog since v2.1.0 | Markdown changelog formattato |
| Dependency Checker | Verifica dipendenze outdated e vulnerabili | @deps check this project | Relatórios com versões e CVEs |
| i18n Helper | Gerar traduções para chaves ausentes | @i18n translate to Italian | Arquivos JSON/YAML com traduções |
GitHub Apps Integration
As extensões completas do Copilot são criadas como aplicativos GitHub. Isso significa que eles herdam todo o modelo de segurança, autenticação e autorização dos aplicativos GitHub, garantindo uma integração segura e controlável.
Autenticazione e Autorizzazione
Modelo de segurança de extensões
| Livello | Meccanismo | Descrição |
|---|---|---|
| App-level | JWT (JSON Web Token) | Identifica l'app stessa presso GitHub |
| Installation-level | Installation Access Token | Token específico para instalação na organização |
| User-level | OAuth User Access Token | Ações em nome do usuário específico |
| Permissions | Granular permissions | Acesse apenas os recursos necessários (repo, problemas, PRs) |
| Webhooks | HMAC-SHA256 signature | Verifique a autenticidade dos eventos recebidos |
Permessi Richiesti
Cada extensão declara as permissões necessárias. O usuário ou administrador da organização deve aprová-los explicitamente antes da instalação. O princípio do menor privilégio deve orientar a escolha das licenças.
{
"name": "Copilot DB Assistant",
"description": "Database query helper for Copilot Chat",
"url": "https://db-assistant.example.com",
"hook_attributes": {
"url": "https://db-assistant.example.com/webhooks"
},
"redirect_url": "https://db-assistant.example.com/auth/callback",
"public": true,
"default_events": [
"issues",
"pull_request"
],
"default_permissions": {
"contents": "read",
"issues": "write",
"pull_requests": "read",
"metadata": "read"
},
"copilot_agent": {
"url": "https://db-assistant.example.com/copilot/agent",
"description": "Helps with database queries and migrations"
}
}Integração MCP no Contexto de Extensões
Il Protocolo de Contexto do Modelo (MCP) é uma alternativa complementar Extensões do Copilot para conectar ferramentas externas ao Copilot. Enquanto as extensões siga o modelo GitHub Apps, o MCP oferece um protocolo padronizado para conexão de ferramentas e fontes de dados.
GitHub MCP Registry
O GitHub MCP Registry é um serviço de descoberta selecionado para servidores MCP. Funciona como um catálogo que permite encontrar e instalar rapidamente servidores MCP verificados, reduzindo o risco de integrações inseguras.
Confronto: Extensions vs MCP Servers
| Aspetto | Copilot Extensions | MCP Servers |
|---|---|---|
| Piattaforma | GitHub Marketplace | MCP Registry + configurazione locale |
| Autenticazione | GitHub OAuth / App tokens | Varia (API key, OAuth, none) |
| Hosting | Server esterno (cloud) | Locale (stdio) o remoto (HTTP/SSE) |
| Complessità' setup | Media (GitHub App) | Bassa (config file) |
| Cross-platform | Todos os ambientes do Copilot | Principalmente IDE (VS Code) |
| Governance | GitHub Marketplace review | Responsabilidades do usuário/organização |
| Caso d'uso | Integrazioni SaaS, workflow complessi | Tool locali, database, file system |
| Distribuzione | Pubblica (Marketplace) | Privata o pubblica (Registry) |
Toolsets: Raggruppare i Tool MCP
I conjuntos de ferramentas são um mecanismo para agrupar ferramentas MCP relacionadas em um único espaço para nome. Isso simplifica o gerenciamento quando você tem muitos servidores MCP ativos ao mesmo tempo, permitindo ativar/desativar grupos de ferramentas com uma única operação.
{
"servers": {
"development-tools": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@dev-tools/mcp-server"],
"toolsets": {
"database": {
"description": "Database management tools",
"tools": ["query", "migrate", "seed", "backup"]
},
"testing": {
"description": "Testing utilities",
"tools": ["generate-test", "run-test", "coverage-report"]
},
"documentation": {
"description": "Documentation generation",
"tools": ["generate-docs", "update-readme", "create-adr"]
}
}
},
"cloud-services": {
"type": "remote",
"url": "https://cloud-mcp.example.com/sse",
"toolsets": {
"aws": {
"description": "AWS service management",
"tools": ["s3-upload", "lambda-deploy", "cloudwatch-logs"]
},
"monitoring": {
"description": "Monitoring and alerting",
"tools": ["check-health", "get-metrics", "create-alert"]
}
}
}
}
}Third-Party Agents
Uma das evoluções mais significativas do ecossistema Copilot é a integração de agentes terceirizados diretamente na plataforma. Esses agentes trazer os recursos de modelos alternativos de IA para a experiência do Copilot.
Agenti Disponibili
Third-Party Agents in Copilot
| Agente | Provider | Specializzazione | Disponibilità' | Modello |
|---|---|---|---|---|
| Claude | Anthropic | Análise aprofundada de código, refatoração e documentação | Pro+ / Enterprise | Claude Sonnet 4 |
| Codex | OpenAI | Generazione codice, completamenti avanzati | Pro+ / Enterprise | Codex / o3-mini |
| Gemini | Comprensione multimodale, contesto lungo | Pro+ / Enterprise | Gemini 2.5 Pro |
Quando usar cada agente
| Scenario | Agente Consigliato | Motivazione |
|---|---|---|
| Refactoring codebase legacy | Claude | Excelente na análise de códigos complexos e na proposta de reestruturação gradual |
| Generazione boilerplate rapida | Copilot nativo (GPT-4) | Otimizado para finalizações rápidas e andaimes |
| Análise de captura de tela da IU | Gemini | Compreensão multimodal para análise de imagens de interface |
| Debugging algoritmico complesso | Codex / o3-mini | Forte em raciocínio lógico e resolução de problemas algorítmicos |
| Documentação técnica detalhada | Claude | Produz texto técnico de alta qualidade com contexto extenso |
| Migração entre frameworks | Claude o Copilot nativo | Compreensão profunda dos padrões de diferentes estruturas |
Nota sobre disponibilidade
Agentes terceirizados estão atualmente em visualização pública e disponível somente para pisos Pró+ e Empresa. Disponibilidade e modelos específicos podem mudar ao longo do tempo à medida que novos fornecedores surgem integrado à plataforma.
O uso de agentes terceirizados consome solicitações premium do seu orçamento mensal. Solicitações para modelos avançados podem consumir mais solicitações premium do que solicitações ao modelo básico do Copilot.
Construindo sua própria extensão de copiloto
Se as extensões disponíveis no Marketplace não atenderem às suas necessidades específicas equipe, você pode criar sua própria extensão Copilot. O processo requer a criação de um Aplicativo GitHub com um endpoint de servidor que lida com solicitações do Copilot.
Pré-requisitos
O que você precisa para construir uma extensão
- Contas GitHub: Com acesso para criar aplicativos GitHub
- Servidores da Web: Para hospedar o endpoint de extensão (Node.js, Python, Go, etc.)
- Domínio HTTPS: O endpoint deve ser acessível via HTTPS
- Conhecimento da API de aplicativos GitHub: Para gerenciar autenticação e webhooks
- SDK de extensões do Copilot: SDK oficial para simplificar o desenvolvimento
Arquitetura de uma extensão
# Architettura di una Copilot Extension
GitHub Infrastructure
+-------------------+
| |
User in IDE ---> | Copilot Chat |
"@my-ext help" | (message router) |
| |
+--------+----------+
|
HTTP POST (authenticated)
|
+--------v----------+
| |
| Your Extension |
| Server |
| |
| +---------------+ |
| | Request | |
| | Handler | |
| +-------+-------+ |
| | |
| +-------v-------+ |
| | Business | |
| | Logic | |
| +-------+-------+ |
| | |
| +-------v-------+ |
| | External | |
| | Services | |
| | (DB, API, | |
| | tools) | |
| +---------------+ |
| |
+--------+----------+
|
HTTP Response (streaming)
|
+--------v----------+
| |
| Copilot Chat |
| (rendered to |
| user) |
| |
+-------------------+Implementação básica com Node.js
import express from 'express';
import { Octokit } from '@octokit/rest';
import { createNodeMiddleware } from '@octokit/webhooks';
import { verifyRequestByKeyId } from '@copilot-extensions/preview-sdk';
const app = express();
app.use(express.json());
// Endpoint principale per Copilot Chat
app.post('/copilot/agent', async (req, res) => {
try {
// 1. Verifica autenticita' della richiesta
const signature = req.headers['github-public-key-signature'] as string;
const keyId = req.headers['github-public-key-identifier'] as string;
const body = JSON.stringify(req.body);
const isValid = await verifyRequestByKeyId(body, signature, keyId, {
token: process.env.GITHUB_TOKEN!
});
if (!isValid) {
return res.status(401).json({ error: 'Invalid signature' });
}
// 2. Estrai il messaggio dell'utente
const messages = req.body.messages;
const lastMessage = messages[messages.length - 1];
const userQuery = lastMessage.content;
// 3. Elabora la richiesta in base al contenuto
const response = await processQuery(userQuery, req.body);
// 4. Restituisci risposta in streaming (SSE format)
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
// Invia la risposta come stream di eventi
res.write(`data: ${JSON.stringify({
choices: [{
index: 0,
delta: {
role: 'assistant',
content: response
}
}]
})}\n\n`);
res.write('data: [DONE]\n\n');
res.end();
} catch (error) {
console.error('Extension error:', error);
res.status(500).json({ error: 'Internal server error' });
}
});
async function processQuery(
query: string,
context: any
): Promise<string> {
// Logica personalizzata dell'extension
// Qui puoi chiamare database, API esterne, ecc.
if (query.includes('status')) {
return await getSystemStatus();
}
if (query.includes('deploy')) {
return await getDeploymentInfo();
}
if (query.includes('metrics')) {
return await getProjectMetrics();
}
return `Ciao! Sono l'extension personalizzata del team.
Posso aiutarti con:
- **status**: Stato attuale dei servizi
- **deploy**: Informazioni sull'ultimo deployment
- **metrics**: Metriche del progetto
Come posso aiutarti?`;
}
async function getSystemStatus(): Promise<string> {
// Esempio: chiama un health check endpoint
const services = ['api', 'database', 'cache', 'queue'];
const results = await Promise.all(
services.map(async (service) => {
try {
const response = await fetch(
`https://monitoring.example.com/health/${service}`
);
const data = await response.json();
return `- **${service}**: ${data.status} (uptime: ${data.uptime})`;
} catch {
return `- **${service}**: UNREACHABLE`;
}
})
);
return `## System Status\n\n${results.join('\n')}`;
}
async function getDeploymentInfo(): Promise<string> {
// Esempio: informazioni dall'ultimo deploy
return `## Last Deployment
- **Version**: v2.4.1
- **Environment**: production
- **Time**: 2 hours ago
- **Status**: Successful
- **Deployed by**: CI/CD Pipeline
- **Commit**: abc1234`;
}
async function getProjectMetrics(): Promise<string> {
// Esempio: metriche dal sistema di monitoring
return `## Project Metrics (Last 24h)
- **Requests**: 125,430
- **Error Rate**: 0.12%
- **p95 Latency**: 245ms
- **Active Users**: 3,421
- **CPU Usage**: 45%
- **Memory**: 62%`;
}
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Extension server running on port ${PORT}`);
});Teste de extensão
import request from 'supertest';
import { app } from '../server';
describe('Copilot Extension', () => {
describe('POST /copilot/agent', () => {
it('should respond to status query', async () => {
const response = await request(app)
.post('/copilot/agent')
.set('Content-Type', 'application/json')
.send({
messages: [
{
role: 'user',
content: 'What is the current status?'
}
]
});
expect(response.status).toBe(200);
expect(response.headers['content-type']).toContain('text/event-stream');
});
it('should handle unknown queries gracefully', async () => {
const response = await request(app)
.post('/copilot/agent')
.send({
messages: [
{
role: 'user',
content: 'random question'
}
]
});
expect(response.status).toBe(200);
// Should return help message
});
it('should reject unauthenticated requests', async () => {
// Test without proper GitHub signature headers
const response = await request(app)
.post('/copilot/agent')
.set('github-public-key-signature', 'invalid')
.set('github-public-key-identifier', 'invalid')
.send({
messages: [{ role: 'user', content: 'test' }]
});
expect(response.status).toBe(401);
});
});
});Pubblicazione sul Marketplace
Processo de publicação
| Step | Azione | Requisitos | Tempo Stimato |
|---|---|---|---|
| 1 | Crea GitHub App | Account GitHub, dominio HTTPS | 1 ora |
| 2 | Implementa endpoint | Servidor com SDK de extensões do Copilot | 1-4 semanas |
| 3 | Test locale | Instalação de aplicativo privado | 1-2 giorni |
| 4 | Documentação | README, examples, API docs | 2-3 giorni |
| 5 | Enviar para revisão | Listagem completa do Marketplace | 1 giorno |
| 6 | Review GitHub | Conformidade com as diretrizes | 3-10 giorni |
| 7 | Pubblicazione | Approvazione ottenuta | Immediata |
Categorias de extensões populares
O GitHub Marketplace oferece extensões organizadas por categoria. Aqui estão as categorias mais populares e tipos de extensões disponíveis.
Categorie Principali del Marketplace
| Categoria | Esempi | Valore Aggiunto |
|---|---|---|
| Code Analysis | Linter, security scanner, complexity analyzer | Identifique problemas de qualidade e segurança no código |
| Database | Query builder, schema visualizer, migration helper | Gerenciamento de banco de dados integrado ao chat |
| Cloud & DevOps | AWS helper, Kubernetes manager, CI/CD status | Operações na nuvem sem sair do IDE |
| Testing | Test generator, coverage reporter, E2E runner | Acelere a criação e execução de testes |
| Documentation | API doc generator, diagram creator, README builder | Documentação automatica e aggiornata |
| Project Management | Jira integration, sprint planner, estimation helper | Conexão entre código e gerenciamento de projetos |
| Monitoring | Sentry, DataDog, PagerDuty integrations | Visibilidade de erros e desempenho no chat |
| Design | Figma integration, color palette helper, icon finder | Ponte entre design e implementação |
Melhores práticas para desenvolvimento de extensão
Pendência
- Risposte veloci (timeout < 30s)
- Tratamento elegante de erros
- Documentação clara e completa
- Permessi minimi necessari
- Registro estruturado para depuração
- Rate limiting interno
- Test automatizzati completi
- Versionamento semantico
- Risposta in formato Markdown
- Sugira as próximas etapas ao usuário
Para ser evitado
- Risposte troppo lunghe (> 4000 char)
- Operações destrutivas sem confirmação
- Exponha dados confidenciais nas respostas
- Solicitando permissões desnecessárias
- Ignorar verificação de assinatura
- Respostas sem contexto ou estrutura
- Dependências não mantidas
- Falta de mensagens de erro claras
- Chiamate API sincrone bloccanti
- Falta de endpoints de verificação de integridade
Padrão de resposta recomendado
As respostas das extensões devem seguir um padrão consistente para serem entregues uma experiência de usuário uniforme. Aqui está o formato recomendado:
- Título: Título claro que descreve o resultado
- Risultato: Dati richiesti formattati in modo leggibile
- Contexto: Informações adicionais úteis para interpretação
- Próximas etapas: Sugestão de ações sucessivas possíveis
Segurança de extensões
A segurança é uma prioridade ao usar ou construir extensões. Cada extensão tem acesso potencial a dados confidenciais e deve ser tratada com a mesma atenção dada a qualquer integração de terceiros.
Lista de verificação de segurança para extensões
| Area | Verifica | Rischio se Ignorato |
|---|---|---|
| Autenticazione | Sempre verifique a assinatura das solicitações do GitHub | Richieste fraudolente elaborate |
| Autorizzazione | Verifique as permissões do usuário antes de agir | Escalação de privilégios |
| Input validation | Valida tutti i parametri in ingresso | Injection attacks |
| Secrets | Nunca exponha tokens/chaves nas respostas | Vazamento de credenciais |
| Rate limiting | Implementar limites por usuário e por IP | Denial of service |
| Logging | Log sem dados confidenciais (sem PII, sem token) | Data breach via log |
| HTTPS | Somente comunicações criptografadas | Man-in-the-middle attacks |
| Dependencies | Auditoria regular de dependências | Supply chain attacks |
Conclusão
O ecossistema Copilot Extensions transforma o GitHub Copilot de um assistente codificação isolada para um hub centralizado para todo o fluxo de trabalho de desenvolvimento. Seja conectando bancos de dados, serviços em nuvem, ferramentas de monitoramento ou agentes de IA terceirizados, as extensões permitem que você traga todo o contexto necessário diretamente na conversa com o Copilot.
Para as equipes, as extensões representam uma oportunidade de automatizar fluxos de trabalho repetitivos e centralizar informações. Para desenvolvedores individuais, são uma forma de personalizar a experiência do Copilot com ferramentas específicas para o seu domínio.
No próximo e último artigo da série, abordaremos o tema crucial da segurança e uso responsável do Copilot, explorando proteções diretrizes integradas de privacidade de dados e melhores práticas para uso IA ética e segura no desenvolvimento de software.
Progresso da série
| # | Artigo | Status |
|---|---|---|
| 1 | Fundamentos e Mindset | ✅ |
| 2 | Ideação e Requisitos | ✅ |
| 3 | Arquitetura Backend/Frontend | ✅ |
| 4 | Estrutura de Código | ✅ |
| 5 | Prompt Engineering | ✅ |
| 6 | Testes e Qualidade | ✅ |
| 7 | Documentação | ✅ |
| 8 | Deploy e DevOps | ✅ |
| 9 | Evolução | ✅ |
| 10 | Coding Agent | ✅ |
| 11 | Code Review | ✅ |
| 12 | Copilot Edits | ✅ |
| 13 | GitHub Spark | ✅ |
| 14 | Copilot Spaces | ✅ |
| 15 | Modelos de IA | ✅ |
| 16 | Personalização avançada | ✅ |
| 17 | Enterprise e Business | ✅ |
| 18 | Extensions e Marketplace | 📍 |
| 19 | Segurança e Uso Responsabile | ◻ |