Évaluation par lots avec l’agent de modernisation GitHub Copilot

L’évaluation par lots vous permet d’analyser un portefeuille d’applications Java, .NET et JavaScript/TypeScript en une seule exécution. Vous bénéficiez d’une vue complète du paysage de modernisation de vos applications. Cet article vous guide tout au long du processus d’évaluation efficace de plusieurs référentiels. Le processus prend en charge les référentiels à langage unique et les mono-repos qui contiennent un mélange de projets Java, .NET et JavaScript/TypeScript.

Chaque application est analysée le long de deux pistes complémentaires. L’analyse des problèmes détecte les problèmes que vous devez résoudre. Codebase Insights documente la façon dont l’application est générée afin de pouvoir la planifier.

Analyse des problèmes

L’analyse des problèmes détecte les problèmes de modernisation et de sécurité dans trois domaines. La couverture linguistique diffère selon le domaine :

• Mise à niveau : analyse de version du runtime et de l’infrastructure. Couvre Java et .NET.
• Préparation au cloud — adéquation à la plateforme cible Azure et problèmes de migration. Couvre Java et .NET.
• Sécurité : analyse CVE sur les dépendances directes et transitives, ainsi que les problèmes de sécurité CWE guidés par ISO 5055 . Java uniquement pour l’instant ; .NET et la prise en charge de JavaScript/TypeScript se trouve sur la feuille de route.

Analyses de la base de code

Codebase Insights documente la façon dont chaque application est générée. Ils sont produits pour les projets Java, .NET et JavaScript/TypeScript. Ils s’affichent lorsque vous sélectionnez Analyse complète dans le paramètre Couverture d’analyse.

• Architecture : diagramme d’architecture de haut niveau avec des couches, des limites de module, une topologie d’exécution et des points d’entrée.
• Contrats d’API — REST, gRPC, files de messages et webhooks que l’application expose ou consomme. Évalue le périmètre d’impact de l’intégration avant la migration.
• Configuration : fichiers de configuration, variables d’environnement, indicateurs de fonctionnalité, chaînes de connexion et secrets. Pilote la migration des secrets et de la configuration vers Azure Key Vault et Azure App Configuration.
• Flux de travail métier : flux fonctionnels de bout en bout reconstruits à partir du code (par exemple , commander → réserver → payer → remplir). Définit le périmètre de régression et la communication avec les parties prenantes.
• Dépendances — bibliothèques directes ou transitives, SDK et pilotes avec versions figées. Alimente la correspondance entre les services Azure et met en évidence les fins de vie (EOL) ou les versions bêta épinglées.
• Modèle de données : bases de données, schémas, entités clés et relations à partir de mappages ORM et DDL. Pilote la planification de la migration de la couche de données.

Rapports

L’évaluation par lots est particulièrement utile pour la planification de la migration, car elle vous permet d’évaluer efficacement la préparation et les exigences de différentes applications en même temps. En utilisant l’évaluation par lots, vous pouvez évaluer différents référentiels en même temps et obtenir des rapports d’évaluation détaillés pour chaque application. Il produit deux types de rapports pour prendre en charge votre planification de la migration :

• Rapport par référentiel : fournit des insights détaillés sur les deux aspects identifiés au niveau du référentiel individuel.
• rapport Aggregated : présente une perspective globale de toutes les applications évaluées, offrant des insights récapitulatives, des recommandations sur les services Azure, les plateformes cibles, les chemins de mise à niveau, les stratégies de migration et les vagues de migration. En outre, le rapport agrégé inclut des raccourcis pour faciliter l’accès à chaque rapport de référentiel.

L’évaluation par lots offre les avantages suivants :

• Visibilité inter-applications :

  • Rapports agrégés : obtenir une vue complète sur les applications.
  • Analyse entre référentiels : identifiez les modèles et dépendances courants entre les applications.
  • Informations sur la hiérarchisation : Comprendre les applications qui ont besoin d’une attention immédiate.

• Mise à l’échelle et efficacité :

  • Traitement parallèle : utilisez des agents cloud pour traiter plusieurs référentiels simultanément.
  • Flux de travail automatisés : intégrer des pipelines CI/CD pour l’évaluation planifiée.
  • Économies de temps : réduisez le temps total d’évaluation des semaines aux heures.

Prerequisites

• Moderniser l’interface CLI.
• Accès à tous les référentiels que vous souhaitez évaluer.
• L'authentification GitHub est configurée (gh auth login).

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 évaluer :

• Dossier actif : évaluez 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é.

