Integrazione CI/CD con Modernize CLI

• Sottoscrizione di GitHub Copilot: piano Gratuito, Pro, Pro+, Business o Enterprise. Vedere Piani di Copilot.
• Un token di accesso personale di GitHub: creare un token e archiviarlo come segreto del repository denominato GH_TOKEN. Vedere Gestione dei token di accesso personali.

• Sottoscrizione di GitHub Copilot: piano Gratuito, Pro, Pro+, Business o Enterprise. Vedere Piani di Copilot.
• Autorizzazioni per la creazione di Azure Pipelines: vedere Informazioni sulle autorizzazioni e sui gruppi di sicurezza.
• Autorizzazioni del servizio di build: l'identità del servizio di build della pipeline deve disporre delle autorizzazioni per la scrittura nel repository. Vedere Eseguire comandi Git in uno script.
  • Vai a Impostazioni del progetto>Repository.
  • Selezionare il repository di destinazione e quindi selezionare la scheda Sicurezza .
  • Cerca l'identità del servizio di build, ad esempio Project Collection Build Service (<Organization>).
  • Impostare le autorizzazioni seguenti su Consenti:
    • Creare un ramo
    • Contribuire
    • Leggere
• Un token di accesso personale di GitHub: creare un token e archiviarlo come variabile della pipeline denominata GH_TOKEN. Vedere Gestione dei token di accesso personale e Definire le variabili.

Crea un file di flusso di lavoro in .github/workflows/modernize.yml nel tuo repository con il contenuto seguente:

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

1. Creare un file YAML per la pipeline - ad esempio, azure-pipelines-modernize.yml - nel repository con il contenuto seguente.

   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. Creare una pipeline di Azure che faccia riferimento a questo file YAML. Per altre informazioni, vedere Creare la prima pipeline.

Il flusso di lavoro include due trigger:

• Invio manuale (workflow_dispatch): eseguire il flusso di lavoro su richiesta dalla scheda Azioni . Specificare facoltativamente una destinazione di aggiornamento, Java 21ad esempio .
• Pianificato (schedule): viene eseguito automaticamente alle 2:00 UTC giornaliere. Modificare l'espressione cron in modo che corrisponda alla pianificazione preferita.

Ogni esecuzione compie i passaggi seguenti:

1. Estrae il codice del repository.
2. Scarica e installa la versione più recente dell'interfaccia della riga di comando di Modernize.
3. Esegue modernize upgrade con la destinazione specificata o ricorre a latest.
4. Esegue il commit delle modifiche e le inserisce in un branch con timestamp.
5. Scrive un riepilogo con collegamenti al branch e alle pull request per il riepilogo dei passaggi di GitHub Actions.
6. Carica i log di Modernize CLI come artefatto di build per la risoluzione dei problemi.

La pipeline include due trigger:

• Esecuzione manuale: eseguire la pipeline su richiesta da Azure DevOps. Specificare un parametro di destinazione di aggiornamento, Java 21ad esempio .
• Pianificato (schedules): viene eseguito automaticamente alle 2:00 UTC giornaliere nel main ramo. Modificare l'espressione cron in modo che corrisponda alla pianificazione preferita.

Ogni esecuzione compie i passaggi seguenti:

1. Effettua il checkout del repository con credenziali persistenti per spingere le modifiche.
2. Scarica e installa la versione più recente dell'interfaccia della riga di comando di Modernize.
3. Esegue modernize upgrade con la destinazione specificata o ricorre a latest.
4. Esegue il commit di tutte le modifiche e inserisce queste in un ramo di risultato denominato con l'ID di build.
5. Pubblica un file markdown di riepilogo come artefatto di compilazione.
6. Carica i log di Modernize CLI come artefatto di build per la risoluzione dei problemi.

Per attivare manualmente il flusso di lavoro:

1. Vai al tuo repository su GitHub.
2. Seleziona la scheda Azioni.
3. Selezionare Modernization CLI nell'elenco dei flussi di lavoro.
4. Selezionare Esegui flusso di lavoro.
5. Facoltativamente, immettere una destinazione di aggiornamento e quindi selezionare Esegui flusso di lavoro per confermare.

Al termine del flusso di lavoro, esaminare il riepilogo dei passaggi per i collegamenti al ramo dei risultati e creare una richiesta pull per unire le modifiche.

Per attivare la pipeline manualmente:

1. Passare al progetto Azure DevOps.
2. Selezionare Pipelines dalla barra di navigazione a sinistra.
3. Selezionare la pipeline Modernization CLI.
4. Selezionare Esegui pipeline.
5. Facoltativamente, aggiornare il parametro Di destinazione dell'aggiornamento e quindi selezionare Esegui.

Al termine della pipeline, esaminare gli elementi pubblicati, compreso il riepilogo e i log. Creare quindi una richiesta pull dal ramo dei risultati.