CI/CD-integratie met Modernize CLI

Integreer de MODERNize CLI in uw CI/CD-pijplijnen om de modernisering van toepassingen op schaal te automatiseren. In dit artikel leest u hoe u gitHub Actions en Azure Pipelines configureert om de CLI te moderniseren volgens een planning of op aanvraag.

Door het uitvoeren van de Modernize CLI in een CI/CD-pijplijn kunt u:

• Automatiseer upgrades volgens een terugkerend schema zonder handmatige tussenkomst.
• Moderniseringswerkstromen in uw organisatie standaardiseren.
• Houd wijzigingen bij via specifieke vertakkingen en build-artefacten.
• Bekijk de resultaten via pull-aanvragen, bouwoverzichten en logboeken.

De voorbeeldpijplijnen in dit artikel voeren de volgende stappen uit:

1. Download en installeer de nieuwste Modernize CLI.
2. Uitvoeren modernize upgrade met een configureerbaar doel (bijvoorbeeld Java 21).
3. Voer eventuele resulterende wijzigingen door en push deze naar een speciale tak.
4. Publiceer een resultatenoverzicht en upload CLI-logboeken als buildartefacten.

Vereiste voorwaarden

GitHub Actions

• Een GitHub Copilot-abonnement: Gratis, Pro, Pro+, Business of Enterprise-abonnement. Zie Copilot-plannen.
• Een GitHub Personal Access Token (PAT): Maak een token en sla het op als een opslagplaatsgeheim met de naam GH_TOKEN. Zie Uw persoonlijke toegangstokens beheren.

Azure-pijplijnen

• Een GitHub Copilot-abonnement: Gratis, Pro, Pro+, Business of Enterprise-abonnement. Zie Copilot-plannen.
• Machtigingen voor het maken van Azure Pipelines: Zie Over machtigingen en beveiligingsgroepen.
• Machtigingen voor buildservice: de identiteit van de buildservice van de pijplijn heeft machtigingen nodig om naar de repository te schrijven. Zie Git-opdrachten uitvoeren in een script.
  • Ga naarOpslagplaatsen voor >.
  • Selecteer de doelopslagplaats en selecteer vervolgens het tabblad Beveiliging .
  • Zoek naar de buildservice-identiteit (bijvoorbeeld Project Collection Build Service (<Organization>)).
  • Stel de volgende machtigingen in op Toestaan:
    • Vertakking maken
    • Bijdragen
    • Lezen
• Een GitHub Personal Access Token (PAT): maak een token en sla het op als een pijplijnvariabele met de naam GH_TOKEN. Zie Uw persoonlijke toegangstokens beheren en Variabelen definiëren.

De pijplijn configureren

GitHub Actions

Maak een werkstroombestand .github/workflows/modernize.yml in uw opslagplaats met de volgende inhoud:

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-pijplijnen

1. Maak bijvoorbeeld een YAML-pijplijnbestand, zoals azure-pipelines-modernize.yml, in uw repository met de volgende inhoud.

   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. Maak een Azure-pijplijn die verwijst naar dit YAML-bestand. Zie Uw eerste pijplijn maken voor meer informatie.

Werkstroomdetails

GitHub Actions

De werkstroom bevat twee triggers:

• Handmatig verzenden (workflow_dispatch): Voer de werkstroom op aanvraag uit vanaf het tabblad Acties . Geef desgewenst een upgradedoel op, zoals Java 21.
• Gepland (schedule): wordt dagelijks om 2:00 uur UTC automatisch uitgevoerd. Pas de cron-expressie aan zodat deze overeenkomt met uw voorkeursschema.

Elke uitvoering voert de volgende stappen uit:

1. Controleert de code van de opslagplaats.
2. Downloadt en installeert de nieuwste Modernize CLI.
3. Voer modernize upgrade uit met het opgegeven target of standaard naar latest.
4. Voert eventuele wijzigingen door en pusht deze naar een branch met tijdstempel.
5. Schrijft een samenvatting met branch- en PR-koppelingen naar het overzicht van de GitHub Actions-stap.
6. Hiermee uploadt u Modernize CLI-logboeken als een bouwartefact voor probleemoplossing.