Vérifiez que vous disposez des autorisations appropriées pour les référentiels ou les dupliquez.

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

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

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 :

Format complet avec regroupement d’applications (facultatif, pour les rapports organisés) :

Vous pouvez ajouter une apps[] section pour regrouper des référentiels dans des applications logiques. Lorsque les applications sont définies, le rapport agrégé organise les résultats par application et prend en charge la distribution de rapports vers des destinations externes.

{
  "repos": [
    {
      "name": "PhotoAlbum-Java",
      "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git",
      "branch": "main"
    },
    {
      "name": "PhotoAlbum",
      "url": "https://github.com/Azure-Samples/PhotoAlbum.git"
    }
  ],
  "apps": [
    {
      "identifier": "photo-app",
      "description": "Photo management application",
      "repos": ["PhotoAlbum-Java"],
      "output": {
        "type": "local",
        "path": "/path/to/reports/photo-app"
      }
    }
  ]
}

Chaque entrée d’application prend en charge :

Le output champ prend en charge les types de distribution suivants :

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é.

Exécuter l’évaluation par lots

Deux modes d’exécution sont disponibles :

• Exécution locale : l’agent de modernisation traite les dépôts l’un après l’autre sur votre ordinateur local. Ce mode fonctionne mieux pour un plus petit ensemble d’applications ou pour les tests initiaux. Prend en charge à la fois l’URL Git et les dépôts de chemins d’accès locaux.
• Délégation à l’agent cloud : l’agent de modernisation soumet des tâches aux agents cloud GitHub Copilot pour un traitement parallèle dans le cloud. Ce mode est plus rapide pour les scénarios multi-dépôts.

Mode interactif (évaluer localement)

1. Exécutez l’agent de modernisation :

   modernize
   

2. Sélectionnez Évaluer 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 Entrée manuelle pour entrer des chemins d’accès locaux ou des URL Git distantes directement, ou Dossier actif pour évaluer le projet dans votre répertoire actif.

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. Sélectionnez les domaines d’évaluation à analyser. Upgrade et Cloud Readiness s’exécutent sur des projets Java et .NET dans le référentiel. Security est décochée par défaut et s’exécute uniquement sur les projets Java ; sélectionnez-la pour rechercher les vulnérabilités CVE et les problèmes CWE guidés par ISO 5055.

   

7. Passez en revue et configurez les options d’évaluation. La page de configuration affiche les options regroupées par langue et domaine :

   • Couverture générale/analyse :
     • Problème uniquement (par défaut) : détecte les problèmes de modernisation et de sécurité dans votre code source. Option la plus rapide.
     • Analyse complète : détecte les problèmes et génère également des insights codebase sur six aspects de votre application : architecture, contrats API, configuration, flux de travail métier, dépendances et modèle de données. Prend plus de temps que l’analyse du problème uniquement.
   • Java / UPGRADE : Environnement d’exécution cible (OpenJDK 11, 17, 21 ou 25).
   • Java / CLOUD READINESS : Services de calcul cibles, système d’exploitation cible et conteneurisation.
   • Java / SECURITY : gravité minimale CVE (low, medium, high, critical ; high par défaut). Les valeurs de gravité inférieure incluent plus de résultats. (Le domaine de sécurité est uniquement disponible pour Java à ce jour.)
   • .NET / UPGRADE : Framework cible (.NET 8, 9 ou 10).
   • .NET / CLOUD READINESS : Services de calcul cibles.

   Utilisez les touches de direction pour naviguer, appuyez sur Entrée pour modifier une valeur ou sélectionnez Continuer pour continuer avec les paramètres actuels.

   

   Conseil / Astuce

   Les valeurs par défaut recommandées fonctionnent pour la plupart des scénarios. Vous devez uniquement modifier ces paramètres si vous avez des exigences spécifiques, telles que le ciblage d’une version JDK particulière, d’un service de calcul Azure spécifique ou d’un seuil de gravité CVE différent.

8. Choisissez le mode d’exécution. Sélectionnez Évaluer localement.

   

9. Entrez le chemin de sortie des résultats de l’évaluation ou appuyez sur Entrée pour accepter la valeur par défaut.

10. L'agent fonctionne automatiquement :

    • Clone les dépôts distants (les dépôts avec chemin local sont utilisés directement).

    • Exécute l’évaluation sur chaque référentiel un par un.

    • Génère des rapports d’évaluation individuels.

      

    • Crée un rapport agrégé.

      

11. Une fois l’évaluation terminée, l’agent ouvre automatiquement le rapport agrégé.

    

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

