Integração CI/CD com Modernize CLI

• Uma subscrição do GitHub Copilot: plano Gratuito, Pro, Pro+, Business ou Enterprise. Ver planos do Copilot.
• Um Token de Acesso Pessoal (PAT) no GitHub: Crie um token e armazene-o como um segredo de repositório chamado GH_TOKEN. Veja Gestão dos seus tokens de acesso pessoais.

• Uma subscrição do GitHub Copilot: plano Gratuito, Pro, Pro+, Business ou Enterprise. Ver planos do Copilot.
• Permissões para criar Azure Pipelines: Veja Sobre permissões e grupos de segurança.
• Permissões do serviço de compilação: A identidade do serviço de compilação do pipeline necessita de permissões para escrever no repositório. Veja Executar comandos Git num script.
  • Vai a Definições do Projeto>Repositórios.
  • Selecione o repositório de destino e depois selecione a aba Segurança.
  • Procure a identidade do serviço de compilação (por exemplo, Project Collection Build Service (<Organization>)).
  • Defina as seguintes permissões para Permitir:
    • Criar ramificação
    • Contribua
    • Leia
• Um Token de Acesso Pessoal (PAT) no GitHub: Crie um token e armazene-o como uma variável pipeline chamada GH_TOKEN. Veja Gestão dos seus tokens pessoais de acesso e Definir variáveis.

Crie um ficheiro de fluxo de trabalho no .github/workflows/modernize.yml seu repositório com o seguinte conteúdo:

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. Crie um ficheiro YAML de pipeline – por exemplo, azure-pipelines-modernize.yml – no seu repositório com o seguinte conteúdo.

   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. Crie um Azure Pipeline que faça referência a este ficheiro YAML. Para obter mais informações, consulte Criar seu primeiro pipeline.

O fluxo de trabalho inclui dois gatilhos:

• Despacho manual (workflow_dispatch): Execute o fluxo de trabalho a pedido a partir do separador Ações . Opcionalmente, especifique um alvo de atualização como Java 21.
• Agendado (schedule): Funciona automaticamente às 2 da manhã UTC diariamente. Ajusta a expressão cron para corresponder ao teu horário preferido.

Cada corrida executa os seguintes passos:

1. Verifica o código do repositório.
2. Descarrega e instala a mais recente CLI do Modernize.
3. Executa modernize upgrade com o alvo especificado ou utiliza latest por predefinição.
4. Faz commit de quaisquer alterações e envia-as para um ramo com carimbo de data/hora.
5. Escreve um resumo dos passos do GitHub Actions com links para a branch e o PR.
6. Carrega registos do Modernize CLI como artefato de build para diagnóstico de problemas.

O pipeline inclui dois gatilhos:

• Execução manual: Executar o pipeline a pedido do Azure DevOps. Especifique um parâmetro alvo de atualização, como Java 21.
• Agendado (schedules): Funciona automaticamente às 2 da manhã UTC diariamente no main ramal. Ajusta a expressão cron para corresponder ao teu horário preferido.

Cada corrida executa os seguintes passos:

1. Verifica o repositório com credenciais persistentes para efetuar alterações.
2. Descarrega e instala a mais recente CLI do Modernize.
3. Executa modernize upgrade com o alvo especificado ou utiliza latest por predefinição.
4. Executa o commit de quaisquer alterações e envia-as para um branch de resultados nomeado com o ID da build.
5. Publica um ficheiro de markdown resumo como artefacto de build.
6. Carrega registos do Modernize CLI como artefato de build para diagnóstico de problemas.

Para ativar o fluxo de trabalho manualmente:

1. Vai ao teu repositório no GitHub.
2. Selecione o separador Ações.
3. Selecione CLI de Modernização na lista de workflow.
4. Selecione Executar fluxo de trabalho.
5. Opcionalmente, introduza um alvo de atualização e depois selecione Executar fluxo de trabalho para confirmar.

Depois do fluxo de trabalho terminar, reveja o resumo dos passos para ligações para o ramo de resultados e crie um pull request para integrar as alterações.

Para acionar o pipeline manualmente:

1. Vá para seu projeto do Azure DevOps.
2. Selecione Pipelines na navegação da esquerda.
3. Selecione o pipeline CLI de Modernização.
4. Selecione Executar pipeline.
5. Opcionalmente, atualiza o parâmetro de Upgrade target e depois seleciona Executar.

Depois de o pipeline terminar, reveja os artefatos publicados para o resumo e os registros. Depois cria um pull request a partir do ramo de resultados.