Opmerking

De werkstroom wordt opnieuw ingesteld voordat deze wordt doorgevoerd .github/workflows om te voorkomen dat het werkstroombestand zelf per ongeluk wordt gewijzigd.

Azure-pijplijnen

De pijplijn bevat twee triggers:

• Handmatig uitvoeren: voer de pijplijn op aanvraag uit vanuit Azure DevOps. Geef een upgradedoelparameter op, zoals Java 21.
• Gepland (schedules): wordt dagelijks om 2:00 uur UTC automatisch uitgevoerd op de main tak. Pas de cron-expressie aan zodat deze overeenkomt met uw voorkeursschema.

Elke uitvoering voert de volgende stappen uit:

1. Controleert de repository met opgeslagen inloggegevens om wijzigingen te pushen.
2. Downloadt en installeert de nieuwste Modernize CLI.
3. Voer modernize upgrade uit met het opgegeven target of standaard naar latest.
4. Commiteert eventuele wijzigingen en pusht deze naar een resultaatvertakking met de build-id.
5. Hiermee publiceert u een overzichts markdown-bestand als buildartefact.
6. Hiermee uploadt u Modernize CLI-logboeken als een bouwartefact voor probleemoplossing.

De pijplijn uitvoeren

GitHub Actions

De werkstroom handmatig activeren:

1. Ga naar uw opslagplaats op GitHub.
2. Selecteer het tabblad Acties.
3. Selecteer Modernization CLI in de lijst met werkstromen.
4. Selecteer Werkstroom uitvoeren.
5. Voer desgewenst een upgradedoel in en selecteer vervolgens Werkstroom uitvoeren om te bevestigen.

Nadat de werkstroom is voltooid, bekijkt u de samenvatting van de stap voor koppelingen naar de resultatenbranch en maakt u een pull-aanvraag om de wijzigingen samen te voegen.

Azure-pijplijnen

De pijplijn handmatig activeren:

1. Ga naar uw Azure DevOps-project.
2. Selecteer Pijplijnen in het linkernavigatievenster.
3. Selecteer de CLI-pijplijn voor modernisering .
4. Selecteer Pijplijn uitvoeren.
5. Werk desgewenst de upgradedoelparameter bij en selecteer Vervolgens Uitvoeren.

Nadat de pijplijn is voltooid, controleert u de gepubliceerde artefacten voor de samenvatting en logboeken. Maak vervolgens een pull-aanvraag vanuit de resultaatbranch.

Troubleshooting

Veelvoorkomende problemen

Verificatiefouten:

• Controleer of het geheim of de GH_TOKEN variabele juist is ingesteld met een geldig persoonlijk GitHub-toegangstoken.
• Zorg ervoor dat het token de vereiste scopes heeft voor toegang tot GitHub Copilot.

Er zijn geen wijzigingen gedetecteerd:

• De CLI moderniseren kan bepalen dat er geen wijzigingen nodig zijn voor het opgegeven doel.
• Bekijk het geüploade logboekartefact voor meer informatie over de evaluatie.

Pushfouten (Azure Pipelines):

• Controleer of de buildservice-identiteit de machtigingen Create Branch, Contribute en Read heeft voor de opslagplaats.
• Zie Git-opdrachten uitvoeren in een script voor gedetailleerde installatie-instructies.

Downloadfouten van CLI moderniseren:

• Controleer of de runner internettoegang heeft tot https://github.com.
• Controleer op proxy- of firewallbeperkingen die het downloaden mogelijk blokkeren.

Volgende stappen 

• Meer informatie over CLI-opdrachten
• Batch-evaluatie uitvoeren
• Batchupgrade uitvoeren
• Aangepaste vaardigheden maken voor organisatiespecifieke patronen