Tout d’abord, configurez les agents cloud dans chaque référentiel d’applications. Pour configurer les agents cloud, créez un fork des dépôts d’exemple.

Configuration pour les applications .NET

Configurer l’exécution sur Windows pour les applications .NET Framework

Par défaut, l’agent cloud Copilot s’exécute dans un environnement Ubuntu Linux. Pour les applications .NET Framework, vous avez besoin d’un environnement Windows. Pour l’activer, configurez .github/workflows/copilot-setup-steps.yaml dans la main branche de votre référentiel d’applications, comme illustré dans l’exemple suivant :

# Windows-based Copilot Setup Steps for .NET tasks
# Note: Windows runners have firewall limitations that may affect some network operations
# Use this workflow for .NET projects that require Windows-specific tooling

name: "Copilot Setup Step (Windows)"

on:
  workflow_dispatch:

jobs:
  copilot-setup-steps:
    runs-on: windows-latest
    permissions:
      contents: read
    steps:
      - name: Checkout code
        uses: actions/checkout@v5

En savoir plus sur : Customisation de l'environnement de développement de Copilot avec les étapes de configuration de Copilot

Désactiver le pare-feu

Désactivez le pare-feu intégré de l’agent cloud de Copilot dans les paramètres de votre référentiel, comme indiqué dans l’image suivante :

Serveur MCP

Configurez GitHub Copilot serveur MCP de modernisation dans la section Cloud agent de vos paramètres de référentiel, comme illustré dans l’exemple suivant :

{
  "mcpServers": {
   "AppModDotNetUpgrade": {
        "type": "local",
        "command": "dotnet",
        "args": [
          "dnx",
          "Microsoft.GitHubCopilot.Modernization.Mcp",
          "--prerelease",
          "--yes",
          "--source",
          "https://api.nuget.org/v3/index.json"
        ],
        "env": {
          "APPMOD_CALLER_TYPE": "modernize-cli"
        },
        "tools": ["*"]
    }
  }
}

Configuration des applications Java

Configurez GitHub Copilot serveur MCP de modernisation dans la section Cloud agent de vos paramètres de référentiel, comme illustré dans l’exemple suivant :

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

Étapes

Le flux interactif pour la délégation cloud est identique à Évaluer localement par le biais des étapes de source, de référentiel, de domaine et de configuration. La seule différence est le choix en mode exécution et ce qui se passe ensuite.

1. Exécutez l’agent de modernisation :

   modernize
   

2. Sélectionnez Évaluer dans le menu principal, choisissez votre source (fichier de configuration, entrée manuelle ou dossier actif), sélectionnez des référentiels, sélectionnez vos domaines d’évaluation et examinez la configuration. Ces étapes fonctionnent exactement comme décrit en mode interactif (évaluer localement).

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

   

4. Entrez le chemin de sortie des résultats de l’évaluation ou appuyez sur Entrée pour accepter la valeur par défaut.

5. L’agent délègue automatiquement les tâches d’évaluation pour chaque référentiel aux agents cloud et les exécute dans le cloud en parallèle.

   

   L’agent extrait les résultats de l’évaluation par application vers local et génère le rapport agrégé localement.

   

6. Une fois l’évaluation terminée, l’agent ouvre automatiquement le rapport agrégé.

Mode non interactif (CLI)

Vous pouvez également utiliser le mode non interactif en spécifiant directement des arguments de commande. Utilisez la commande modernize assess :

Évaluez localement à l’aide d’un fichier de configuration de référentiel :

modernize assess --source .github/modernize/repos.json

Évaluez plusieurs référentiels en spécifiant directement des sources :

modernize assess --source https://github.com/org/repo1 --source https://github.com/org/repo2

Évaluez en déléguant aux agents cloud :

modernize assess --source .github/modernize/repos.json --delegate cloud --wait

Pour plus d’informations, consultez évaluer - Commandes CLI.

Intégration d’Azure Migrate

Vous pouvez effectuer une évaluation par lots directement à partir de votre projet de Azure Migrate et renvoyer automatiquement les rapports résultants à Azure Migrate.

Flux de bout en bout :

1. Téléchargez un repos.json de démarrage à partir de Azure Migrate. Azure Migrate génère un fichier JSON délimité aux applications que vous avez sélectionnées pour l’évaluation de la modernisation. Le fichier contient déjà les entrées apps[] et le bloc output qui pointe vers votre projet Azure Migrate.

2. Renseignez les URL du référentiel. Modifiez chaque entrée repos[] dans le fichier téléchargé pour ajouter l’URL du référentiel GitHub pour l’application. Conservez les blocs apps[] et output comme Azure Migrate les avez générés : ces blocs pilotent le chargement.

