Copilot Extensions e Marketplace
GitHub Copilot está diseñado para ser extensible. A través del Extensiones de copiloto, es posible ampliar las capacidades del asistente de IA con integraciones de terceros, herramientas personalizadas y agentes especializados. las extensiones le permiten conectar Copilot a bases de datos, servicios en la nube, plataformas de prueba y herramientas. monitoreo y mucho más, transformándolo en un centro centralizado para todo el flujo de trabajo de desarrollo.
En este artículo exploraremos el ecosistema de extensiones, los tipos disponibles, cómo integrarlos en su flujo de trabajo y cómo crear extensiones personalizadas para las necesidades específicas de su equipo.
Vista General de la Serie Completa
| # | Artículo | Enfoque |
|---|---|---|
| 1 | Foundation e Mindset | Setup e mentalita' |
| 2 | Concepto y requisitos | De idea a MVP |
| 3 | Arquitectura de backend/frontend | API e database |
| 4 | Estructura del Código | Organizzazione e naming |
| 5 | Prompt Engineering | Prompt e Agenti MCP |
| 6 | Testing e qualità' | Unit, integration, E2E |
| 7 | Documentación | README, API docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evoluzione | Scalabilità' e manutenzione |
| 10 | Coding Agent | Agente autonomo GitHub |
| 11 | Code Review | Review automatizzata |
| 12 | Copilot Edits | Editing multi-file |
| 13 | GitHub Spark | Microaplicaciones sin código |
| 14 | Copilot Spaces | Contesto condiviso |
| 15 | Modelli AI | Multi-model e selezione |
| 16 | Personalizzazione | Instrucciones y configuración |
| 17 | Enterprise e Business | Piani, analytics, policy |
| 18 | Sei qui → Extensions e Marketplace | Estensioni e integrazioni |
| 19 | Sicurezza e Uso Responsabile | Security e compliance |
Descripción general de las extensiones Copilot
Las extensiones de Copilot son aplicaciones que amplían la funcionalidad de GitHub Copilot. Están disponibles en Mercado GitHub y se puede instalar tanto a nivel individual como organizacional. Las extensiones se integran directamente con Copilot Chat, que permite a los desarrolladores interactuar con herramientas externas sin salir de su IDE o navegador.
Arquitectura de extensiones
Las extensiones Copilot están construidas como Aplicaciones GitHub, que garantiza compatibilidad multiplataforma y un modelo robusto de autenticación y autorización. Cuando un usuario invoca una extensión a través de Copilot Chat, la solicitud se enruta a través de la infraestructura de GitHub hasta el punto final de la extensión, que procesa la solicitud y devuelve una respuesta.
Flujo de una extensión copiloto
| Step | Attore | Azione | Detalle |
|---|---|---|---|
| 1 | Utente | Invoca l'extension in chat | @extension-name come posso...? |
| 2 | GitHub | Autenticar la solicitud | Verifica permessi utente e app |
| 3 | GitHub | Reenviar al punto final | HTTP POST al servidor de extensión |
| 4 | Extension | Procesar la solicitud | Chiama API esterne, analizza dati |
| 5 | Extension | Genera risposta | Testo, codice, link, azioni |
| 6 | GitHub | Restituisce risposta | Formateado en el chat de Copilot |
Tipos de extensiones
GitHub distingue dos tipos principales de extensiones, cada una con características y diferentes complejidades de implementación.
Full Extensions (Agents)
- Aplicaciones completas con lógica del lado del servidor
- Possono chiamare API esterne
- Gestionan estados y sesiones.
- Supportano flussi complessi multi-step
- Requieren su propia infraestructura de hosting
- Maggiore flessibilità' e potenza
- Tiempo de desarrollo: semanas/meses
Skillsets (Lightweight)
- Estensioni leggere e task-specific
- Definite tramite configurazione, poco codice
- Centrarse en una única capacidad'
- Rápido de construir e implementar
- Nessuna infrastruttura complessa richiesta
- Ideal para automatizaciones simples
- Tiempo de desarrollo: horas/días
Skillsets: Estensioni Leggere
Los conjuntos de habilidades son la forma más sencilla de ampliar Copilot con funciones personalizadas. Son ideales para tareas específicas y repetitivas que no requieren una lógica compleja. Un conjunto de habilidades es esencialmente una definición de herramientas que Copilot puede utilizar para responder a solicitudes específicas.
Estructura de un 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 conjuntos de habilidades
Conjuntos de habilidades comunes para equipos de desarrollo
| Skillset | Función | Trigger | Output |
|---|---|---|---|
| Code Formatter | Formatear el código según los estándares de la empresa. | @formatter format this code | Codice formattato + diff |
| Regex Builder | Generar expresiones regulares a partir de una descripción natural. | @regex validate Italian fiscal code | Pattern regex + test cases |
| API Mock Generator | Genere datos simulados a partir del esquema OpenAPI | @mock generate 10 users | JSON con datos realistas |
| Changelog Writer | Generar registro de cambios a partir del historial de confirmaciones | @changelog since v2.1.0 | Markdown changelog formattato |
| Dependency Checker | Verifica dipendenze outdated e vulnerabili | @deps check this project | Informes con versiones y CVE |
| i18n Helper | Generar traducciones para claves faltantes | @i18n translate to Italian | Archivos JSON/YAML con traducciones |
GitHub Apps Integration
Las extensiones Copilot completas están creadas como aplicaciones GitHub. Esto significa que heredan todo el modelo de seguridad, autenticación y autorización de GitHub Apps, garantizando una integración segura y controlable.
Autenticazione e Autorizzazione
Modelo de seguridad de extensiones
| Livello | Meccanismo | Descripción |
|---|---|---|
| App-level | JWT (JSON Web Token) | Identifica l'app stessa presso GitHub |
| Installation-level | Installation Access Token | Token específico para instalación en la organización |
| User-level | OAuth User Access Token | Acciones en nombre del usuario específico |
| Permissions | Granular permissions | Acceda solo a los recursos necesarios (repo, issues, relaciones públicas) |
| Webhooks | HMAC-SHA256 signature | Verificar la autenticidad de los eventos recibidos |
Permessi Richiesti
Cada extensión declara los permisos que necesita. El usuario u administrador de la organización. debe aprobarlos explícitamente antes de la instalación. El principio de privilegio mínimo debe guiar la elección de los permisos.
{
"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"
}
}Integración de MCP en el contexto de las extensiones
Il Protocolo de contexto modelo (MCP) es una alternativa complementaria a Extensiones de Copilot para conectar herramientas externas a Copilot. Mientras que las extensiones Siga el modelo de GitHub Apps, MCP ofrece un protocolo estandarizado para la conexión. de herramientas y fuentes de datos.
GitHub MCP Registry
El Registro MCP de GitHub es un servicio de descubrimiento seleccionado para servidores MCP. Funciona como un catálogo que le permite encontrar e instalar rápidamente servidores MCP verificados, reduciendo el riesgo de integraciones 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 los entornos de copiloto | Principalmente IDE (VS Code) |
| Governance | GitHub Marketplace review | Responsabilidad del usuario/org |
| 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 herramientas son un mecanismo para agrupar herramientas MCP relacionadas en un único espacio de nombres. Esto simplifica la administración cuando tiene muchos servidores MCP. activo al mismo tiempo, permitiéndole habilitar/deshabilitar grupos de herramientas con una sola operación.
{
"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
Una de las evoluciones más significativas del ecosistema Copilot es la integración de agentes de terceros directamente en la plataforma. Estos agentes incorporar las capacidades de modelos alternativos de IA a la experiencia Copilot.
Agenti Disponibili
Third-Party Agents in Copilot
| Agente | Proveedor | Specializzazione | Disponibilità' | Modelo |
|---|---|---|---|---|
| Claude | Anthropic | Análisis de código en profundidad, refactorización y documentación. | 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 |
Cuándo utilizar cada agente
| Scenario | Agente Consigliato | Motivazione |
|---|---|---|
| Refactoring codebase legacy | Claude | Excelente para analizar código complejo y proponer una reestructuración gradual. |
| Generazione boilerplate rapida | Copilot nativo (GPT-4) | Optimizado para terminaciones y andamios rápidos |
| Análisis de captura de pantalla de la interfaz de usuario | Gemini | Comprensión multimodal para analizar imágenes de interfaz. |
| Debugging algoritmico complesso | Codex / o3-mini | Fuerte en razonamiento lógico y resolución de problemas algorítmicos. |
| Documentación técnica detallada | Claude | Produce texto técnico de alta calidad con un contexto extenso. |
| Migración entre marcos | Claude o Copilot nativo | Comprensión profunda de los patrones de diferentes marcos. |
Nota sobre disponibilidad
Actualmente hay agentes externos en vista previa pública y disponible solo para pisos Pro+ e Empresa. Disponibilidad y los modelos específicos pueden cambiar con el tiempo a medida que aparecen nuevos proveedores Integrado en la plataforma.
El uso de agentes externos consume solicitudes premium de su presupuesto mensual. Las solicitudes de modelos avanzados pueden consumir más solicitudes premium que solicitudes al modelo básico de Copilot.
Construyendo su propia extensión Copilot
Si las extensiones disponibles en Marketplace no cubren sus necesidades específicas equipo, puede crear su propia extensión Copilot. El proceso requiere la creación de un Aplicación GitHub con un punto final de servidor que maneja las solicitudes de Copilot.
Requisitos previos
Lo que necesita para crear una extensión
- Cuentas de GitHub: Con acceso para crear aplicaciones GitHub
- Servidores web: Para alojar el punto final de la extensión (Node.js, Python, Go, etc.)
- Dominio HTTPS: El punto final debe ser accesible a través de HTTPS.
- Conocimiento de la API de aplicaciones de GitHub: Para gestionar la autenticación y los webhooks
- SDK de extensiones de copiloto: SDK oficial para simplificar el desarrollo
Arquitectura de una extensión
# 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) |
| |
+-------------------+Implementación básica con 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}`);
});Pruebas de extensión
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
Proceso de publicación
| Step | Azione | Requisitos | Tempo Stimato |
|---|---|---|---|
| 1 | Crea GitHub App | Account GitHub, dominio HTTPS | 1 ora |
| 2 | Implementa endpoint | Servidor con SDK de extensiones Copilot | 1-4 semanas |
| 3 | Test locale | Instalación de aplicaciones privadas | 1-2 giorni |
| 4 | Documentación | README, examples, API docs | 2-3 giorni |
| 5 | Enviar para revisión | Listado completo del mercado | 1 giorno |
| 6 | Review GitHub | Cumplimiento de las directrices | 3-10 giorni |
| 7 | Pubblicazione | Approvazione ottenuta | Immediata |
Categorías de extensiones populares
GitHub Marketplace ofrece extensiones organizadas por categoría. Aquí están las categorías Más populares y tipos de extensiones disponibles.
Categorie Principali del Marketplace
| Categoría | Esempi | Valore Aggiunto |
|---|---|---|
| Code Analysis | Linter, security scanner, complexity analyzer | Identificar problemas de calidad y seguridad en el código. |
| Database | Query builder, schema visualizer, migration helper | Gestión de base de datos integrada en el chat. |
| Cloud & DevOps | AWS helper, Kubernetes manager, CI/CD status | Operaciones en la nube sin salir del IDE |
| Testing | Test generator, coverage reporter, E2E runner | Acelere la creación y ejecución de pruebas |
| Documentation | API doc generator, diagram creator, README builder | Documentación automática y actualizada. |
| Project Management | Jira integration, sprint planner, estimation helper | Conexión entre código y gestión de proyectos |
| Monitoring | Sentry, DataDog, PagerDuty integrations | Visibilidad de errores y rendimiento en el chat. |
| Design | Figma integration, color palette helper, icon finder | Puente entre diseño e implementación |
Mejores prácticas para el desarrollo de extensiones
Hacer
- Risposte veloci (timeout < 30s)
- Manejo elegante de errores
- Documentación clara y completa
- Permessi minimi necessari
- Registro estructurado para depuración
- Rate limiting interno
- Test automatizzati completi
- Versionamento semantico
- Risposta in formato Markdown
- Sugerir próximos pasos al usuario
Para ser evitado
- Risposte troppo lunghe (> 4000 char)
- Operaciones destructivas sin confirmación
- Exponer datos confidenciales en las respuestas
- Solicitar permisos innecesarios
- Ignorar la verificación de firma
- Respuestas sin contexto ni estructura
- Dependencias no mantenidas
- Falta de mensajes de error claros.
- Chiamate API sincrone bloccanti
- Falta de puntos finales de control de salud
Patrón de respuesta recomendado
Las respuestas de las extensiones deben seguir un patrón consistente para entregar una experiencia de usuario uniforme. Aquí está el formato recomendado:
- Título: Título claro que describe el resultado.
- Risultato: Dati richiesti formattati in modo leggibile
- Contexto: Información adicional útil para la interpretación.
- Próximos pasos: Suggerimenti su azioni posibilidades sucesivas
Seguridad de extensiones
La seguridad es una prioridad al utilizar o construir ampliaciones. Cada extensión tiene acceso potencial a datos confidenciales y debe ser tratada con la misma atención prestada a cualquier integración de terceros.
Lista de verificación de seguridad para extensiones
| Area | Verifica | Rischio se Ignorato |
|---|---|---|
| Autenticazione | Verifique siempre la firma de GitHub de las solicitudes | Richieste fraudolente elaborate |
| Autorizzazione | Verifique los permisos del usuario antes de tomar medidas | Escalada de privilegios |
| Input validation | Valida tutti i parametri in ingresso | Injection attacks |
| Secrets | Nunca exponga tokens/claves en las respuestas | Fuga de credenciales |
| Rate limiting | Implementar límites por usuario y por IP | Denial of service |
| Logging | Iniciar sesión sin datos confidenciales (sin PII, sin token) | Data breach via log |
| HTTPS | Sólo comunicaciones cifradas | Man-in-the-middle attacks |
| Dependencies | Auditoría periódica de las dependencias. | Supply chain attacks |
Conclusión
El ecosistema Copilot Extensions transforma GitHub Copilot de un asistente codificación aislada a un centro centralizado para todo el flujo de trabajo de desarrollo. Ya sea conectando bases de datos, servicios en la nube, herramientas de monitoreo o agentes de IA de terceros, las extensiones le permiten traer todo el contexto necesario directamente en la conversación con Copilot.
Para los equipos, las extensiones representan una oportunidad para automatizar flujos de trabajo repetitivos e centralizar la información. Para desarrolladores individuales, son una forma de personalizar la experiencia Copilot con herramientas específicas para su dominio.
En el próximo y último artículo de la serie, abordaremos el tema crucial de seguridad y uso responsable de Copilot, explorando protecciones Directrices integradas de privacidad de datos y mejores prácticas de uso. IA ética y segura en el desarrollo de software.
Progreso de la serie
| # | Artículo | Estado |
|---|---|---|
| 1 | Foundation e Mindset | ✅ |
| 2 | Concepto y requisitos | ✅ |
| 3 | Arquitectura de backend/frontend | ✅ |
| 4 | Estructura del Código | ✅ |
| 5 | Prompt Engineering | ✅ |
| 6 | Testing e qualità' | ✅ |
| 7 | Documentación | ✅ |
| 8 | Deploy e DevOps | ✅ |
| 9 | Evoluzione | ✅ |
| 10 | Coding Agent | ✅ |
| 11 | Code Review | ✅ |
| 12 | Copilot Edits | ✅ |
| 13 | GitHub Spark | ✅ |
| 14 | Copilot Spaces | ✅ |
| 15 | Modelli AI | ✅ |
| 16 | Personalización avanzada | ✅ |
| 17 | Enterprise e Business | ✅ |
| 18 | Extensions e Marketplace | 📍 |
| 19 | Sicurezza e Uso Responsabile | ◻ |