Intégration CI/CD avec Modernize CLI

Intégrez la CLI de modernisation à vos pipelines CI/CD pour automatiser à grande échelle la modernisation des applications. Cet article vous montre comment configurer GitHub Actions et Azure Pipelines pour exécuter l’interface CLI Moderniser selon une planification ou à la demande.

Utiliser la CLI de modernisation dans un pipeline CI/CD vous permet de :

• Automatisez les mises à niveau selon une planification périodique sans intervention manuelle.
• Normaliser les flux de travail de modernisation au sein de votre organisation.
• Effectuez le suivi des modifications par le biais de branches dédiées et d’artefacts de build.
• Passez en revue les résultats par le biais de pull requests, de résumés de build et de journaux.

Les exemples de pipelines de cet article effectuent les étapes suivantes :

1. Téléchargez et installez la dernière version de Modernize CLI.
2. Exécuter modernize upgrade avec une cible configurable (par exemple). Java 21
3. Validez les modifications résultantes et envoyez-les à une branche dédiée.
4. Publiez un résumé des résultats et chargez les journaux CLI en tant qu’artefacts de build.

Prerequisites

GitHub Actions

• Un abonnement GitHub Copilot : Gratuit, Pro, Pro+, Business ou Enterprise. Consultez Plans Copilot.
• Un jeton d’accès personnel GitHub (PAT) : créez un jeton et stockez-le en tant que secret de dépôt nommé GH_TOKEN. Consultez Gestion de vos jetons d’accès personnels.

Azure Pipelines

• Un abonnement GitHub Copilot : Gratuit, Pro, Pro+, Business ou Enterprise. Consultez Plans Copilot.
• Autorisations de création d’Azure Pipelines : voir à propos des autorisations et des groupes de sécurité.
• Autorisations du build service : l'identité du build service du pipeline a besoin d'autorisations pour écrire dans le référentiel. Consultez Exécuter des commandes Git dans un script.
  • Accédez aux paramètres du projet>référentiels.
  • Sélectionnez le référentiel cible, puis sélectionnez l’onglet Sécurité .
  • Recherchez l’identité du service de génération (par exemple, Project Collection Build Service (<Organization>)).
  • Définissez les autorisations suivantes sur Autoriser :
    • Créer une branche
    • Contribuer
    • Lire
• Un jeton d’accès personnel GitHub (PAT) : créez un jeton et stockez-le en tant que variable de pipeline nommée GH_TOKEN. Consultez Gestion de vos jetons d’accès personnels et Définir des variables.

Configurer le pipeline

GitHub Actions

Créez un fichier de flux de travail dans .github/workflows/modernize.yml votre référentiel avec le contenu suivant :

name: Modernization CLI

on:
  workflow_dispatch:
    inputs:
      upgrade_target:
        description: 'Upgrade target (e.g., Java 21)'
        required: false
        default: 'latest'
  schedule:
    # Run during off-peak hours: 2 AM UTC daily
    - cron: '0 2 * * *'

permissions:
    id-token: write
    contents: write
    actions: read

