Mise à niveau par lots avec l’agent de modernisation GitHub Copilot

La mise à niveau par lots vous permet d’appliquer simultanément des plans de modernisation cohérents sur plusieurs référentiels. Cet article explique comment mettre à niveau plusieurs applications efficacement à l’échelle de l’entreprise.

À l’aide de la mise à niveau par lots, vous pouvez :

• Mettez à niveau plusieurs applications simultanément à l’aide de la même cible de mise à niveau.
• Appliquez des modèles cohérents à l’aide de modèles de mise à niveau similaires entre les applications.
• Tirez parti de l’exécution parallèle lors de la délégation à des agents de codage cloud.

La mise à niveau par lots offre les avantages suivants :

• Exécution cohérente :

  • Approche standardisée : appliquez les mêmes modèles de modernisation dans tous les référentiels.
  • Variabilité réduite : garantir des chemins de mise à niveau cohérents pour des applications similaires.
  • Stratégies réutilisables : utilisez des compétences spécifiques à l’organisation entre les applications.

• Mise à l’échelle et efficacité :

  • Traitement parallèle : utilisez des agents de codage cloud pour traiter plusieurs référentiels simultanément.
  • Flux de travail automatisés : s'intégrer aux pipelines CI/CD pour une modernisation programmée.
  • Économies de temps : réduisez le temps de modernisation total des semaines à l’heure.

Prerequisites

• Moderniser l’interface CLI.
• Évaluation de lot terminée (recommandée, mais non obligatoire).
• Tous les référentiels utilisent le même langage de programmation (Java ou .NET).
• Accès à tous les référentiels que vous souhaitez mettre à niveau.
• Authentification GitHub configurée (gh auth login).

Important

Tous les référentiels d’une mise à niveau par lots doivent utiliser le même langage de programmation. Si un référentiel utilise une langue différente, la mise à niveau du lot marque le référentiel comme échoué et le ignore.

Configurer les référentiels

Pour activer la mise à niveau par lots, créez un .github/modernize/repos.json fichier dans votre répertoire de travail qui répertorie tous les référentiels que vous souhaitez mettre à niveau.

Conseil / Astuce

Vérifiez que vous disposez des autorisations appropriées pour accéder aux référentiels ou les forker d'abord.

[
  {
    "name": "PhotoAlbum-Java",
    "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git"
  },
  {
    "name": "ZavaSocialFrontEnd",
    "url": "https://github.com/bradygaster/ZavaSocialFrontEnd"
  }
]

Configuration du référentiel

Chaque entrée nécessite :

• nom : nom convivial du référentiel (utilisé dans les rapports et les tableaux de bord).
• URL : URL du clone Git (format HTTPS).

Conseil / Astuce

Vous pouvez inclure des référentiels provenant de différentes organisations et utiliser différentes méthodes d’authentification tant que vous avez accès.

Emplacement du fichier

Vous devez placer le repos.json fichier sur .github/modernize/repos.json.

L’agent de modernisation détecte automatiquement ce fichier lors de l’exécution d’opérations par lots.

Choisir votre mode d’exécution

La mise à niveau par lots prend en charge deux modes d’exécution et deux méthodes d’interaction :

Modes d'exécution

Exécution locale

• Meilleur pour : les tests, les petits ensembles de référentiels (1 à 5 référentiels), ou lorsque vous préférez un contrôle local.
• Fonctionnement : traite les référentiels de manière séquentielle sur votre ordinateur local.
• Configuration requise : Aucun au-delà des prérequis de base.

Délégation de l’Agent de codage cloud

• Idéal pour les opérations à l’échelle de l’entreprise, les grands portefeuilles (5 dépôts) ou le traitement parallèle.
• Fonctionnement : envoie des tâches à GitHub Cloud Coding Agents pour une exécution parallèle dans le cloud.
• Configuration requise : configuration du serveur MCP dans chaque référentiel (configurée lors de l’installation).

Conseil / Astuce