3. Exécutez l’évaluation par lots. Exécutez l’évaluation localement ou en déléguant aux agents cloud en suivant les étapes précédentes. Les deux modes d’exécution respectent la configuration de sortie Azure Migrate.

4. Les rapports sont chargés automatiquement. Une fois l'évaluation terminée, l'agent de modernisation charge le rapport de chaque application dans votre projet de Azure Migrate. Aucune option CLI supplémentaire n’est requise : le paramètre output.type dans le fichier repos.json pilote le téléversement.

Présentation du rapport agrégé

Le rapport agrégé fournit une vue complète sur les applications évaluées comme suit :

Tableau de bord

• Instantané de l'intégrité du portefeuille : nombre total d'applications, nombre d'applications nécessitant des mises à niveau, et nombre total de blocages et de problèmes.
• Distribution de technologies : quels frameworks sont utilisés et combien d’applications les partagent.
• Répartition des efforts : indique si la migration globale est une petite ou grande entreprise.

Recommandations

• Azure Services : mappe les dépendances actuelles aux Azure équivalents recommandés. Les dépendances partagées entre les applications sont décidés une fois. Vous évitez donc de retravailler par application.
• Target Platform : guide le choix d’hébergement, tel que Azure Container Apps par rapport à AKS, et présente des opportunités de consolidation.
• Chemin de mise à niveau : identifie les applications qui ont besoin de mises à niveau de l’infrastructure en tant que prérequis, en séparant le travail de mise à niveau du travail de migration.
• Cost Estimate : estime le coût de Azure d’exécution de chaque application sur sa cible recommandée, afin de pouvoir prendre en compte les dépenses dans la hiérarchisation.
• Stratégies de migration : recommande une approche de migration pour chaque application — par exemple, Replatform pour des migrations de type lift-and-reshape ou Rearchitect pour une refactorisation plus approfondie — afin que chaque application bénéficie d’une stratégie adaptée à son niveau de préparation.
• Vagues de migration : répartit les applications en phases selon leur niveau de préparation et de risque (par exemple, vague 1 : gains rapides, vague 2 : socle cloud, vague 3 : paris à long terme). Cette approche permet de gagner rapidement, tandis que les applications plus difficiles sont préparées en parallèle.

Matrice d’évaluation des applications

• Vue d’ensemble rapide de chaque application sur les aspects de l’infrastructure, de la plateforme cible, de la recommandation de mise à niveau, de la répartition des problèmes (obligatoire, potentiel, facultatif), du dimensionnement des efforts, etc.
• Liens vers des rapports d’application individuels pour descendre dans la hiérarchie si nécessaire.

Résolution des problèmes liés à l’évaluation 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 référentiels répertoriés dans repos.json.

É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 d’évaluation :

• Vérifiez si le référentiel contient des projets Java, .NET ou JavaScript/TypeScript valides.
• Vérifiez que les fichiers de build existent, tels que pom.xml, , build.gradle*.csproj, *.sln, *.slnx, ou package.json.
• Passez en revue les messages d’erreur dans la sortie de la console. Les avertissements sans gravité (par exemple, des fichiers de build manquants dans un sous-module) sont désormais affichés directement dans la sortie de l’interface en ligne de commande ; examinez-les avant de considérer le rapport comme définitif.

Problèmes de délégation d’agent cloud :

• La délégation de l’agent cloud accepte uniquement les URL de référentiel https://github.com/.... Les chemins d’accès locaux et les fournisseurs non GitHub (GitLab, Azure DevOps) sont rejetés en amont avec une erreur descriptive. Utilisez l’exécution locale pour ces référentiels.
• Vérifiez que vous disposez des autorisations appropriées pour créer des flux de travail GitHub Actions.
• Vérifiez GitHub Actions autorisations et limites de quota pour votre organisation.
• Pour les applications .NET Framework, vérifiez que la configuration de l'exécuteur Windows est correctement définie.
• Vérifiez la configuration de votre serveur MCP.

Étapes suivantes

Une fois l’évaluation par lots terminée, vous pouvez :

Poursuivez le flux de travail de modernisation :

• Exécutez la mise à niveau par lots entre les référentiels : appliquez des mises à niveau cohérentes en fonction des résultats de l’évaluation.

En savoir plus :

• Créez des compétences personnalisées pour des modèles spécifiques à l’organisation.
• Découvrez les commandes CLI.

Fournir des commentaires

Votre entrée est importante ! Si vous avez des commentaires sur l’évaluation 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.