jobs:
  modernization:
    runs-on: ubuntu-latest
    env:
      GH_TOKEN: ${{ secrets.GH_TOKEN }}

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Download Modernize CLI
        run: |
          curl -fsSL https://raw.githubusercontent.com/microsoft/modernize-cli/main/scripts/install.sh | sh

      - name: Run Modernize CLI to upgrade code
        run: |
          TARGET="${{ github.event.inputs.upgrade_target }}"
          if [ -z "$TARGET" ] || [ "$TARGET" = "latest" ]; then
            modernize upgrade --no-tty
          else
            modernize upgrade "$TARGET" --no-tty
          fi

      - name: Push changes to result branch
        id: push_changes
        run: |
          BRANCH_NAME="modernize-upgrade-${{ github.event.inputs.upgrade_target || 'latest' }}-$(date +%Y%m%d-%H%M%S)"

          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"

          git add -A
          git reset .github/workflows
          git diff --cached --quiet || git commit -m "chore: apply Modernize CLI changes [skip ci]"
          git checkout -B "$BRANCH_NAME"
          git push origin "$BRANCH_NAME"

          echo "BRANCH_NAME=$BRANCH_NAME" >> $GITHUB_OUTPUT

      - name: Display results summary
        if: success()
        run: |
          cat >> $GITHUB_STEP_SUMMARY <<EOF
          ## Modernization Complete

          ### Branch Information
          - **Result Branch**: \`${{ steps.push_changes.outputs.BRANCH_NAME }}\`
          - **Target**: ${{ github.event.inputs.upgrade_target || 'latest' }}

          ### Links
          - [View Branch](https://github.com/${{ github.repository }}/tree/${{ steps.push_changes.outputs.BRANCH_NAME }})
          - [Create PR](https://github.com/${{ github.repository }}/compare/main...${{ steps.push_changes.outputs.BRANCH_NAME }})
          EOF

      - name: Upload Modernize CLI logs
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: modernize-logs
          path: ~/.modernize/logs/
          if-no-files-found: warn

Azure Pipelines

1. Créez un fichier YAML de pipeline, par exemple, azure-pipelines-modernize.yml dans votre référentiel avec le contenu suivant.

   name: Modernization CLI
   
   schedules:
     - cron: '0 2 * * *'
       displayName: 'Daily 2 AM UTC build'
       branches:
         include:
           - main
       always: true
   
   parameters:
     - name: upgrade_target
       displayName: 'Upgrade target (e.g., Java 21)'
       type: string
       default: 'latest'
   
   variables:
     - name: BRANCH_NAME
       value: modernize-${{ parameters.upgrade_target }}-$(Build.BuildId)
   
   pool:
     vmImage: 'ubuntu-latest'
   
   jobs:
     - job: modernization
       displayName: 'Modernization CLI'
       steps:
         - checkout: self
           persistCredentials: true
   
         - task: Bash@3
           displayName: 'Download Modernize CLI'
           inputs:
             targetType: 'inline'
             script: |
               curl -fsSL https://raw.githubusercontent.com/microsoft/modernize-cli/main/scripts/install.sh | sh
   
         - task: Bash@3
           displayName: 'Run Modernize CLI to upgrade code'
           inputs:
             targetType: 'inline'
             script: |
               TARGET="${{ parameters.upgrade_target }}"
               if [ -z "$TARGET" ] || [ "$TARGET" = "latest" ]; then
                 modernize upgrade --no-tty
               else
                 modernize upgrade "$TARGET" --no-tty
               fi
           env:
             GH_TOKEN: $(GH_TOKEN)
   
         - task: Bash@3
           displayName: 'Push changes to result branch'
           inputs:
             targetType: 'inline'
             script: |
               git config user.name "Azure Pipelines"
               git config user.email "azuredevops@microsoft.com"
   
               git add -A
               git reset .github/workflows
               git diff --cached --quiet || git commit -m "chore: apply Modernize CLI changes [skip ci]"
               git checkout -B "$(BRANCH_NAME)"
               git push origin "$(BRANCH_NAME)"
   
         - task: Bash@3
           displayName: 'Display results summary'
           condition: succeeded()
           inputs:
             targetType: 'inline'
             script: |
               mkdir -p "$(Build.ArtifactStagingDirectory)/summary"
               cat > "$(Build.ArtifactStagingDirectory)/summary/SUMMARY.md" <<EOF
               ## Modernization Complete
   
               ### Branch Information
               - **Result Branch**: \`$(BRANCH_NAME)\`
               - **Target**: ${{ parameters.upgrade_target }}
   
               ### Links
               - [View Branch]($(Build.Repository.Uri)/tree/$(BRANCH_NAME))
               - [View Build]($(System.CollectionUri)$(System.TeamProject)/_build/results?buildId=$(Build.BuildId))
               EOF
   
         - task: PublishBuildArtifacts@1
           displayName: 'Publish summary'
           condition: succeeded()
           inputs:
             pathToPublish: '$(Build.ArtifactStagingDirectory)/summary'
             artifactName: 'modernize-summary'
           continueOnError: true
   
         - task: Bash@3
           displayName: 'Prepare logs for upload'
           condition: always()
           inputs:
             targetType: 'inline'
             script: |
               if [ -d "$HOME/.modernize/logs" ]; then
                 mkdir -p "$(Build.ArtifactStagingDirectory)/modernize-logs"
                 cp -r "$HOME/.modernize/logs/"* "$(Build.ArtifactStagingDirectory)/modernize-logs/" 2>/dev/null || true
               fi
           continueOnError: true
   
         - task: PublishBuildArtifacts@1
           displayName: 'Upload Modernize CLI logs'
           condition: always()
           inputs:
             pathToPublish: '$(Build.ArtifactStagingDirectory)/modernize-logs'
             artifactName: 'modernize-logs'
           continueOnError: true
   

2. Créez un pipeline Azure qui fait référence à ce fichier YAML. Pour plus d’informations, consultez Créer votre premier pipeline.

Détails du flux de travail

GitHub Actions

Le flux de travail comprend deux déclencheurs :

• Répartition manuelle (workflow_dispatch) : exécutez le flux de travail à la demande à partir de l’onglet Actions . Spécifiez éventuellement une cible de mise à niveau telle que Java 21.
• Planifié (schedule) : Exécutez automatiquement à 2 h UTC tous les jours. Ajustez l’expression cron pour qu’elle corresponde à votre planification préférée.

Chaque exécution suit les étapes suivantes :

1. Extrait le code du référentiel.
2. Télécharge et installe la dernière version du Modernize CLI.
3. S'exécute modernize upgrade avec la cible spécifiée ou utilise par défaut latest.
4. Valide toutes les modifications et les envoie (push) vers une branche horodatée.
5. Rédige un récapitulatif avec des liens de branches et de pull request vers le récapitulatif de l’étape GitHub Actions.
6. Charge les journaux de Modernize CLI comme artefact de build pour le dépannage.

Note

Avant de valider, le flux de travail est réinitialisé .github/workflows pour éviter de modifier accidentellement le fichier de flux de travail lui-même.

Azure Pipelines

Le pipeline comprend deux déclencheurs :

• Exécution manuelle : exécutez le pipeline à la demande à partir d’Azure DevOps. Spécifiez un paramètre cible de mise à niveau tel que Java 21.
• Planifié (schedules) : exécuté automatiquement à 2 h UTC tous les jours sur le main branch. Ajustez l’expression cron pour qu’elle corresponde à votre planification préférée.

Chaque exécution suit les étapes suivantes :

1. Extrait le dépôt avec des informations d’identification persistantes pour pousser les modifications.
2. Télécharge et installe la dernière version du Modernize CLI.
3. S'exécute modernize upgrade avec la cible spécifiée ou utilise par défaut latest.
4. Valide les modifications et les envoie (push) vers une branche de résultat nommée avec l’ID de build.
5. Publie un fichier markdown récapitulatif en tant qu'artefact de build.
6. Charge les journaux de Modernize CLI comme artefact de build pour le dépannage.

Exécuter le pipeline

GitHub Actions

Pour déclencher le flux de travail manuellement :

1. Accédez à votre dépôt sur GitHub.
2. Sélectionnez l’onglet Actions.
3. Sélectionnez l’interface CLI de modernisation dans la liste des flux de travail.
4. Sélectionnez Exécuter le flux de travail.
5. Si vous le souhaitez, entrez une cible de mise à niveau, puis sélectionnez Exécuter le flux de travail pour confirmer.

Une fois le flux de travail terminé, passez en revue le résumé des étapes pour y trouver les liens vers la branche de résultat et créez une pull request pour fusionner les modifications.

Azure Pipelines

Pour déclencher le pipeline manuellement :

1. Accédez à votre projet Azure DevOps.
2. Sélectionnez Pipelines dans le volet de navigation gauche.
3. Sélectionnez le pipeline Modernisation CLI.
4. Sélectionnez Exécuter le pipeline.
5. Mettez éventuellement à jour le paramètre cible de mise à niveau , puis sélectionnez Exécuter.

Après la fin du pipeline, examinez les artéfacts publiés pour le résumé et le journal. Créez ensuite une pull request à partir de la branche résultante.

Résolution des problèmes

Problèmes courants

Erreurs d’authentification :

• Vérifiez que le secret ou la GH_TOKEN variable est correctement défini avec un jeton d’accès personnel GitHub valide.
• Vérifiez que le jeton a les étendues requises pour l’accès à GitHub Copilot.

Aucune modification détectée :

• L’interface CLI de modernisation peut déterminer qu’aucune modification n’est nécessaire pour la cible spécifiée.
• Passez en revue le fichier de journal des journaux chargés pour obtenir les détails concernant l'évaluation.

Échecs de push (Azure Pipelines) :

• Vérifiez que l’identité du service de génération dispose des autorisations Créer une branche, Contribuer et Lire sur le référentiel.
• Pour obtenir des instructions détaillées sur l’installation, consultez Exécuter des commandes Git dans un script .

Moderniser les erreurs de téléchargement du CLI :

• Vérifiez que l’exécuteur dispose d’un accès Internet à https://github.com.
• Recherchez les restrictions de proxy ou de pare-feu susceptibles de bloquer le téléchargement.

Étapes suivantes

• En savoir plus sur les commandes CLI
• Exécuter l’évaluation par lots
• Exécuter la mise à niveau par lots
• Créer des compétences personnalisées pour des modèles spécifiques à l’organisation