Copilot Extensions e Marketplace
GitHub Copilot est conçu pour être extensible. À travers le Extensions copilote, il est possible d'étendre les capacités de l'assistant IA avec des intégrations tierces, des outils personnalisés et des agents spécialisés. Les extensions they allow you to connect Copilot to databases, cloud services, testing platforms, tools surveillance et bien plus encore, en le transformant en un hub centralisé pour l'ensemble du flux de travail de développement.
Dans cet article, nous explorerons l'écosystème des extensions, les types disponibles, comment les intégrer dans votre flux de travail et comment créer des extensions personnalisées pour les besoins spécifiques de votre équipe.
Vue d'Ensemble de la Série Complète
| # | Article | Focus |
|---|---|---|
| 1 | Foundation e Mindset | Setup e mentalita' |
| 2 | Concept et exigences | De l'idée au MVP |
| 3 | Architecture back-end/front-end | API e database |
| 4 | Structure du Code | Organizzazione e naming |
| 5 | Prompt Engineering | Prompt e Agenti MCP |
| 6 | Testing e qualità' | Unit, integration, E2E |
| 7 | Documentation | 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 | Micro-applications sans code |
| 14 | Copilot Spaces | Contesto condiviso |
| 15 | Modelli AI | Multi-model e selezione |
| 16 | Personalizzazione | Instructions et configuration |
| 17 | Enterprise e Business | Piani, analytics, policy |
| 18 | Sei qui → Extensions e Marketplace | Estensioni e integrazioni |
| 19 | Sicurezza e Uso Responsabile | Security e compliance |
Présentation des extensions Copilot
Les extensions Copilot sont des applications qui étendent les fonctionnalités de GitHub Copilot. Ils sont disponibles sur Marché GitHub et peut être installé tant au niveau individuel qu'organisationnel. Les extensions sont intégrées directement avec Copilot Chat, permettant aux développeurs d'interagir avec des outils externes sans quitter votre IDE ou votre navigateur.
Architecture des extensions
Les extensions Copilot sont construites comme Applications GitHub, ce qui garantit compatibilité multiplateforme et modèle d'authentification et d'autorisation robuste. Lorsqu'un utilisateur appelle une extension via Copilot Chat, la demande est acheminée via l'infrastructure GitHub jusqu'au point de terminaison de l'extension, qui traite la demande et renvoie une réponse.
Flux d'une extension copilote
| Step | Attore | Azione | Détail |
|---|---|---|---|
| 1 | Utente | Invoca l'extension in chat | @extension-name come posso...? |
| 2 | GitHub | Authentifier la demande | Verifica permessi utente e app |
| 3 | GitHub | Transférer vers le point de terminaison | HTTP POST vers le serveur d'extension |
| 4 | Extension | Traiter la demande | Chiama API esterne, analizza dati |
| 5 | Extension | Genera risposta | Testo, codice, link, azioni |
| 6 | GitHub | Restituisce risposta | Formaté dans le chat Copilot |
Types d'extensions
GitHub distingue deux principaux types d'extensions, chacune ayant des caractéristiques et différentes complexités de mise en œuvre.
Full Extensions (Agents)
- Applications complètes avec logique côté serveur
- Possono chiamare API esterne
- Ils gèrent l'état et les sessions
- Supportano flussi complessi multi-step
- Ils nécessitent leur propre infrastructure d’hébergement
- Maggiore flessibilità' e potenza
- Temps de développement : semaines/mois
Skillsets (Lightweight)
- Estensioni leggere e task-specific
- Definite tramite configurazione, poco codice
- Concentrez-vous sur une seule capacité
- Rapide à construire et à déployer
- Nessuna infrastruttura complessa richiesta
- Idéal pour les automatisations simples
- Temps de développement : heures/jours
Skillsets: Estensioni Leggere
Les compétences constituent le moyen le plus simple d’étendre Copilot avec des fonctionnalités personnalisées. Ils sont idéaux pour les tâches spécifiques et répétitives qui ne nécessitent pas de logique complexe. Un ensemble de compétences c'est essentiellement une définition de outils que Copilot peut utiliser pour répondre à des demandes spécifiques.
Structure d'un ensemble de compétences
{
"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"
}
}
}
]
}Cas d'utilisation des compétences
Compétences communes pour les équipes de développement
| Skillset | Fonction | Trigger | Output |
|---|---|---|---|
| Code Formatter | Formater le code selon les normes de l'entreprise | @formatter format this code | Codice formattato + diff |
| Regex Builder | Générer une expression régulière à partir d'une description naturelle | @regex validate Italian fiscal code | Pattern regex + test cases |
| API Mock Generator | Générer des données fictives à partir du schéma OpenAPI | @mock generate 10 users | JSON avec des données réalistes |
| Changelog Writer | Générer un journal des modifications à partir de l'historique des validations | @changelog since v2.1.0 | Markdown changelog formattato |
| Dependency Checker | Verifica dipendenze outdated e vulnerabili | @deps check this project | Rapports avec versions et CVE |
| i18n Helper | Générer des traductions pour les clés manquantes | @i18n translate to Italian | Fichiers JSON/YAML avec traductions |
GitHub Apps Integration
Les extensions Copilot complètes sont construites sous forme d'applications GitHub. Cela signifie que ils héritent de l'intégralité du modèle de sécurité, d'authentification et d'autorisation de GitHub Apps, assurer une intégration sûre et contrôlable.
Autenticazione e Autorizzazione
Modèle de sécurité des extensions
| Livello | Meccanismo | Description |
|---|---|---|
| App-level | JWT (JSON Web Token) | Identifica l'app stessa presso GitHub |
| Installation-level | Installation Access Token | Jeton spécifique pour l'installation dans l'organisation |
| User-level | OAuth User Access Token | Actions au nom de l'utilisateur spécifique |
| Permissions | Granular permissions | Accédez uniquement aux ressources nécessaires (repo, tickets, PR) |
| Webhooks | HMAC-SHA256 signature | Vérifier l'authenticité des événements reçus |
Permessi Richiesti
Chaque extension déclare les autorisations dont elle a besoin. L'administrateur de l'utilisateur ou de l'organisation doit les approuver explicitement avant l’installation. Le principe du moindre privilège doit guider le choix des permis.
{
"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"
}
}Intégration MCP dans le contexte des extensions
Il Protocole de contexte de modèle (MCP) c'est une alternative complémentaire à Extensions Copilot pour connecter des outils externes à Copilot. Alors que les extensions suivez le modèle GitHub Apps, MCP propose un protocole standardisé pour la connexion d’outils et de sources de données.
GitHub MCP Registry
Le registre GitHub MCP est un service de découverte organisé pour les serveurs MCP. Ça marche comme un catalogue qui vous permet de trouver et d'installer rapidement des serveurs MCP vérifiés, réduisant le risque d’intégrations non sécurisées.
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 | Tous les environnements Copilot | Principalmente IDE (VS Code) |
| Governance | GitHub Marketplace review | Responsabilités de l'utilisateur/de l'organisation |
| 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 jeux d'outils sont un mécanisme permettant de regrouper les outils MCP associés sous un seul espace de noms. Cela simplifie la gestion lorsque vous disposez de plusieurs serveurs MCP actif en même temps, vous permettant d'activer/désactiver des groupes d'outils avec une seule opération.
{
"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
L'une des évolutions les plus significatives de l'écosystème Copilot est l'intégration de agents tiers directement sur la plateforme. Ces agents apportez les capacités des modèles d’IA alternatifs dans l’expérience Copilot.
Agenti Disponibili
Third-Party Agents in Copilot
| Agente | Fournisseur | Specializzazione | Disponibilità' | Modèle |
|---|---|---|---|---|
| Claude | Anthropic | Analyse approfondie du code, refactoring, documentation | 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 |
Quand utiliser chaque agent
| Scenario | Agente Consigliato | Motivazione |
|---|---|---|
| Refactoring codebase legacy | Claude | Excellent pour analyser du code complexe et proposer une restructuration progressive |
| Generazione boilerplate rapida | Copilot nativo (GPT-4) | Optimisé pour des réalisations rapides et des échafaudages |
| Analyse de capture d'écran de l'interface utilisateur | Gemini | Compréhension multimodale pour l'analyse des images d'interface |
| Debugging algoritmico complesso | Codex / o3-mini | Fort en raisonnement logique et en résolution de problèmes algorithmiques |
| Documentation technique détaillée | Claude | Produit un texte technique de haute qualité avec un contexte long |
| Migration entre frameworks | Claude o Copilot nativo | Compréhension approfondie des modèles de différents frameworks |
Remarque sur la disponibilité
Des agents tiers sont actuellement en aperçu public et disponible pour les sols uniquement Pro+ e Entreprise. Disponibilité et les modèles spécifiques peuvent changer au fil du temps à mesure que de nouveaux fournisseurs apparaissent intégré à la plateforme.
Le recours à des agents tiers consomme des demandes de primes sur votre budget mensuel. Les requêtes vers des modèles avancés peuvent consommer plus de requêtes premium que de requêtes au modèle de base Copilot.
Construire votre propre extension copilote
Si les extensions disponibles sur la Marketplace ne couvrent pas vos besoins spécifiques équipe, vous pouvez créer votre propre extension Copilot. Le processus nécessite la création d'un Application GitHub avec un point de terminaison de serveur qui gère les requêtes Copilot.
Conditions préalables
Ce dont vous avez besoin pour créer une extension
- Comptes GitHub : Avec accès pour créer des applications GitHub
- Serveurs Web : Pour héberger le point de terminaison de l'extension (Node.js, Python, Go, etc.)
- Domaine HTTPS : Le point de terminaison doit être accessible via HTTPS
- Connaissance de l'API des applications GitHub : Pour gérer l'authentification et les webhooks
- SDK d'extensions Copilot : SDK officiel pour simplifier le développement
Architecture d'une extension
# 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) |
| |
+-------------------+Implémentation de base avec 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}`);
});Tests d'extension
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
Processus de publication
| Step | Azione | Exigences | Tempo Stimato |
|---|---|---|---|
| 1 | Crea GitHub App | Account GitHub, dominio HTTPS | 1 ora |
| 2 | Implementa endpoint | Serveur avec SDK Copilot Extensions | 1-4 semaines |
| 3 | Test locale | Installation d'application privée | 1-2 giorni |
| 4 | Documentation | README, examples, API docs | 2-3 giorni |
| 5 | Soumettre pour examen | Liste complète du marché | 1 giorno |
| 6 | Review GitHub | Respect des directives | 3-10 giorni |
| 7 | Pubblicazione | Approvazione ottenuta | Immediata |
Catégories d'extensions populaires
Le GitHub Marketplace propose des extensions organisées par catégorie. Voici les catégories les plus populaires et les types d’extensions disponibles.
Categorie Principali del Marketplace
| Catégorie | Esempi | Valore Aggiunto |
|---|---|---|
| Code Analysis | Linter, security scanner, complexity analyzer | Identifier les problèmes de qualité et de sécurité dans le code |
| Database | Query builder, schema visualizer, migration helper | Gestion de base de données intégrée au chat |
| Cloud & DevOps | AWS helper, Kubernetes manager, CI/CD status | Opérations cloud sans quitter l'EDI |
| Testing | Test generator, coverage reporter, E2E runner | Accélérez la création et l’exécution des tests |
| Documentation | API doc generator, diagram creator, README builder | Documentation automatique et mise à jour |
| Project Management | Jira integration, sprint planner, estimation helper | Connexion entre le code et la gestion de projet |
| Monitoring | Sentry, DataDog, PagerDuty integrations | Visibilité sur les erreurs et les performances dans le chat |
| Design | Figma integration, color palette helper, icon finder | Pont entre la conception et la mise en œuvre |
Meilleures pratiques pour le développement d’extensions
Faire
- Risposte veloci (timeout < 30s)
- Gestion gracieuse des erreurs
- Documentation claire et complète
- Permessi minimi necessari
- Journalisation structurée pour le débogage
- Rate limiting interno
- Test automatizzati completi
- Versionamento semantico
- Risposta in formato Markdown
- Suggérer les prochaines étapes à l'utilisateur
A éviter
- Risposte troppo lunghe (> 4000 char)
- Opérations destructrices sans confirmation
- Exposer les données sensibles dans les réponses
- Demander des autorisations inutiles
- Ignorer la vérification de la signature
- Réponses sans contexte ni structure
- Dépendances non entretenues
- Manque de messages d'erreur clairs
- Chiamate API sincrone bloccanti
- Manque de points de terminaison de contrôle de santé
Modèle de réponse recommandé
Les réponses des extensions doivent suivre un modèle cohérent pour être livrées une expérience utilisateur uniforme. Voici le format recommandé :
- Titre: Titre clair qui décrit le résultat
- Risultato: Dati richiesti formattati in modo leggibile
- Contexte: Informations complémentaires utiles à l’interprétation
- Prochaines étapes : Suggestions de vos options successives possibles
Sécurité des extensions
La sécurité est une priorité lors de l’utilisation ou de la construction d’extensions. Chaque extension a un accès potentiel à des données sensibles et doit être traitée avec la même attention accordée à toute intégration tierce.
Liste de contrôle de sécurité pour les extensions
| Area | Verifica | Rischio se Ignorato |
|---|---|---|
| Autenticazione | Vérifiez toujours la signature GitHub des requêtes | Richieste fraudolente elaborate |
| Autorizzazione | Vérifiez les autorisations de l'utilisateur avant d'agir | Élévation de privilèges |
| Input validation | Valida tutti i parametri in ingresso | Injection attacks |
| Secrets | N'exposez jamais de jetons/clés dans les réponses | Fuite d'identifiants |
| Rate limiting | Implémenter des limites par utilisateur et par IP | Denial of service |
| Logging | Connectez-vous sans données sensibles (pas de PII, pas de jeton) | Data breach via log |
| HTTPS | Communications cryptées uniquement | Man-in-the-middle attacks |
| Dependencies | Audit régulier des dépendances | Supply chain attacks |
Conclusion
L'écosystème Copilot Extensions transforme GitHub Copilot d'un assistant codage isolé à un centre centralisé pour l'ensemble du flux de travail de développement. Qu'il s'agisse de connecter des bases de données, des services cloud, des outils de surveillance ou des agents IA tiers, les extensions vous permettent d'apporter tout le contexte nécessaire directement dans la conversation avec Copilot.
Pour les équipes, les extensions représentent une opportunité de automatiser flux de travail répétitifs e centraliser les informations. Pour développeurs individuels, sont un moyen de personnaliser l'expérience Copilot avec des outils spécifiques à votre domaine.
Dans le prochain et dernier article de la série, nous aborderons le sujet crucial de sécurité et utilisation responsable de Copilot, explorant les protections directives intégrées de confidentialité des données et meilleures pratiques d'utilisation IA éthique et sûre dans le développement de logiciels.
Progression de la série
| # | Article | État |
|---|---|---|
| 1 | Foundation e Mindset | ✅ |
| 2 | Concept et exigences | ✅ |
| 3 | Architecture back-end/front-end | ✅ |
| 4 | Structure du Code | ✅ |
| 5 | Prompt Engineering | ✅ |
| 6 | Testing e qualità' | ✅ |
| 7 | Documentation | ✅ |
| 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 | Personnalisation avancée | ✅ |
| 17 | Enterprise e Business | ✅ |
| 18 | Extensions e Marketplace | 📍 |
| 19 | Sicurezza e Uso Responsabile | ◻ |