Utiliser GitHub Copilot avec Azure Boards

Azure DevOps Services

Utilisez Azure Boards avec GitHub Copilot pour passer plus rapidement de l’élément de travail au brouillon de pull request. Lancez Copilot à partir d’un élément de travail pour créer une branche, générer des modifications de code et ouvrir une pull request en brouillon, tandis qu’Azure DevOps suit la progression de l’élément de travail.

Utilisez cette intégration pour :

  • Démarrez le codage automatisé à partir d’éléments de travail.
  • Suivez GitHub Copilot progression directement dans Azure DevOps.
  • Lier les branches générées et les pull requests à des éléments de travail.
  • Surveillez quand les pull requests en brouillon sont prêtes à être examinées.

Important

Cette intégration nécessite GitHub référentiels et l’authentification d’application GitHub. Azure Repos (dépôts Git Azure DevOps) ne prennent pas en charge l'intégration de GitHub Copilot.

Prerequisites

Catégorie Spécifications
Gestion des licences Abonnement actif GitHub Copilot. Pour connaître les tarifs, consultez GitHub Copilot plans.
Référentiel référentiel GitHub (pas Azure Repos) avec les autorisations appropriées
Authentification GitHub authentification d'application configurée entre Azure DevOps et GitHub (les jetons d'accès personnels ne sont pas pris en charge)
Permissions Accès Contributeur dans Azure DevOps pour les éléments de travail et possibilité de lier des artefacts
Connexion Azure Boards Connecter Azure Boards à GitHub

Pour les administrateurs d’équipe

Utilisez la liste de contrôle suivante pour configurer cette intégration pour les équipes :

  • Configurez l’intégration de GitHub App au niveau de l’organisation. Pour connaître les étapes de configuration, consultez Connexion Azure Boards à GitHub.
  • Vérifiez que chaque membre de l’équipe dispose de l’accès requis dans les deux systèmes :
    • Autorisations Azure DevOps pour mettre à jour les éléments de travail et créer des liens vers des artefacts.
    • Accès GitHub aux dépôts et aux branches cibles.

Types d’éléments de travail pris en charge

L’intégration GitHub Copilot prend en charge les types d’éléments de travail dans les catégories Exigences et Tâches, notamment :

  • Types d’éléments de travail standard, tels que l’article utilisateur, l’élément de backlog de produit, l’exigence, la tâche, le bogue et le problème.
  • Types d’éléments de travail personnalisés que vous définissez dans votre modèle de processus.

Les types personnalisés sont pris en charge lorsque votre processus les mappe aux catégories Exigences ou Tâches.

Vous pouvez utiliser GitHub Copilot avec des éléments de travail d’Agile, Scrum, CMMI et des modèles de processus personnalisés dans votre projet Azure DevOps.

Démarrer GitHub Copilot à partir d’éléments de travail

  1. Ouvrez l’élément de travail que vous souhaitez implémenter à l’aide de GitHub Copilot.

  2. Dans le formulaire élément de travail, sélectionnez l’icône GitHub.

    Si plusieurs options sont disponibles, l’icône apparaît sous la forme d’un menu déroulant.

    Screenshot montrant l’icône GitHub Copilot mise en surbrillance dans l’élément de travail.

  3. Sélectionnez Créer une pull request avec GitHub Copilot.

    Capture d'écran montrant le menu déroulant GitHub sélectionné et l'option pour proposer une pull request GitHub.

  4. Sélectionnez le dépôt GitHub cible et la branche cible pour la pull request.

    Note

    La liste des référentiels affiche uniquement GitHub référentiels connectés via l’authentification d’application GitHub. Azure Repos ne sont pas pris en charge.

  5. (Facultatif) Ajoutez des instructions spéciales pour guider l’implémentation.

    Exemples d’instructions :

    • Créez un fichier README avec des instructions d’installation.
    • Utilisez le modèle async/await dans le nouveau code asynchrone.
    • Ajoutez des tests unitaires pour la nouvelle logique.
    • Suivez le style de code existant du référentiel et les conventions d’affectation de noms.

  6. Cliquez sur Créer.

    La capture d'écran montre les listes déroulantes du menu pour le dépôt et la branche, afin de créer un pull request brouillon avec Copilot.

Que se passe-t-il lorsque vous démarrez Copilot

Lorsque vous démarrez Copilot à partir d’un élément de travail, Azure DevOps effectue les actions suivantes :

  • Partagez le contexte d’élément de travail avec GitHub Copilot : titre, champs de texte volumineux (tels que les critères de description et d’acceptation), les commentaires et un lien vers l’élément de travail.
  • Créez une branche et un brouillon de pull request dans le dépôt GitHub sélectionné, puis associez-les à l’élément de travail.
  • Mettez à jour l’état de l’élément de travail afin de suivre les états en cours, prêts pour révision et d’erreur.

Surveiller la progression de GitHub Copilot

Indicateurs d’état

Azure DevOps affiche le statut de Copilot directement dans votre élément de tâche avec trois états possibles :

  • En cours : Copilot génère des modifications de code.
  • Prêt pour révision : la pull request en brouillon est prête à être révisée.
  • Erreur : échec du processus de codage. Survolez le statut pour afficher les détails.

Note

Attendez-vous que l’opération de Copilot prenne 5 à 15 minutes, en fonction de la complexité de l’élément de travail.

Indicateurs de carte du tableau

Les éléments de travail sur votre tableau affichent directement le statut de GitHub Copilot sur la carte de l’élément de travail. Une icône de GitHub Copilot s’affiche sur la carte et indique que Copilot travaille ou a déjà terminé son travail pour cet élément.

