CI/CD-Integration mit Modernize CLI

Integrieren Sie die Modernize CLI in Ihre CI/CD-Pipelines, um die Anwendungsmodernisierung im großen Maßstab zu automatisieren. In diesem Artikel erfahren Sie, wie Sie sowohl GitHub-Aktionen als auch Azure-Pipelines so konfigurieren, dass die MODERNize CLI nach einem Zeitplan oder bei Bedarf ausgeführt wird.

Das Ausführen der Modernize CLI in einer CI/CD-Pipeline ermöglicht Folgendes:

• Automatisieren Sie Upgrades nach einem wiederkehrenden Zeitplan ohne manuelle Eingriffe.
• Standardisieren Sie Modernisierungsworkflows in Ihrer Organisation.
• Nachverfolgen von Änderungen über dedizierte Verzweigungen und Erstellen von Artefakten.
• Überprüfen Sie die Ergebnisse durch Pull Requests, Build-Berichte und Protokolle.

Die Beispiel-Pipelines in diesem Artikel führen die folgenden Schritte aus:

1. Laden Sie die neueste Modernize CLI herunter, und installieren Sie sie.
2. Führen Sie modernize upgrade mit einem konfigurierbaren Ziel aus (z. B. Java 21).
3. Übernehmen Sie alle resultierenden Änderungen und pushen Sie sie auf einen dedizierten Zweig.
4. Veröffentlichen Sie eine Ergebniszusammenfassung, und laden Sie CLI-Protokolle als Buildartefakte hoch.

Voraussetzungen

GitHub-Aktionen

• Ein GitHub Copilot-Abonnement: Kostenloser, Pro-, Pro+-, Business- oder Enterprise-Plan. Weitere Informationen findest du unter Copilot-Pläne.
• Ein GitHub Personal Access Token (PAT):Erstellen Sie ein Token, und speichern Sie es als Repositoryschlüssel mit dem Namen GH_TOKEN. Siehe Verwalten Ihrer persönlichen Zugriffstoken.

Azure-Pipelines

• Ein GitHub Copilot-Abonnement: Kostenloser, Pro-, Pro+-, Business- oder Enterprise-Plan. Weitere Informationen findest du unter Copilot-Pläne.
• Berechtigungen zum Erstellen von Azure-Pipelines: Informationen zu Berechtigungen und Sicherheitsgruppen.
• Builddienstberechtigungen: Die Builddienstidentität der Pipeline benötigt Berechtigungen zum Schreiben in das Repository. Siehe Ausführen von Git-Befehlen in einem Skript.
  • Wechseln Sie zu Projekteinstellungen>Repositorys.
  • Wählen Sie das Ziel-Repository und dann die Registerkarte "Sicherheit " aus.
  • Suchen Sie nach der Builddienstidentität (z. B. Project Collection Build Service (<Organization>)).
  • Legen Sie die folgenden Berechtigungen auf "Zulassen" fest:
    • Verzweigung erstellen
    • Beitragen
    • Lesen
• Ein GitHub Personal Access Token (PAT):Erstellen Sie ein Token, und speichern Sie es als Pipelinevariable namens GH_TOKEN. Siehe Verwalten Ihrer persönlichen Zugriffstoken und Definieren von Variablen.

Konfigurieren der Pipeline

GitHub-Aktionen

Erstellen Sie eine Workflowdatei in .github/workflows/modernize.yml Ihrem Repository mit dem folgenden Inhalt:

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. Erstellen Sie eine YaML-Pipelinedatei – z. B azure-pipelines-modernize.yml . – in Ihrem Repository mit dem folgenden Inhalt.

   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. Erstellen Sie eine Azure-Pipeline, die auf diese YAML-Datei verweist. Weitere Informationen finden Sie unter Erstellen Ihrer ersten Pipeline.

Workflowdetails

GitHub-Aktionen

Der Workflow enthält zwei Trigger:

• Manueller Start (workflow_dispatch): Führen Sie den Workflow auf Anforderung auf der Registerkarte Aktionen aus. Geben Sie optional ein Upgrade-Ziel an, z. B. Java 21.
• Geplant (schedule): Wird täglich um 2 UHR UTC automatisch ausgeführt. Passen Sie den Cron-Ausdruck an Ihren bevorzugten Zeitplan an.

Jede Ausführung führt die folgenden Schritte aus:

1. Überprüft den Repositorycode.
2. Lädt die neueste Modernize CLI herunter und installiert sie.
3. Wird modernize upgrade mit dem angegebenen Ziel oder standardmäßig mit latest.
4. Führt einen Commit für alle Änderungen durch und verschiebt sie an eine Zeitstempel-Verzweigung.
5. Schreibt eine Zusammenfassung mit Verzweigungs- und PR-Links zur GitHub Actions-Schrittzusammenfassung.
6. Lädt Modernisierungs-CLI-Protokolle als Buildartefakt zur Problembehandlung hoch.

Hinweis

Der Workflow wird zurückgesetzt .github/workflows, bevor ein Commit durchgeführt wird, um zu vermeiden, dass die Workflowdatei versehentlich selbst geändert wird.

Azure-Pipelines

Die Pipeline enthält zwei Trigger:

• Manuelle Ausführung: Führen Sie die Pipeline bei Bedarf aus Azure DevOps aus. Geben Sie einen Upgradezielparameter wie Java 21 an.
• Geplant (schedules): Wird täglich um 2 UHR UTC auf der main Zweigstelle ausgeführt. Passen Sie den Cron-Ausdruck an Ihren bevorzugten Zeitplan an.

Jede Ausführung führt die folgenden Schritte aus:

1. Checkt das Repository mit gespeicherten Anmeldeinformationen aus, um Änderungen zu pushen.
2. Lädt die neueste Modernize CLI herunter und installiert sie.
3. Wird modernize upgrade mit dem angegebenen Ziel oder standardmäßig mit latest.
4. Führt einen Commit für alle Änderungen durch und überträgt sie an einen Ergebniszweig, der mit der Build-ID benannt ist.
5. Veröffentlicht eine Zusammenfassungs-Markdown-Datei als Build-Artefakt.
6. Lädt Modernisierungs-CLI-Protokolle als Buildartefakt zur Problembehandlung hoch.

Führen Sie die Pipeline aus.

GitHub-Aktionen

So lösen Sie den Workflow manuell aus:

1. Wechseln Sie zu Ihrem Repository auf GitHub.
2. Klicken Sie auf die Registerkarte Actions (Aktionen).
3. Wählen Sie die Modernisierungs-CLI aus der Workflowliste aus.
4. Wählen Sie "Workflow ausführen" aus.
5. Geben Sie optional ein Upgradeziel ein, und wählen Sie dann " Workflow ausführen " aus, um dies zu bestätigen.

Überprüfen Sie nach Abschluss des Workflows die Schrittzusammenfassung für Verknüpfungen mit der Ergebniszweigung, und erstellen Sie eine Pullanforderung zum Zusammenführen der Änderungen.

Azure-Pipelines

So lösen Sie die Pipeline manuell aus:

1. Wechseln Sie zu Ihrem Azure DevOps-Projekt.
2. Wählen Sie "Pipelines" aus der linken Navigation aus.
3. Wählen Sie die Modernisierungs-CLI-Pipeline aus.
4. Klicken Sie auf Pipeline ausführen.
5. Aktualisieren Sie optional den Upgradezielparameter , und wählen Sie dann "Ausführen" aus.

Überprüfen Sie nach Abschluss der Pipeline die veröffentlichten Artefakte im Hinblick auf die Zusammenfassung und die Protokolle. Erstellen Sie dann eine Pullanforderung aus der Ergebniszweigung.

Problembehandlung

Häufige Probleme

Authentifizierungsfehler:

• Überprüfen Sie, ob der geheime Schlüssel oder die GH_TOKEN Variable korrekt mit einem gültigen GitHub Personal Access Token festgelegt ist.
• Stellen Sie sicher, dass das Token über die erforderlichen Bereiche für den GitHub Copilot-Zugriff verfügt.

Es wurden keine Änderungen erkannt:

• Die Modernize CLI kann feststellen, dass für das angegebene Ziel keine Änderungen erforderlich sind.
• Überprüfen Sie das hochgeladene Protokollartefakt auf Details zur Bewertung.

Push-Fehler (Azure Pipelines):

• Vergewissern Sie sich, dass die Builddienst-Identität über die Berechtigungen Zweig erstellen, Mitwirken und Lesen für das Repository verfügt.
• Ausführliche Anweisungen zum Einrichten finden Sie unter Run Git commands in a script.

Modernisieren von CLI-Downloadfehlern:

• Vergewissern Sie sich, dass der Läufer über Internetzugriff verfügt https://github.com.
• Überprüfen Sie auf Proxy- oder Firewalleinschränkungen, die den Download blockieren können.

Nächste Schritte

• Informationen zu CLI-Befehlen
• Batchbewertung ausführen
• Batchupgrade ausführen
• Erstellen von benutzerdefinierten Fähigkeiten für organisationsspezifische Muster