Integracja CI/CD z Modernize CLI

Zintegruj Modernize CLI z potokami ciągłej integracji i wdrażania, aby zautomatyzować modernizację aplikacji w dużej skali. W tym artykule pokazano, jak skonfigurować zarówno funkcję GitHub Actions, jak i usługę Azure Pipelines w celu uruchomienia interfejsu wiersza polecenia modernizacji zgodnie z harmonogramem lub na żądanie.

Uruchomienie Modernize CLI w potoku CI/CD umożliwia:

• Automatyzowanie uaktualnień zgodnie z harmonogramem cyklicznym bez ręcznej interwencji.
• Ustandaryzuj procesy modernizacyjne w całej organizacji.
• Śledzenie zmian za pomocą dedykowanych gałęzi i artefaktów budowania.
• Przejrzyj wyniki za pośrednictwem żądań ściągnięcia, podsumowań kompilacji i dzienników.

Przykładowe potoki w tym artykule wykonują następujące kroki:

1. Pobierz i zainstaluj najnowszy Modernize CLI.
2. Uruchom polecenie modernize upgrade z konfigurowalnym obiektem docelowym (na przykład Java 21).
3. Zatwierdź wszelkie wynikowe zmiany i prześlij je do dedykowanej gałęzi.
4. Opublikuj podsumowanie wyników i prześlij logi CLI jako artefakty kompilacji.

Wymagania wstępne

GitHub Actions

• Subskrypcja Usługi GitHub Copilot: bezpłatna, Pro, Pro+, Business lub Enterprise. Zobacz Plany Copilot.
• Token osobistego dostępu w GitHubie: twórz ten token i zapisz go jako wpis tajny repozytorium o nazwie GH_TOKEN. Zobacz Zarządzanie osobistymi tokenami dostępu.

Azure Pipelines

• Subskrypcja Usługi GitHub Copilot: bezpłatna, Pro, Pro+, Business lub Enterprise. Zobacz Plany Copilot.
• Uprawnienia do tworzenia usługi Azure Pipelines: zobacz Informacje o uprawnieniach i grupach zabezpieczeń.
• Uprawnienia usługi kompilacji: tożsamość usługi kompilacji potoku wymaga uprawnień do zapisu w repozytorium. Zobacz Uruchamianie poleceń usługi Git w skrycie.
  • Przejdź doobszaru Repozytoria> projektu.
  • Wybierz repozytorium docelowe, a następnie wybierz kartę Zabezpieczenia .
  • Wyszukaj tożsamość usługi kompilacji (na przykład Project Collection Build Service (<Organization>)).
  • Ustaw następujące uprawnienia na Zezwalaj:
    • Tworzenie gałęzi
    • Przyczynić się
    • Przeczytaj
• Osobisty Token Dostępu dla GitHub (PAT): Utwórz token i zapisz go jako zmienną potoku o nazwie GH_TOKEN. Zobacz Zarządzanie osobistymi tokenami dostępu i Definiowanie zmiennych.

Skonfiguruj potok danych

GitHub Actions

Utwórz plik przepływu pracy w repozytorium pod .github/workflows/modernize.yml z następującą zawartością:

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. Utwórz w repozytorium plik YAML dla potoku, na przykład , z następującą zawartością.

   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. Utwórz potok platformy Azure, który odwołuje się do tego pliku YAML. Aby uzyskać więcej informacji, zobacz Tworzenie pierwszego pipeline'u.

Szczegóły przepływu pracy

GitHub Actions

Przepływ pracy zawiera dwa wyzwalacze:

• Wysyłanie ręczne (workflow_dispatch): uruchom przepływ pracy na żądanie z karty Akcje. Opcjonalnie określ element docelowy aktualizacji, na przykład Java 21.
• Zaplanowane (schedule): Uruchamiane automatycznie codziennie o 2:00 czasu UTC. Dostosuj wyrażenie cron, aby było zgodne z preferowanym harmonogramem.

Każdy przebieg wykonuje następujące kroki:

1. Sprawdź kod repozytorium.
2. Pobiera i instaluje najnowszą wersję Modernize CLI.
3. Uruchamia modernize upgrade z określonym elementem docelowym lub uruchamia latest jako domyślne.latest
4. Zatwierdza wszelkie zmiany i przesyła je do gałęzi z oznaczeniem czasowym.
5. Zapisuje podsumowanie z gałęzi i linkami do pull requestów w podsumowaniu kroku GitHub Actions.
6. Przesyła dzienniki z Modernize CLI jako artefakt kompilacji w celu rozwiązywania problemów.

