Integración de CI/CD con Modernize CLI

Integre la CLI de Modernize en las canalizaciones de CI/CD para automatizar la modernización de aplicaciones a escala. En este artículo se muestra cómo configurar Acciones de GitHub y Azure Pipelines para ejecutar la CLI de Modernize según una programación o a petición.

La ejecución de la CLI de Modernize en una canalización de CI/CD le permite:

• Automatice las actualizaciones de manera recurrente sin necesidad de intervención manual.
• Estandarizar los flujos de trabajo de modernización en toda la organización.
• Realice un seguimiento de los cambios a través de ramas dedicadas y cree artefactos.
• Revise los resultados a través de solicitudes de incorporación de cambios, resúmenes de compilación y registros.

Las canalizaciones de ejemplo de este artículo realizan los pasos siguientes:

1. Descargue e instale la CLI de Modernize más reciente.
2. Ejecute modernize upgrade con un destino configurable (por ejemplo, Java 21).
3. Confirme los cambios resultantes e insértelos en una rama dedicada.
4. Publique un resumen de resultados y cargue los registros de la CLI como artefactos de compilación.

Prerrequisitos

Acciones de GitHub

• Una suscripción a GitHub Copilot: plan Gratis, Pro, Pro+, Empresa o Enterprise. Consulta los planes de Copilot.
• Un token de acceso personal (PAT) de GitHub: cree un token y almacénelo como un secreto de repositorio denominado GH_TOKEN. Consulte Administración de los tokens de acceso personal.

Azure Pipelines

• Una suscripción a GitHub Copilot: plan Gratis, Pro, Pro+, Empresa o Enterprise. Consulta los planes de Copilot.
• Permisos para crear Azure Pipelines: consulte Acerca de los permisos y los grupos de seguridad.
• Permisos del servicio de compilación: la identidad del servicio de compilación de la canalización necesita permisos para escribir en el repositorio. Consulte Ejecución de comandos de Git en un script.
  • Vaya a Configuración del proyecto>Repositorios.
  • Seleccione el repositorio de destino y, a continuación, seleccione la pestaña Seguridad .
  • Busque la identidad del servicio de compilación (por ejemplo, Project Collection Build Service (<Organization>)).
  • Establezca los permisos siguientes en Permitir:
    • Crear rama
    • Contribuir
    • Leer
• Un token de acceso personal (PAT) de GitHub: cree un token y almacénelo como una variable de canalización denominada GH_TOKEN. Consulte Administración de los tokens de acceso personal y Definición de variables.

Configuración de la canalización

Acciones de GitHub

Cree un archivo de flujo de trabajo en .github/workflows/modernize.yml en el repositorio con el siguiente contenido:

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. Cree un archivo YAML de canalización ( por ejemplo, azure-pipelines-modernize.yml ) en el repositorio con el siguiente contenido.

   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. Cree una canalización de Azure que haga referencia a este archivo YAML. Para obtener más información, consulte Creación de su primera canalización.

Detalles del flujo de trabajo

Acciones de GitHub

El flujo de trabajo incluye dos desencadenadores:

• Envío manual (workflow_dispatch): ejecute el flujo de trabajo a petición desde la pestaña Acciones . Opcionalmente, especifique un destino de actualización como Java 21.
• Programado (schedule): se ejecuta automáticamente a las 2:00 UTC diariamente. Ajuste la expresión cron para que coincida con la programación preferida.

Cada ejecución realiza los pasos siguientes:

1. Extrae el código del repositorio.
2. Descarga e instala la CLI de Modernize más reciente.
3. Se ejecuta modernize upgrade con el destino especificado o por defecto en latest.
4. Confirma los cambios e los inserta en una rama con marca de tiempo.
5. Escribe un resumen con vínculos de rama y solicitud de incorporación de cambios en el resumen del paso Acciones de GitHub.
6. Carga Modernizar los registros de la CLI como un artefacto de compilación para solucionar problemas.

Nota:

El flujo de trabajo se restablece .github/workflows antes de confirmar para evitar modificar accidentalmente el propio archivo de flujo de trabajo.

Azure Pipelines

La canalización incluye dos desencadenadores:

• Ejecución manual: ejecute la canalización a petición desde Azure DevOps. Especifique un parámetro de destino de actualización como Java 21.
• Programado (schedules): Se ejecuta automáticamente a las 2:00 UTC diariamente en la rama main. Ajuste la expresión cron para que coincida con la programación preferida.

Cada ejecución realiza los pasos siguientes:

1. Comprueba el repositorio con credenciales persistentes para insertar cambios.
2. Descarga e instala la CLI de Modernize más reciente.
3. Se ejecuta modernize upgrade con el destino especificado o por defecto en latest.
4. Confirma los cambios e los inserta en una rama de resultados denominada con el identificador de compilación.
5. Publica un archivo markdown de resumen como un artefacto de compilación.
6. Carga Modernizar los registros de la CLI como un artefacto de compilación para solucionar problemas.

Ejecución de la canalización

Acciones de GitHub

Para desencadenar el flujo de trabajo manualmente:

1. Vaya al repositorio en GitHub.
2. Selecciona la pestaña Acciones.
3. Seleccione La CLI de modernización en la lista de flujos de trabajo.
4. Seleccione Ejecutar flujo de trabajo.
5. Opcionalmente, escriba un destino de actualización y, a continuación, seleccione Ejecutar flujo de trabajo para confirmar.

Una vez finalizado el flujo de trabajo, revise el resumen del paso para ver los vínculos a la rama de resultados y cree una solicitud de incorporación de cambios para combinar los cambios.

Azure Pipelines

Para desencadenar la canalización manualmente:

1. Vaya al proyecto de Azure DevOps.
2. Seleccione Canalizaciones en el panel de navegación izquierdo.
3. Seleccione la pipeline de Modernization CLI.
4. Selecciona Ejecutar canalización.
5. Opcionalmente, actualice el parámetro Upgrade target (Actualizar parámetro de destino) y, a continuación, seleccione Ejecutar.

Una vez finalizada la canalización, revise los artefactos publicados para el resumen y los registros. A continuación, cree una solicitud de incorporación de cambios de la rama de resultados.

Solución de problemas

Problemas comunes

Errores de autenticación:

• Compruebe que el secreto o la GH_TOKEN variable se ha establecido correctamente con un token de acceso personal de GitHub válido.
• Asegúrese de que el token tiene los ámbitos necesarios para el acceso a GitHub Copilot.

No se detectaron cambios:

• La CLI de Modernize podría determinar que no se necesitan cambios para el destino especificado.
• Revise los archivos de registro cargados para más detalles sobre la evaluación.

Errores de envío (Azure Pipelines):

• Confirme que la identidad del servicio de compilación tiene permisos crear rama, Contribuir y Leer en el repositorio.
• Consulte Ejecución de comandos de Git en un script para obtener instrucciones detalladas de configuración.

Modernizar errores de descarga del CLI:

• Verifique que el corredor tiene acceso a Internet a https://github.com.
• Compruebe si hay restricciones de proxy o firewall que podrían bloquear la descarga.

Pasos siguientes

• Más información sobre los comandos de la CLI
• Ejecución de la evaluación por lotes
• Ejecución de la actualización por lotes
• Creación de aptitudes personalizadas para patrones específicos de la organización