CI/CD integráció a Modernize CLI-vel

A modernizálási parancssori felület integrálása a CI/CD-folyamatokba az alkalmazások nagy léptékű modernizálásának automatizálásához. Ez a cikk bemutatja, hogyan konfigurálhatja a GitHub Actionst és az Azure Pipelinest a modernizálási parancssori felület ütemezés szerinti vagy igény szerinti futtatásához.

A modernizálási parancssori felület CI/CD-folyamatokban való futtatásával a következőket hozhatja létre:

• A frissítések automatizálása ismétlődő ütemezés szerint manuális beavatkozás nélkül.
• A modernizálási munkafolyamatok egységesítése a szervezetben.
• A változások nyomon követése dedikált ágakon és összetevők létrehozása révén.
• Tekintse át az eredményeket lekéréses kérelmek, összefoglalók és naplók készítése révén.

A cikkben szereplő mintafolyamatok a következő lépéseket hajtják végre:

1. Töltse le és telepítse a legújabb Modernizálási parancssori felületet.
2. Futtasd modernize upgrade konfigurálható céllal (például Java 21).
3. Véglegesítse az esetleges módosításokat, és küldje el őket egy dedikált ágba.
4. Az eredmények összefoglalójának közzététele és a parancssori felület (CLI) naplók feltöltése build-artifaktumként.

Előfeltételek

GitHub-műveletek

• GitHub Copilot-előfizetés: Ingyenes, Pro, Pro+, Üzleti vagy Nagyvállalati csomag. Lásd „Copilot-tervek”.
• Egy GitHub személyes hozzáférési jogkivonat (PAT): Hozzon létre egy jogkivonatot, és tárolja azt egy adattárbeli titkos kódként.GH_TOKEN Lásd : Személyes hozzáférési jogkivonatok kezelése.

Azure Pipelines

• GitHub Copilot-előfizetés: Ingyenes, Pro, Pro+, Üzleti vagy Nagyvállalati csomag. Lásd „Copilot-tervek”.
• Az Azure Pipelines létrehozásához szükséges engedélyek: Lásd : Engedélyek és biztonsági csoportok.
• Buildszolgáltatás engedélyei: A buildszolgáltatás identitásának írási engedélyekkel kell rendelkeznie az adattárban. Lásd: Git-parancsok futtatása szkriptben.
  • Nyissa meg a Project>.
  • Jelölje ki a céladattárat, majd válassza a Biztonság lapot.
  • Keresse meg a buildszolgáltatás identitását (például Project Collection Build Service (<Organization>)).
  • Adja meg az alábbi engedélyeket az Engedélyezés beállításhoz:
    • Ág létrehozása
    • Hozzájárul
    • Olvass
• GitHub személyes hozzáférési jogkivonat (PAT): Hozzon létre egy jogkivonatot, és tárolja folyamatváltozóként a következő néven: GH_TOKEN. Lásd : Személyes hozzáférési jogkivonatok kezelése és változók definiálása.

A folyamat konfigurálása

GitHub-műveletek

Hozzon létre egy munkafolyamat-fájlt .github/workflows/modernize.yml az adattárban a következő tartalommal:

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. Hozzon létre egy folyamat YAML-fájlt – például azure-pipelines-modernize.yml – az adattárban az alábbi tartalommal.

   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. Hozzon létre egy Azure Pipeline-t, amely erre a YAML-fájlra hivatkozik. További információért lásd: Első csővezeték létrehozása.

Munkafolyamat részletei

GitHub-műveletek

A munkafolyamat két eseményindítót tartalmaz:

• Manuális küldés (workflow_dispatch): Futtassa igény szerint a munkafolyamatot a Műveletek lapon. Igény szerint adjon meg egy frissítési célt, például Java 21.
• Ütemezett (schedule): Naponta automatikusan fut 02:00 (UTC) időpontban. Módosítsa a cron kifejezést az előnyben részesített ütemezésnek megfelelően.

Minden futtatás a következő lépéseket hajtja végre:

1. Ellenőrzi az adattár kódját.
2. Letölti és telepíti a legújabb modernizálási parancssori felületet.
3. modernize upgrade a megadott céllal vagy alapértelmezett céllal fut.
4. Véglegesíti a módosításokat, és feltölti őket egy időponttal ellátott ágra.
5. Összegzést ír a GitHub Actions lépésösszegzésébe, ág- és PR-hivatkozásokkal.
6. A parancssori felületi naplók modernizálása összeállítási összetevőként a hibaelhárításhoz.

