Personnalisation, extension et validation de l’agent de codage Copilot

  • 5 minutes

L’agent de codage GitHub Copilot s’exécute dans un environnement GitHub Actions sécurisé et éphémère. Avec quelques étapes de configuration, vous pouvez pré-configurer cet environnement pour améliorer la fiabilité et la vitesse, étendre les capacités de l'agent à l'aide d'outils externes via le protocole Model Context (MCP), et appliquer les meilleures pratiques pour tester et valider les résultats de l'agent avant l'intégration.

À la fin de cette unité, vous pourrez :

  • Préinstaller des outils, des dépendances et des secrets pour personnaliser l’environnement de développement de l’agent.
  • Étendez les fonctionnalités de l’agent à l’aide du protocole MCP (Model Context Protocol).
  • Testez et validez efficacement la sortie de l’agent avant de fusionner les modifications.

Préparation de l’environnement de développement

Préinstaller les outils et les dépendances aveccopilot-setup-steps.yml

Créez .github/workflows/copilot-setup-steps.yml sur la branche par défaut de votre référentiel. Le flux de travail doit définir un seul travail nommé copilot-setup-steps. Incluez les étapes nécessaires pour installer les dépendances ou configurer des outils.

Exemple pour TypeScript :

name: "Copilot Setup Steps"

on:
  workflow_dispatch:
  push:
    paths:
      - .github/workflows/copilot-setup-steps.yml
  pull_request:
    paths:
      - .github/workflows/copilot-setup-steps.yml

jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - name: Checkout code
        uses: actions/checkout@v5
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
      - name: Install JavaScript dependencies
        run: npm ci

Clés de configuration autorisées pour le copilot-setup-steps travail : steps, permissions, runs-on, container, services, snapshot, timeout-minutes (≤ 59). Toute profondeur de récupération actions/checkout est remplacée pour permettre une restauration sécurisée. Le flux de travail d’installation s’exécute autonome (vous pouvez donc le valider), puis automatiquement avant le démarrage de l’agent.

Exécuteurs de plus grande taille hébergés par GitHub

  • Ajouter d'abord les plus grands coureurs
  • Dans copilot-setup-steps.yml, définissez runs-on sur l’étiquette/le groupe (par exemple, ubuntu-4-core).
  • Seuls les exécuteurs Ubuntu x64 sont pris en charge ; Les exécuteurs auto-hébergés ne sont pas pris en charge.

Git LFS

Si vous utilisez le stockage de fichiers volumineux Git, activez-le dans les étapes de configuration :

jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@v5
        with:
          lfs: true

Personnalisation du pare-feu

L’accès Internet par défaut est limité pour réduire le risque d’exfiltration. Vous pouvez personnaliser ou désactiver le pare-feu par stratégie d’organisation si nécessaire.

Étendre avec le protocole MCP (Model Context Protocol)

MCP est une norme ouverte pour connecter des LLM à des outils et des données. L’agent peut utiliser des outils fournis par des serveurs MCP locaux ou distants pour développer ses fonctionnalités.

Remarque : l’agent de codage Copilot prend uniquement en charge les outils MCP (pas les ressources ou les invites). Les serveurs MCP distants qui nécessitent OAuth ne sont pas pris en charge.

Serveurs MCP par défaut

  • Serveur MCP GitHub : Accédez aux tickets, aux pull requests et aux données GitHub avec un jeton de lecture seule par défaut, limité au référentiel actuel (vous pouvez personnaliser le jeton).
  • Serveur MCP playwright : Lisez, interagissez et prenez des captures d’écran des pages web accessibles dans l’environnement de l’agent (localhost/127.0.0.1).

Configuration du référentiel

Les administrateurs peuvent déclarer des serveurs MCP via une configuration JSON dans le dépôt. Une fois configuré, l’agent utilise de manière autonome les outils disponibles, sans solliciter d’approbation à chaque utilisation. Consultez Extension de l’agent de codage Copilot GitHub avec MCP.

Bonnes pratiques

  • Passez en revue les serveurs MCP tiers pour connaître les implications de qualité des performances et des sorties.
  • Préférer les outils de lecture ; si des outils d’écriture existent, autorisez uniquement ce qui est nécessaire.
  • Validez soigneusement la configuration MCP avant d’enregistrer.

Tester et valider la sortie de l’agent

Vous restez responsable de la qualité et de la sécurité :

  • Exécutez l’intégration continue (tests, linters, analyse) sur chaque demande de tirage d’agent ; ces vérifications ne s’exécutent pas tant que vous n’avez pas cliqué sur Approuver et exécuter des flux de travail.
  • Inspectez manuellement les zones sensibles ou à impact élevé.
  • Demandez à l’agent de générer des tests (par exemple, « Ajouter des tests unitaires Jest pour toutes les fonctions dans src/utils/ en suivant le style de référentiel ») : la génération de test multi-fichiers consomme des PRU.
  • Appliquez des ensembles de règles afin que les demandes de tirage de l’agent passent des tests + analyse + linting avant la fusion.
  • Étiquetez les demandes de tirage de l’agent (par exemple, agent-refactor, agent-tests) pour surveiller, trier et rétablir si nécessaire.
  • Itérer des instructions dans .github/copilot-instructions.md lorsque vous voyez des erreurs répétées.
  • Rétablissez rapidement si nécessaire et demandez de nouvelles modifications à l’agent.

Utilisation intentionnelle des PRU pour la validation

Tirez parti des RU pour des tâches de validation plus approfondies telles que l’extension de couverture des tests, les audits entre les répertoires ou les analyses de zone à risque. Les vérifications légères consomment moins de PRUs, donc appliquez-les intentionnellement pour optimiser la valeur.

Avec les pratiques de configuration, d’extensions et de validation en place, la dernière étape consiste à utiliser l'agent de manière responsable en définissant bien les tâches, en protégeant les environnements et en examinant continuellement les résultats.