En traitant les référentiels en parallèle, la délégation de l’Agent de codage cloud peut réduire le temps de modernisation total des heures à minutes.

Méthodes d’interaction

Mode interactif (TUI)

• Expérience guidée avec des menus et des invites.
• Idéal pour les utilisateurs de première fois ou lorsque vous souhaitez passer en revue les options.
• Prend en charge l’exécution locale et cloud.

Mode non interactif (CLI/sans tête)

• Basé sur la ligne de commande, entièrement automatisé.
• Idéal pour les pipelines CI/CD et l’automatisation.
• Prend en charge l’exécution locale et dans le cloud avec le drapeau --delegate cloud.

Note

Vous pouvez combiner n’importe quel mode d’exécution avec n’importe quelle méthode d’interaction. Par exemple:

• modernize (interactif, local)
• modernize → sélectionner des agents de codage cloud (interactifs, cloud)
• modernize upgrade "Java 21" (non interactif, local)
• modernize upgrade "Java 21" --delegate cloud (non interactif, cloud)

Fonctionnement de la mise à niveau par lots

Flux de travail de mise à niveau par lots :

1. Détection de langue : détecte automatiquement le langage du projet (Java ou .NET) à partir du premier référentiel.
2. Élaboration d'un plan : crée un plan de mise à niveau selon votre demande ou utilise les dernières versions LTS.
3. Exécution : applique la mise à niveau à chaque référentiel.
4. Validation : génère et valide les modifications pour chaque référentiel.

Exécuter la mise à niveau par lots

Après avoir configuré vos référentiels et choisi un mode d’exécution, démarrez la mise à niveau par lots.

Mode interactif (mise à niveau localement)

1. Exécutez l’agent de modernisation :

   modernize
   

2. L’agent détecte le repos.json fichier et affiche la liste des référentiels :

   

3. Sélectionnez les référentiels à mettre à niveau, puis appuyez Enter pour confirmer votre sélection.

   • Appuyez sur Ctrl+A pour sélectionner tous les référentiels.
   • Vous pouvez également utiliser des touches de direction pour naviguer et appuyer Enter pour sélectionner des référentiels individuels.

4. Sélectionnez 2. Mettre à niveau dans le menu principal.

   Capture d’écran de Modernize CLI montrant l’option de menu Mettre à niveau le Runtime & Framework dans le terminal.

5. Pour exécuter la mise à niveau, sélectionnez 1. Mettre à niveau localement.

   

6. L'agent fonctionne automatiquement :

   • Crée un plan de mise à niveau en fonction de votre demande.
   • Applique le plan à chaque référentiel de manière séquentielle.
   • Génère et valide chaque référentiel après les modifications.
   • Affiche la progression et le résumé de chaque référentiel.

   

Mode interactif (délégation aux agents de codage cloud)

Prérequis : Configurer le serveur MCP

Avant d’exécuter la mise à niveau, configurez le serveur MCP de modernisation GitHub Copilot dans chaque dépôt.

Pour les applications Java, ajoutez cette configuration dans la section Agent de codage cloud de vos paramètres de référentiel :

{
  "mcpServers": {
    "app-modernization": {
      "type": "local",
      "command": "npx",
      "tools": [
        "*"
      ],
      "args": [
        "-y",
        "@microsoft/github-copilot-app-modernization-mcp-server"
      ]
    }
  }
}

Étapes

1. Exécutez l’agent de modernisation :

   modernize
   

2. L’agent détecte le repos.json fichier et affiche la liste des référentiels :

   

3. Sélectionnez les référentiels à mettre à niveau, puis appuyez Enter pour confirmer votre sélection.

   • Appuyez sur Ctrl+A pour sélectionner tous les référentiels.
   • Vous pouvez également utiliser des touches de direction pour naviguer et appuyer Enter pour sélectionner des référentiels individuels.

4. Sélectionnez 2. Mettre à niveau dans le menu principal.

