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

L’agent de modernisation prend en charge plusieurs façons de spécifier les référentiels que vous souhaitez mettre à niveau :

• Dossier actif : Mettez à niveau le projet dans votre répertoire de travail actuel.
• Entrée manuelle : entrez directement les chemins d’accès au répertoire local ou les URL Git distantes.
• Fichier de configuration du référentiel : utilisez un fichier de configuration JSON qui répertorie tous les référentiels.

Fichier de configuration du référentiel

Pour les opérations par lots sur de nombreux référentiels, créez un fichier de configuration JSON pour répertorier tous les référentiels. Par exemple, créez-le .github/modernize/repos.json dans votre répertoire de travail ou fournissez un chemin personnalisé.

Conseil / Astuce

Pour les exemples de référentiels, commencez par les dépliquer et vérifiez que vous disposez d’une autorisation d’administrateur pour déléguer le travail aux agents de codage cloud.

Format simple (tableau de référentiels) :

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

Format complet (avec les chemins de branche et les chemins locaux) :

{
  "repos": [
    {
      "name": "PhotoAlbum-Java",
      "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git",
      "branch": "main"
    },
    {
      "name": "local-project",
      "path": "/absolute/path/to/project"
    }
  ]
}

Chaque entrée de dépôt prend en charge les champs suivants :

Champ	Description	Obligatoire
name	Nom convivial du référentiel (utilisé dans les rapports et les tableaux de bord).	Oui
url	URL de clonage Git au format HTTPS ou SSH.	L’une de url ou path
path	Chemin d’accès absolu du répertoire local.	L’une de url ou path
branch	Branche à vérifier après le clonage.	Non
description	Description lisible par l’homme.	Non

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.

L’agent de modernisation détecte automatiquement le fichier repos.json à .github/modernize/repos.json lorsque vous sélectionnez à partir d’un fichier de configuration en mode interactif. Vous pouvez également fournir un chemin personnalisé.

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.
• Prend en charge : les URL Git et les référentiels de chemins d'accès locaux.

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.
• How it works : envoie des tâches à GitHub Agents de codage cloud pour l’exécution parallèle dans le cloud.
• Configuration requise : configuration du serveur MCP dans chaque référentiel (configurée lors de l’installation).
• Supports : référentiels uniquement avec des URL GitHub (github.com). Les chemins d'accès locaux et les fournisseurs non GitHub ne sont pas pris en charge.

Important

La délégation de l’Agent de codage cloud nécessite que les dépôts aient des URL de référentiel GitHub (github.com). Les référentiels spécifiés avec des chemins d’accès locaux ou hébergés sur des fournisseurs non GitHub (GitLab, Azure DevOps) sont ignorés lors de la délégation cloud. Utilisez l’exécution locale pour ces référentiels.

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 → sélectionnez Mettre à niveau (interactive, locale)
• modernize → sélectionnez Mettre à niveau → déléguer aux agents cloud (interactifs, cloud)
• modernize upgrade "Java 21" --source ./repos.json (non interactif, local)
• modernize upgrade "Java 21" --source ./repos.json --delegate cloud (non interactif, cloud)

Fonctionnement de la mise à niveau par lots

Flux de travail de mise à niveau par lots :

1. Language detection : 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. Sélectionnez Mettre à niveau dans le menu principal.

   

3. Choisissez comment spécifier vos référentiels cibles. Sélectionnez Dans un fichier de configuration pour utiliser un repos.json fichier.

   

   Conseil / Astuce

   Vous pouvez également sélectionner une entrée manuelle pour entrer des chemins d’accès locaux ou des URL Git distantes directement, ou Dossier actuel pour mettre à niveau le projet dans votre répertoire actuel.

4. Si le repos.json fichier est détecté à l’emplacement par défaut, l’agent le remplit automatiquement. Sinon, entrez le chemin d’accès à votre fichier de configuration, puis appuyez sur Entrée.

5. Tous les référentiels sont sélectionnés par défaut. Désélectionnez les référentiels que vous souhaitez ignorer, puis appuyez sur Entrée pour confirmer votre sélection.

   • Utilisez les touches de direction pour naviguer et appuyer sur Espace pour activer/désactiver les dépôts individuels.

   

6. Choisissez le mode d’exécution. Sélectionnez Mettre à niveau localement.

   

7. Entrez l’invite cible de mise à niveau (par exemple, Java 21 ou .NET 10) ou appuyez sur Enter pour accepter la version par défaut (dernière version LTS).

8. 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 référentiel.

For Java applications, 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. Sélectionnez Mettre à niveau dans le menu principal.

   

3. Choisissez comment spécifier vos référentiels cibles. Sélectionnez Dans un fichier de configuration.

   

4. Si le repos.json fichier est détecté à l’emplacement par défaut, l’agent le remplit automatiquement. Sinon, entrez le chemin d’accès à votre fichier de configuration, puis appuyez sur Entrée.

5. Tous les référentiels sont sélectionnés par défaut. Désélectionnez les référentiels que vous souhaitez ignorer, puis appuyez sur Entrée pour confirmer votre sélection. Utilisez les touches de direction pour naviguer et appuyer sur Espace pour activer/désactiver les dépôts individuels.

   

6. Choisissez le mode d’exécution. Sélectionnez Déléguer aux agents cloud.

   

7. Entrez l’invite cible de mise à niveau (par exemple, Java 21) ou appuyez sur Enter pour accepter la valeur par défaut.

8. 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 :

Mettez à niveau localement à l’aide d’un fichier de configuration de référentiel :

modernize upgrade "Java 21" --source .github/modernize/repos.json

Mettez à niveau plusieurs référentiels en spécifiant directement des sources :

modernize upgrade "Java 21" --source https://github.com/org/repo1 --source https://github.com/org/repo2

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

modernize upgrade "Java 21" --source .github/modernize/repos.json --delegate cloud

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 de GitHub en utilisant gh auth status.
• Vérifiez que vous avez accès à tous les dépôts dans repos.json.

Erreurs d’incompatibilité de langue :

• Vérifiez que tous les référentiels de repos.json utilisent la même langue (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 et les limites de quota de GitHub Actions.
• Pour .NET Framework, assurez-vous 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 au niveau du dépôt github-copilot-appmod ou utilisez le formulaire de commentaires de modernisation GitHub Copilot.