Copilot Extensions e Marketplace
GitHub Copilot ist darauf ausgelegt erweiterbar. Durch die Copilot-Erweiterungenist es möglich, die Fähigkeiten des KI-Assistenten zu erweitern mit Integrationen von Drittanbietern, benutzerdefinierten Tools und spezialisierten Agenten. Die Erweiterungen Sie ermöglichen es Ihnen, Copilot mit Datenbanken, Cloud-Diensten, Testplattformen und Tools zu verbinden Überwachung und vieles mehr und verwandelt es in eine zentrale Drehscheibe für den gesamten Arbeitsablauf der Entwicklung.
In diesem Artikel werden wir das Ökosystem der Erweiterungen, die verfügbaren Typen und wie Sie sie in Ihren Workflow integrieren und benutzerdefinierte Erweiterungen erstellen für die spezifischen Bedürfnisse Ihres Teams.
Übersicht der vollständigen Serie
| # | Artikel | Schwerpunkt |
|---|---|---|
| 1 | Grundlagen und Mindset | Setup und Denkweise |
| 2 | Ideenfindung und Anforderungen | Von der Idee zum MVP |
| 3 | Backend-Architektur/Frontend | API und Datenbank |
| 4 | Codestruktur | Organizzazione e naming |
| 5 | Prompt Engineering | Prompts und MCP-Agenten |
| 6 | Testing und Qualität | Unit, Integration, E2E |
| 7 | Dokumentation | README, API Docs, ADR |
| 8 | Deploy und DevOps | Docker, CI/CD |
| 9 | Evolution | Skalierbarkeit und Wartung |
| 10 | Coding Agent | Agente autonomo GitHub |
| 11 | Code Review | Review automatizzata |
| 12 | Copilot Edits | Multi-File-Editing |
| 13 | GitHub Spark | Codefreie Mikro-Apps |
| 14 | Copilot Spaces | Geteilter Kontext |
| 15 | KI-Modelle | Multi-Model und Auswahl |
| 16 | Personalisierung | Anleitung und Einrichtung |
| 17 | Enterprise e Business | Piani, analytics, policy |
| 18 | Aktuell → Extensions e Marketplace | Extensions e integrazioni |
| 19 | Sicherheit e Uso Responsabile | Sicherheit und Compliance |
Übersicht über Copilot-Erweiterungen
Copilot-Erweiterungen sind Anwendungen, die die Funktionalität von GitHub Copilot erweitern. Sie sind verfügbar auf GitHub-Marktplatz und kann installiert werden sowohl auf individueller als auch auf organisatorischer Ebene. Die Erweiterungen werden direkt integriert mit Copilot Chat, der es Entwicklern ermöglicht, mit externen Tools zu interagieren ohne Ihre IDE oder Ihren Browser zu verlassen.
Erweiterungsarchitektur
Copilot-Erweiterungen werden als erstellt GitHub-Apps, was garantiert plattformübergreifende Kompatibilität und ein robustes Authentifizierungs- und Autorisierungsmodell. Wenn ein Benutzer eine Erweiterung über Copilot Chat aufruft, wird die Anfrage weitergeleitet über die GitHub-Infrastruktur zum Erweiterungsendpunkt, der die Anfrage verarbeitet und gibt eine Antwort zurück.
Ablauf einer Copilot-Erweiterung
| Step | Attore | Azione | Detail |
|---|---|---|---|
| 1 | Utente | Invoca l'extension in chat | @extension-name come posso...? |
| 2 | GitHub | Authentifizieren Sie die Anfrage | Verifica permessi utente e app |
| 3 | GitHub | Zum Endpunkt weiterleiten | HTTP POST an den Erweiterungsserver |
| 4 | Extension | Bearbeiten Sie die Anfrage | Chiama API esterne, analizza dati |
| 5 | Extension | Genera risposta | Testo, codice, link, azioni |
| 6 | GitHub | Restituisce risposta | Im Copilot-Chat formatiert |
Arten von Erweiterungen
GitHub unterscheidet zwei Haupttypen von Erweiterungen mit jeweils eigenen Merkmalen und unterschiedliche Implementierungskomplexitäten.
Full Extensions (Agents)
- Komplette Anwendungen mit serverseitiger Logik
- Possono chiamare API esterne
- Sie verwalten Status und Sitzungen
- Supportano flussi complessi multi-step
- Sie benötigen eine eigene Hosting-Infrastruktur
- Maggiore flessibilità' e potenza
- Entwicklungszeit: Wochen/Monate
Skillsets (Lightweight)
- Extensions leggere e task-specific
- Definite tramite configurazione, poco codice
- Konzentrieren Sie sich auf eine einzelne Fähigkeit.
- Schnell zu erstellen und bereitzustellen
- Nessuna infrastruttura complessa richiesta
- Ideal für einfache Automatisierungen
- Entwicklungszeit: Stunden/Tage
Skillsets: Extensions Leggere
Skillsets sind die einfachste Möglichkeit, Copilot mit benutzerdefinierten Funktionen zu erweitern. Sie eignen sich ideal für spezifische, sich wiederholende Aufgaben, die keine komplexe Logik erfordern. Ein Skillset es ist im Wesentlichen eine Definition von Werkzeuge dass Copilot für verwenden kann auf konkrete Anfragen reagieren.
Struktur eines Skillsets
{
"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"
}
}
}
]
}Anwendungsfälle für Skillsets
Gemeinsame Fähigkeiten für Entwicklungsteams
| Skillset | Funktion | Trigger | Output |
|---|---|---|---|
| Code Formatter | Formatieren Sie den Code gemäß den Unternehmensstandards | @formatter format this code | Codice formattato + diff |
| Regex Builder | Generieren Sie einen regulären Ausdruck aus einer natürlichen Beschreibung | @regex validate Italian fiscal code | Pattern regex + test cases |
| API Mock Generator | Generieren Sie Scheindaten aus dem OpenAPI-Schema | @mock generate 10 users | JSON mit realistischen Daten |
| Changelog Writer | Generieren Sie ein Änderungsprotokoll aus dem Commit-Verlauf | @changelog since v2.1.0 | Markdown changelog formattato |
| Dependency Checker | Verifica dipendenze outdated e vulnerabili | @deps check this project | Berichte mit Versionen und CVEs |
| i18n Helper | Generieren Sie Übersetzungen für fehlende Schlüssel | @i18n translate to Italian | JSON/YAML-Dateien mit Übersetzungen |
GitHub Apps Integration
Die kompletten Copilot-Erweiterungen sind als GitHub-Apps erstellt. Das bedeutet das Sie erben das gesamte Sicherheits-, Authentifizierungs- und Autorisierungsmodell von GitHub Apps. Gewährleistung einer sicheren und kontrollierbaren Integration.
Autenticazione e Autorizzazione
Sicherheitsmodell von Erweiterungen
| Livello | Meccanismo | Beschreibung |
|---|---|---|
| App-level | JWT (JSON Web Token) | Identifica l'app stessa presso GitHub |
| Installation-level | Installation Access Token | Spezifisches Token für die Installation in der Organisation |
| User-level | OAuth User Access Token | Aktionen im Namen des jeweiligen Benutzers |
| Permissions | Granular permissions | Greifen Sie nur auf die notwendigen Ressourcen zu (Repo, Issues, PRs) |
| Webhooks | HMAC-SHA256 signature | Überprüfen Sie die Authentizität der empfangenen Ereignisse |
Permessi Richiesti
Jede Erweiterung deklariert die Berechtigungen, die sie benötigt. Der Benutzer- oder Organisationsadministrator Sie müssen diese vor der Installation ausdrücklich genehmigen. Das Prinzip der geringsten Privilegien muss die Wahl der Genehmigungen leiten.
{
"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"
}
}MCP-Integration im Erweiterungskontext
Il Model Context Protocol (MCP) es ist eine ergänzende Alternative zu Copilot-Erweiterungen zur Anbindung externer Tools an Copilot. Während die Erweiterungen Folgen Sie dem GitHub Apps-Modell. MCP bietet ein standardisiertes Protokoll für die Verbindung von Tools und Datenquellen.
GitHub MCP Registry
Die GitHub MCP Registry ist ein kuratierter Erkennungsdienst für MCP-Server. Es funktioniert wie ein Katalog, mit dem Sie verifizierte MCP-Server schnell finden und installieren können, Reduzierung des Risikos unsicherer Integrationen.
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 | Alle Copilot-Umgebungen | Principalmente IDE (VS Code) |
| Governance | GitHub Marketplace review | Verantwortlichkeiten des Benutzers/der 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 Werkzeugsätze sind ein Mechanismus zum Gruppieren verwandter MCP-Tools ein einzelner Namensraum. Dies vereinfacht die Verwaltung, wenn Sie über viele MCP-Server verfügen gleichzeitig aktiv sein, so dass Sie Gruppen von Werkzeugen aktivieren/deaktivieren können mit einer einzigen Operation.
{
"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
Eine der bedeutendsten Entwicklungen des Copilot-Ökosystems ist die Integration von Drittanbieter direkt auf der Plattform. Diese Agenten Bringen Sie die Fähigkeiten alternativer KI-Modelle in das Copilot-Erlebnis ein.
Agenti Disponibili
Third-Party Agents in Copilot
| Agente | Provider | Specializzazione | Disponibilità' | Modello |
|---|---|---|---|---|
| Claude | Anthropic | Eingehende Codeanalyse, Refactoring, Dokumentation | 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 |
Wann man jeden Agenten verwenden sollte
| Scenario | Agente Consigliato | Motivazione |
|---|---|---|
| Refactoring codebase legacy | Claude | Hervorragend darin, komplexen Code zu analysieren und eine schrittweise Umstrukturierung vorzuschlagen |
| Generazione boilerplate rapida | Copilot nativo (GPT-4) | Optimiert für schnelle Fertigstellungen und Gerüste |
| UI-Screenshot-Analyse | Gemini | Multimodales Verständnis zur Analyse von Schnittstellenbildern |
| Debugging algoritmico complesso | Codex / o3-mini | Stark im logischen Denken und algorithmischen Problemlösen |
| Detaillierte technische Dokumentation | Claude | Erstellt hochwertige technische Texte mit ausführlichem Kontext |
| Migration zwischen Frameworks | Claude o Copilot nativo | Tiefes Verständnis der Muster verschiedener Frameworks |
Hinweis zur Verfügbarkeit
Derzeit sind Drittanbieter-Agenten im Einsatz öffentliche Vorschau und verfügbar Nur für Böden Pro+ e Unternehmen. Verfügbarkeit und bestimmte Modelle können sich im Laufe der Zeit ändern, wenn neue Anbieter hinzukommen in die Plattform integriert.
Durch die Nutzung von Drittanbieter-Agenten werden Premium-Anfragen aus Ihrem Monatsbudget verbraucht. Anfragen an fortgeschrittene Modelle verbrauchen möglicherweise mehr Premium-Anfragen als Anfragen zum Basis-Copilot-Modell.
Erstellen Sie Ihre eigene Copilot-Erweiterung
Wenn die auf dem Marketplace verfügbaren Erweiterungen Ihre spezifischen Anforderungen nicht abdecken Team können Sie Ihre eigene Copilot-Erweiterung erstellen. Der Prozess erfordert die Erstellung eines GitHub-App mit einem Server-Endpunkt, der Copilot-Anfragen verarbeitet.
Voraussetzungen
Was Sie zum Erstellen einer Erweiterung benötigen
- GitHub-Konten: Mit Zugriff zum Erstellen von GitHub-Apps
- Webserver: Zum Hosten des Erweiterungsendpunkts (Node.js, Python, Go usw.)
- HTTPS-Domäne: Der Endpunkt muss über HTTPS erreichbar sein
- Kenntnisse der GitHub Apps API: Zur Verwaltung von Authentifizierung und Webhooks
- Copilot Extensions SDK: Offizielles SDK zur Vereinfachung der Entwicklung
Architektur einer Erweiterung
# 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) |
| |
+-------------------+Grundlegende Implementierung mit 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}`);
});Erweiterungstests
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
Veröffentlichungsprozess
| Step | Azione | Anforderungen | Tempo Stimato |
|---|---|---|---|
| 1 | Crea GitHub App | Account GitHub, dominio HTTPS | 1 ora |
| 2 | Implementa endpoint | Server mit Copilot Extensions SDK | 1-4 Wochen |
| 3 | Test locale | Private App-Installation | 1-2 giorni |
| 4 | Dokumentation | README, examples, API docs | 2-3 giorni |
| 5 | Zur Überprüfung einreichen | Vollständige Marktplatzliste | 1 giorno |
| 6 | Review GitHub | Einhaltung der Richtlinien | 3-10 giorni |
| 7 | Pubblicazione | Approvazione ottenuta | Immediata |
Beliebte Erweiterungskategorien
Der GitHub Marketplace bietet nach Kategorien geordnete Erweiterungen. Hier sind die Kategorien Die beliebtesten und verfügbaren Arten von Erweiterungen.
Categorie Principali del Marketplace
| Kategorie | Esempi | Valore Aggiunto |
|---|---|---|
| Code Analysis | Linter, security scanner, complexity analyzer | Identifizieren Sie Qualitäts- und Sicherheitsprobleme im Code |
| Database | Query builder, schema visualizer, migration helper | Datenbankverwaltung im Chat integriert |
| Cloud & DevOps | AWS helper, Kubernetes manager, CI/CD status | Cloud-Vorgänge, ohne die IDE zu verlassen |
| Testing | Test generator, coverage reporter, E2E runner | Beschleunigen Sie die Erstellung und Ausführung von Tests |
| Documentation | API doc generator, diagram creator, README builder | Dokumentation automatica e aggiornata |
| Project Management | Jira integration, sprint planner, estimation helper | Verbindung zwischen Code und Projektmanagement |
| Monitoring | Sentry, DataDog, PagerDuty integrations | Sichtbarkeit von Fehlern und Leistung im Chat |
| Design | Figma integration, color palette helper, icon finder | Brücke zwischen Design und Umsetzung |
Best Practices für die Erweiterungsentwicklung
Zu tun
- Risposte veloci (timeout < 30s)
- Anmutige Fehlerbehandlung
- Klare und vollständige Dokumentation
- Permessi minimi necessari
- Strukturierte Protokollierung zum Debuggen
- Rate limiting interno
- Test automatizzati completi
- Versionamento semantico
- Risposta in formato Markdown
- Schlagen Sie dem Benutzer die nächsten Schritte vor
Zu vermeiden
- Risposte troppo lunghe (> 4000 char)
- Zerstörerische Operationen ohne Bestätigung
- Legen Sie vertrauliche Daten in Antworten offen
- Anfordern unnötiger Berechtigungen
- Signaturüberprüfung ignorieren
- Antworten ohne Kontext oder Struktur
- Nicht gepflegte Abhängigkeiten
- Fehlen klarer Fehlermeldungen
- Chiamate API sincrone bloccanti
- Mangel an Endpunkten für die Gesundheitsprüfung
Empfohlenes Antwortmuster
Die Antworten auf Erweiterungen sollten einem einheitlichen Muster folgen ein einheitliches Benutzererlebnis. Hier ist das empfohlene Format:
- Titel: Klare Überschrift, die das Ergebnis beschreibt
- Risultato: Dati richiesti formattati in modo leggibile
- Kontext: Zusätzliche Informationen, die für die Interpretation nützlich sind
- Nächste Schritte: Vorschläge für aufeinanderfolgende Möglichkeiten
Erweiterungen Sicherheit
Bei der Nutzung oder dem Bau von Erweiterungen steht die Sicherheit an erster Stelle. Jede Erweiterung hat potenziellen Zugriff auf sensible Daten und muss behandelt werden wobei die gleiche Aufmerksamkeit auf die Integration Dritter gelegt wird.
Checkliste Sicherheit für Erweiterungen
| Area | Verifica | Rischio se Ignorato |
|---|---|---|
| Autenticazione | Überprüfen Sie immer die GitHub-Signatur von Anfragen | Richieste fraudolente elaborate |
| Autorizzazione | Überprüfen Sie die Berechtigungen des Benutzers, bevor Sie Maßnahmen ergreifen | Eskalation von Berechtigungen |
| Input validation | Valida tutti i parametri in ingresso | Injection attacks |
| Secrets | Geben Sie niemals Token/Schlüssel in Antworten preis | Anmeldedatenleck |
| Rate limiting | Implementieren Sie Grenzwerte pro Benutzer und pro IP | Denial of service |
| Logging | Protokoll ohne sensible Daten (keine PII, kein Token) | Data breach via log |
| HTTPS | Nur verschlüsselte Kommunikation | Man-in-the-middle attacks |
| Dependencies | Regelmäßige Prüfung der Abhängigkeiten | Supply chain attacks |
Fazit
Das Copilot Extensions-Ökosystem verwandelt GitHub Copilot in einen Assistenten Codierung isoliert auf a zentraler Hub für den gesamten Workflow der Entwicklung. Ob Anbindung von Datenbanken, Cloud-Diensten, Monitoring-Tools oder KI-Agenten von Drittanbietern ermöglichen Ihnen Erweiterungen, den gesamten Kontext bereitzustellen direkt im Gespräch mit Copilot benötigt.
Für Teams stellen Erweiterungen eine Chance dar automatisieren sich wiederholende Arbeitsabläufe e Informationen zentralisieren. Für Einzelne Entwickler bieten eine Möglichkeit, das Copilot-Erlebnis individuell anzupassen mit für Ihre Domain spezifischen Tools.
Im nächsten und letzten Artikel der Serie werden wir uns mit dem entscheidenden Thema befassen Sicherheit und verantwortungsvoller Umgang von Copilot, Erkundung von Schutzmaßnahmen Integrierte Datenschutzrichtlinien und Best Practices für die Nutzung ethische und sichere KI in der Softwareentwicklung.
Serienfortschritt
| # | Artikel | Status |
|---|---|---|
| 1 | Grundlagen und Mindset | ✅ |
| 2 | Ideenfindung und Anforderungen | ✅ |
| 3 | Backend-Architektur/Frontend | ✅ |
| 4 | Codestruktur | ✅ |
| 5 | Prompt Engineering | ✅ |
| 6 | Testing und Qualität | ✅ |
| 7 | Dokumentation | ✅ |
| 8 | Deploy und DevOps | ✅ |
| 9 | Evolution | ✅ |
| 10 | Coding Agent | ✅ |
| 11 | Code Review | ✅ |
| 12 | Copilot Edits | ✅ |
| 13 | GitHub Spark | ✅ |
| 14 | Copilot Spaces | ✅ |
| 15 | KI-Modelle | ✅ |
| 16 | Erweiterte Personalisierung | ✅ |
| 17 | Enterprise e Business | ✅ |
| 18 | Extensions e Marketplace | 📍 |
| 19 | Sicherheit e Uso Responsabile | ◻ |