Capture d’écran affichant une carte d’élément de travail sur le tableau, avec une icône d’état de GitHub Copilot indiquant la progression.

Cet indicateur vous permet d’identifier les éléments de travail avec des opérations de Copilot actives ou terminées sans ouvrir chaque élément.

Mises à jour de la section Développement

La section Développement de votre élément de travail affiche automatiquement :

  • Branche créée par Copilot.
  • Pull request en brouillon avec statut en temps réel.
  • Lien direct pour passer en revue le code généré dans GitHub.

Réviser et fusionner la pull request

  1. Sélectionnez le lien de pull request pour examiner l'implémentation de Copilot dans GitHub.

  2. Si vous êtes satisfait des modifications, convertissez le brouillon de demande de tirage en demande de tirage standard.

    La discussion de l’élément de travail se met automatiquement à jour à mesure que le statut de la pull request change.

  3. Utilisez l'interface de GitHub pour passer en revue, commenter et approuver le code généré.

  4. Fusionnez la pull request dans GitHub quand vous serez prêt.

    • La validation de fusion est automatiquement liée à votre élément de travail.
    • Les liens de branche sont supprimés si vous supprimez la branche.
    • Les indicateurs d'état de Copilot sont masqués après une fusion réussie.

  5. Une fois le pull request fusionné :

    1. Mettez à jour l’état de votre élément de travail pour refléter l’achèvement.
    2. Vérifiez que la validation de fusion s’affiche dans la section Développement.
    3. Fermez l’élément de travail si l’implémentation répond entièrement aux exigences.

Pour plus d’informations, consultez Qu’est-ce que GitHub Copilot ?

Résoudre les problèmes

  • Vérifier les détails de l’erreur : pointez sur l’icône d’erreur pour afficher les détails.

  • Réexécuter Copilot : sélectionnez Réexécuter Copilot pour réessayer avec les mêmes instructions ou mises à jour.

    La capture d’écran montre l’icône Plus d’actions sélectionnée, puis l’option Relancer Copilot dans la zone Développement.

  • Intervention manuelle : si nécessaire, apportez des modifications manuelles à la branche générée et à la Pull Request.

Problèmes de licences

  • Problème : échec de la validation de la licence.
  • Solution : vérifiez que vous disposez d’un abonnement actif GitHub Copilot, puis sélectionnez Obtenir une licence si vous y êtes invité.

Accès aux dépôts

  • Problème : Impossible de voir les référentiels attendus.
  • Solution :
    • Vérifiez la connexion de l’application GitHub entre Azure DevOps et GitHub.
    • Vérifiez que vous avez accès aux référentiels de GitHub cibles.
    • Vérifiez les autorisations du référentiel et l'authentification de l'application GitHub.
    • Vérifiez que le référentiel est connecté via l’intégration correcte de l’application GitHub.

erreurs de Copilot

  • Problème : Copilot rencontre des erreurs.
  • Solution : passez en revue les détails de l’erreur, clarifiez vos instructions et réexécutez Copilot.

Échecs répétés après la réexécution

  • Problème : Copilot continue d’échouer après la réexécution.
  • Solution :
    • Vérifiez la branche associée et la pull request dans GitHub pour consulter le dernier état de l’opération.
    • Vérifiez que les autorisations du dépôt et de la branche permettent toujours à Copilot de créer des branches et des pull requests.
    • Si le problème persiste, contactez l’administrateur de votre projet ou de votre organisation en lui fournissant le lien de l’élément de travail et le lien de la pull request.

Annuler une opération en cours

Note

Après avoir démarré une opération de GitHub Copilot à partir d'un élément de travail, vous ne pouvez pas l'annuler. L’agent de codage Copilot s’exécute jusqu’à la fin. Pour remédier aux résultats indésirables, gérez ou abandonnez la pull request générée dans GitHub.

État non mis à jour

  • Problème : l’état de progression reste bloqué.
  • Solution : consultez GitHub pour connaître l’avancement réel, car les mises à jour d’état dépendent des rapports de GitHub.

Meilleures pratiques

  • Descriptions claires des éléments de travail : fournissez des critères d’acceptation détaillés et du contexte pour obtenir de meilleurs résultats avec Copilot.
  • Gardez les changements simples et concis : plus la description de votre élément de travail est complexe et détaillée, plus il est difficile pour Copilot de comprendre. Concentrez-vous sur des exigences claires et spécifiques.
  • Instructions spécifiques : ajoutez des instructions d'implémentation lors du démarrage de Copilot.
  • Surveillance régulière : vérifiez régulièrement la progression, en particulier pour les éléments de travail complexes.
  • Révision rapide : passez en revue les pull requests en cours et fournissez des retours rapidement pour maintenir l'élan.
  • Hygiène appropriée des éléments de travail : Mettez à jour les états d’élément de travail de manière appropriée tout au long du processus.

Limites

Passez en revue les limitations suivantes lorsque vous utilisez GitHub Copilot avec Azure Boards :

  • Dépendances : Copilot ne gère pas les dépendances entre les éléments de travail. Veillez à ce que chaque élément de travail soit autonome.
  • Partage de données : GitHub Copilot reçoit uniquement le titre de l’élément de travail, les champs de texte volumineux, les commentaires et le lien élément de travail.
  • Complexité : des descriptions d’éléments de travail trop complexes ou trop détaillées peuvent réduire l’efficacité de Copilot.

Contenu connexe

  • Last updated on