5. Pour exécuter la mise à niveau, sélectionnez 2. Déléguer aux agents de codage cloud.

   

6. L'agent fonctionne automatiquement :

   • Crée des plans de mise à niveau pour chaque référentiel.

   • Envoie une tâche de l’Agent de codage cloud pour chaque dépôt.

   • Exécute des travaux indépendamment en parallèle dans le cloud.

   • Affiche les ID de job et les URLs de PR pour chaque référentiel.

     

   • Délègue les tâches à AgentHQ pour l’exécution parallèle.

     

   • Effectue le suivi de la progression de chaque tâche individuelle en temps réel.

     

   • Affiche le résumé de la mise à niveau pour chaque tâche terminée.

     

Mode non interactif (CLI)

Pour l’automatisation et l’intégration CI/CD, utilisez la modernize upgrade commande :

Mettre à niveau localement :

modernize upgrade "Java 21"

Mise à niveau à l’aide d’agents de codage cloud :

modernize upgrade "Java 21" --delegate cloud

La commande détecte automatiquement le repos.json fichier et traite tous les référentiels.

Note

Pour une exécution sans lot et d’autres options CLI, consultez la section de configuration multi-référentiel dans la référence des commandes CLI.

Passer en revue les résultats

Une fois la mise à niveau par lots terminée :

1. Vérifiez le rapport agrégé affiché dans le terminal.

2. Passez en revue les modifications apportées au référentiel individuel :

   cd <repository-name>
   git status
   git diff
   

3. Créez des requêtes de tirage pour les mises à niveau réussies :

   cd <repository-name>
   gh pr create --title "Upgrade to Java 21" --body "Automated upgrade by modernization agent"
   

Résolution des problèmes liés aux mises à niveau par lots

Problèmes courants

Erreurs d’accès au référentiel :

• Vérifiez l’authentification GitHub à l’aide de gh auth status.
• Vérifiez que vous avez accès à tous les dépôts dans repos.json.

Erreurs d’incompatibilité de langue :

• Assurez-vous que tous les référentiels de repos.json utilisent le même langage (Java ou .NET).
• Créez des opérations de traitement par lots distinctes pour différentes langues.

Échecs de clonage :

• Vérifiez que les URL du référentiel dans repos.json sont correctes et accessibles.
• Vérifiez que vous disposez des autorisations d’accès appropriées pour tous les référentiels.
• Vérifiez la connectivité réseau et les paramètres VPN.

Échecs de build après la mise à niveau :

• Examinez les messages d'erreur de compilation dans le rapport agrégé.
• Vérifiez si vous devez mettre à jour d’autres dépendances.
• Vérifiez la compatibilité des bibliothèques tierces avec la nouvelle version.

Échecs de référentiel individuels :

• Le processus de traitement par lots continue même si les dépôts individuels échouent.
• Passez en revue le rapport agrégé pour identifier les dépôts ayant échoué.
• Vérifiez les journaux des erreurs pour obtenir des messages d’erreur spécifiques.
• Relancez individuellement les dépôts échoués.

Échecs de l’Agent de codage cloud :

• Vérifiez les autorisations GitHub Actions et les limites de quota.
• Pour .NET Framework, vérifiez que la configuration de l’exécuteur Windows est correctement définie.

Étapes suivantes

Une fois la mise à niveau par lots terminée, vous pouvez :

Continuez à améliorer :

• Exécuter l’évaluation par lots - Réévaluer pour vérifier les améliorations et identifier les nouvelles opportunités.
• Créer des compétences personnalisées pour les modèles spécifiques à l’organisation : capturez les modèles réussis à réutiliser.

En savoir plus :

• En savoir plus sur les commandes CLI

Fournir des commentaires

Nous apprécions vos commentaires ! Si vous avez des commentaires sur la mise à niveau par lots ou l’agent de modernisation, créez un problème dans le dépôt github-copilot-appmod ou utilisez le formulaire de commentaires de modernisation GitHub Copilot.