Uwaga / Notatka

Przepływ pracy jest resetowany .github/workflows przed zatwierdzeniem, aby uniknąć przypadkowego zmodyfikowania samego pliku przepływu pracy.

Azure Pipelines

Pipelina zawiera dwa wyzwalacze:

• Uruchamianie ręczne: uruchamianie potoku na żądanie z usługi Azure DevOps. Określ parametr docelowy uaktualnienia, taki jak Java 21.
• Zaplanowane (schedules): Uruchom automatycznie o 2:00 czasu UTC codziennie na gałęzi main. Dostosuj wyrażenie cron, aby było zgodne z preferowanym harmonogramem.

Każdy przebieg wykonuje następujące kroki:

1. Pobiera repozytorium z zachowanymi poświadczeniami w celu wypychania zmian.
2. Pobiera i instaluje najnowszą wersję Modernize CLI.
3. Uruchamia modernize upgrade z określonym elementem docelowym lub uruchamia latest jako domyślne.latest
4. Zatwierdza wszelkie zmiany i przesyła je do gałęzi wynikowej nazwanej identyfikatorem kompilacji.
5. Publikuje plik markdown z podsumowaniem jako artefakt kompilacji.
6. Przesyła dzienniki z Modernize CLI jako artefakt kompilacji w celu rozwiązywania problemów.

Uruchamianie potoku

GitHub Actions

Aby ręcznie wyzwolić przepływ pracy:

1. Przejdź do repozytorium w witrynie GitHub.
2. Wybierz kartę Działania.
3. Wybierz pozycję Modernization CLI z listy przepływów pracy.
4. Wybierz pozycję Uruchom przepływ pracy.
5. Opcjonalnie wprowadź cel uaktualnienia, a następnie wybierz Uruchom przepływ pracy, aby potwierdzić.

Po zakończeniu przepływu pracy przejrzyj podsumowanie kroków, aby uzyskać linki do gałęzi wyników i utworzyć żądanie ściągnięcia w celu scalenia zmian.

Azure Pipelines

Aby ręcznie uruchomić pipeline:

1. Przejdź do projektu usługi Azure DevOps.
2. Wybierz pozycję Potoki z menu po lewej stronie.
3. Wybierz Modernization CLI pipeline.
4. Wybierz Uruchom potok.
5. Opcjonalnie zaktualizuj parametr cel aktualizacji, a następnie wybierz Uruchomić.

Po zakończeniu pipeline'u zapoznaj się z opublikowanymi artefaktami w celu przeglądu podsumowania i dzienników. Następnie utwórz pull request z gałęzi wynikowej.

Troubleshooting

Typowe problemy

Błędy uwierzytelniania:

• Sprawdź, czy tajny klucz lub zmienna GH_TOKEN są poprawnie ustawione z użyciem prawidłowego osobistego tokenu dostępu do GitHub.
• Upewnij się, że token ma wymagane zakresy dostępu do narzędzia GitHub Copilot.

Nie wykryto żadnych zmian:

• Modernize CLI może określić, że dla określonego docelowego obiektu nie są wymagane żadne zmiany.
• Przejrzyj przesłany artefakt logów, aby zdobyć szczegóły na temat oceny.

Błędy przesyłania (Azure Pipelines):

• Upewnij się, że tożsamość usługi kompilacji ma uprawnienia Utwórz gałąź, Współtworzenie i Odczyt w repozytorium.
• Aby uzyskać szczegółowe instrukcje dotyczące konfigurowania, zobacz Uruchamianie poleceń git w skrycie .

Modernizuj błędy pobierania interfejsu wiersza polecenia:

• Sprawdź, czy agent ma dostęp do Internetu https://github.com.
• Sprawdź ograniczenia serwera proxy lub zapory, które mogą blokować pobieranie.

Następne kroki

• Dowiedz się o poleceniach interfejsu wiersza polecenia
• Uruchom ocenę wsadową
• Uruchom uaktualnienie wsadowe
• Tworzenie niestandardowych umiejętności dla wzorców specyficznych dla organizacji