Megjegyzés:

A munkafolyamat a véglegesítés előtt alaphelyzetbe áll .github/workflows , hogy ne módosítsa véletlenül magát a munkafolyamatfájlt.

Azure Pipelines

A folyamat két eseményindítót tartalmaz:

• Manuális futtatás: A folyamat igény szerinti futtatása az Azure DevOpsból. Adjon meg egy frissítési célparamétert, például Java 21.
• Ütemezett (schedules): Naponta 2:00-kor (UTC) automatikusan fut az main ágon. Módosítsa a cron kifejezést az előnyben részesített ütemezésnek megfelelően.

Minden futtatás a következő lépéseket hajtja végre:

1. A módosítások leküldéséhez lekéri az adattárat a tárolt hitelesítő adatokkal.
2. Letölti és telepíti a legújabb modernizálási parancssori felületet.
3. modernize upgrade a megadott céllal vagy alapértelmezett céllal fut.
4. Véglegesíti a módosításokat, és leküldi őket a buildazonosítóval elnevezett eredményágba.
5. Összefoglaló markdown-fájlt tesz közzé build-artefaktumként.
6. A parancssori felületi naplók modernizálása összeállítási összetevőként a hibaelhárításhoz.

A csővezeték futtatása

GitHub-műveletek

A munkafolyamat manuális aktiválása:

1. Nyissa meg az adattárat a GitHubon.
2. Válassza a Műveletek lapot.
3. Válassza a Modernizálási parancssori felület lehetőséget a munkafolyamat-listából.
4. Válassza a Munkafolyamat futtatása lehetőséget.
5. Ha szeretné, adjon meg egy frissítési célt, majd válassza a Munkafolyamat futtatása lehetőséget a megerősítéshez.

A munkafolyamat befejezése után tekintse át a lépés összefoglalását az eredményágra mutató hivatkozásokért, és hozzon létre egy lekéréses kérelmet a módosítások egyesítéséhez.

Azure Pipelines

A folyamat manuális aktiválása:

1. Nyissa meg az Azure DevOps-projektet.
2. Válassza a Folyamatok lehetőséget a bal oldali navigációs sávon.
3. Válassza ki a Modernization CLI folyamatot.
4. Válassza a Folyamat futtatása lehetőséget.
5. Szükség esetén frissítse a frissítési célparamétert , majd válassza a Futtatás lehetőséget.

A folyamat befejezése után tekintse át a közzétett összetevőket az összegzéshez és a naplókhoz. Ezután hozzon létre egy pull kérést a result branch-ból.

Hibaelhárítás

Gyakori problémák

Hitelesítési hibák:

• Ellenőrizze, hogy a GH_TOKEN titkos kód vagy a változó helyesen van-e beállítva egy érvényes GitHub személyes hozzáférési jogkivonattal.
• Győződjön meg arról, hogy a jogkivonat rendelkezik a GitHub Copilot-hozzáféréshez szükséges hatókörökhöz.

A rendszer nem észlelt módosításokat:

• A modernizálási parancssori felület azt állapíthatja meg, hogy a megadott célhoz nincs szükség módosításokra.
• Az értékelés részleteiért tekintse át a feltöltött naplók összetevőt.

Feltöltési hibák (Azure Pipelines):

• Győződjön meg arról, hogy a buildszolgáltatás identitása rendelkezik ág létrehozási, hozzájárulási és olvasási engedélyekkel az adattárban.
• Részletes beállítási utasításokat a Git-parancsok futtatása szkriptben című témakörben talál.

A parancssori felület letöltési hibáinak modernizálása:

• Ellenőrizze, hogy a futó rendelkezik-e internet-hozzáféréssel.https://github.com
• Ellenőrizze, hogy van-e olyan proxy- vagy tűzfalkorlátozás, amely letilthatja a letöltést.

Következő lépések

• Tudnivalók a parancssori felület parancsairól
• Kötegelt értékelés futtatása
• Kötegelt frissítés futtatása
• Egyéni készségek létrehozása szervezetspecifikus mintákhoz