CI/CD-Real: Azure Pipelines

Auf dieser Seite erhalten Sie eine vollständige azure-pipelines.yml , die die CLI installiert, sich mit einer externen Anwendung authentifiziert, eine UiPath-Lösung verpackt und veröffentlicht, sie im Orchestrator bereitstellt und eine Test Manager-Suite für die Bereitstellung ausführt . Die Pipeline ist in sich geschlossenen: Kopieren Sie sie in den Stamm Ihres Repositorys, verknüpfen Sie zwei Geheimnisse und sie wird ausgeführt.

Für die zugrundeliegenden Prinzipien – Authentifizierung, Zwischenspeicherung, Vorinstallation des Tools, Versionsheft – siehe Anleitung: Bereitstellen von CI im Orchestrator. Diese Seite konzentriert sich auf die Azure Pipelines-Syntax.

Voraussetzungen

Bevor Sie die folgende YAML-Datei kopieren:

1. Erstellen Sie eine externe Anwendung in UiPath mit den OR.* Scopes, die Ihre Pipeline benötigt. Siehe Authentifizierung – Flow 2.
2. Speichern Sie die Geheimnisse in einer Azure DevOps- Variablengruppe:
   • Projekteinstellungen → Pipelines → Bibliothek → Neue Variablengruppe (z. B. uipath-prod).
   • Fügen Sie UIPATH_CLIENT_ID und UIPATH_CLIENT_SECRET hinzu – markieren Sie beide als Geheimnis (Vorhängen mit Schlosssymbol).
   • Fügen Sie optional UIPATH_TENANT (kein Geheimnis) hinzu.
3. Verknüpfen Sie die Variablengruppe mit der Pipeline (siehe variables -Block unten).
4. Bereitstellen eines Test Manager-Projekts und eines Testsatzes (wenn Sie die Testphase möchten). Sie benötigen TEST_SET_KEY (Format PROJECT:42) und PROJECT_KEY. Siehe Anleitung: Ausführen von Tests über die CLI.

azure-pipelines.yml

trigger:
  branches:
    include: [ main ]

pr:
  branches:
    include: [ main ]

variables:
- group: uipath-prod           # contains UIPATH_CLIENT_ID, UIPATH_CLIENT_SECRET
- name:  CLI_VERSION
  value: '1.0.0'
- name:  NODE_VERSION
  value: '20.x'
- name:  SOLUTION_NAME
  value: 'my-solution'
- name:  SOLUTION_DIR
  value: '$(Build.SourcesDirectory)/my-solution'
- name:  OUTPUT_DIR
  value: '$(Build.ArtifactStagingDirectory)'
- name:  SOLUTION_VERSION
  value: '1.2.0-ci.$(Build.BuildId)'

# Path where npm places globally-installed packages. Used to cache the CLI + tools.
- name:  NPM_GLOBAL_CACHE
  value: '$(HOME)/.npm-global/lib/node_modules'

stages:

- stage: Build
  displayName: 'Pack the Solution'
  jobs:
  - job: pack
    pool:
      vmImage: 'ubuntu-latest'
    steps:

    - task: NodeTool@0
      displayName: 'Use Node.js $(NODE_VERSION)'
      inputs:
        versionSpec: $(NODE_VERSION)

    - task: Cache@2
      displayName: 'Cache npm global (@uipath/cli)'
      inputs:
        key:  'uip | "$(Agent.OS)" | $(CLI_VERSION)'
        path: $(NPM_GLOBAL_CACHE)

    - script: |
        set -euo pipefail
        mkdir -p "$HOME/.npm-global"
        npm config set prefix "$HOME/.npm-global"
        export PATH="$HOME/.npm-global/bin:$PATH"
        echo "##vso[task.prependpath]$HOME/.npm-global/bin"

        if ! command -v uip >/dev/null; then
          npm install -g "@uipath/cli@$(CLI_VERSION)"
        fi

        uip --version
      displayName: 'Install UiPath CLI'

    - script: |
        set -euo pipefail
        uip solution pack "$(SOLUTION_DIR)" "$(OUTPUT_DIR)" \
          --name "$(SOLUTION_NAME)" \
          --version "$(SOLUTION_VERSION)"
      displayName: 'Pack Solution'

    - publish: '$(OUTPUT_DIR)'
      artifact: solution-zip
      displayName: 'Publish artifact'

- stage: Deploy
  displayName: 'Publish to feed and deploy to Orchestrator'
  dependsOn: Build
  jobs:
  - deployment: deploy
    environment: 'uipath-prod'      # Azure DevOps environment — gates / approvals live here
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:

          - task: NodeTool@0
            displayName: 'Use Node.js $(NODE_VERSION)'
            inputs:
              versionSpec: $(NODE_VERSION)

          - task: Cache@2
            displayName: 'Cache npm global (@uipath/cli)'
            inputs:
              key:  'uip | "$(Agent.OS)" | $(CLI_VERSION)'
              path: $(NPM_GLOBAL_CACHE)

          - script: |
              set -euo pipefail
              mkdir -p "$HOME/.npm-global"
              npm config set prefix "$HOME/.npm-global"
              export PATH="$HOME/.npm-global/bin:$PATH"
              echo "##vso[task.prependpath]$HOME/.npm-global/bin"

              if ! command -v uip >/dev/null; then
                npm install -g "@uipath/cli@$(CLI_VERSION)"
              fi
            displayName: 'Install UiPath CLI'

          - script: |
              set -euo pipefail
              uip login \
                --client-id env.UIPATH_CLIENT_ID \
                --client-secret env.UIPATH_CLIENT_SECRET \
                --tenant "$UIPATH_TENANT"
            displayName: 'Authenticate'
            env:
              UIPATH_CLIENT_ID:     $(UIPATH_CLIENT_ID)
              UIPATH_CLIENT_SECRET: $(UIPATH_CLIENT_SECRET)
              UIPATH_TENANT:        $(UIPATH_TENANT)

          - download: current
            artifact: solution-zip

          - script: |
              set -euo pipefail
              ARTIFACT=$(find "$(Pipeline.Workspace)/solution-zip" -maxdepth 1 -name "*.zip" | head -1)
              uip solution publish "$ARTIFACT"
            displayName: 'Publish to tenant feed'

          - script: |
              set -euo pipefail
              uip solution deploy run \
                --name "$(SOLUTION_NAME)-$(Build.BuildId)" \
                --package-name "$(SOLUTION_NAME)" \
                --package-version "$(SOLUTION_VERSION)" \
                --folder-name MySolution \
                --folder-path Shared
            displayName: 'Deploy to Orchestrator'

- stage: Test
  displayName: 'Run Test Manager suite'
  dependsOn: Deploy
  condition: and(succeeded(), ne(variables['TEST_SET_KEY'], ''))
  jobs:
  - job: test
    pool:
      vmImage: 'ubuntu-latest'
    steps:

    - task: NodeTool@0
      displayName: 'Use Node.js $(NODE_VERSION)'
      inputs:
        versionSpec: $(NODE_VERSION)

    - task: Cache@2
      displayName: 'Cache npm global (@uipath/cli)'
      inputs:
        key:  'uip | "$(Agent.OS)" | $(CLI_VERSION)'
        path: $(NPM_GLOBAL_CACHE)

    - script: |
        set -euo pipefail
        export PATH="$HOME/.npm-global/bin:$PATH"
        echo "##vso[task.prependpath]$HOME/.npm-global/bin"
        if ! command -v uip >/dev/null; then
          npm install -g "@uipath/cli@$(CLI_VERSION)"
        fi

        uip login \
          --client-id env.UIPATH_CLIENT_ID \
          --client-secret env.UIPATH_CLIENT_SECRET \
          --tenant "$UIPATH_TENANT"
      displayName: 'Install + authenticate'
      env:
        UIPATH_CLIENT_ID:     $(UIPATH_CLIENT_ID)
        UIPATH_CLIENT_SECRET: $(UIPATH_CLIENT_SECRET)
        UIPATH_TENANT:        $(UIPATH_TENANT)

    - script: |
        set -euo pipefail

        EXECUTION_ID=$(uip tm testsets run \
          --test-set-key "$TEST_SET_KEY" \
          --output-filter "Data.ExecutionId" \
          --output plain)

        echo "started execution $EXECUTION_ID"

        if ! uip tm wait \
          --execution-id "$EXECUTION_ID" \
          --project-key "$PROJECT_KEY" \
          --timeout 1800; then
          code=$?
          case "$code" in
            2) echo "##vso[task.logissue type=error]test run did not finish within 30 minutes"; exit 2 ;;
            *) echo "##vso[task.logissue type=error]wait failed (exit $code)"; exit "$code" ;;
          esac
        fi

        uip tm report get \
          --execution-id "$EXECUTION_ID" \
          --project-key "$PROJECT_KEY"

        FAILED=$(uip tm report get \
          --execution-id "$EXECUTION_ID" \
          --project-key "$PROJECT_KEY" \
          --output-filter "Data.Failed" \
          --output plain)

        if [ "$FAILED" -gt 0 ]; then
          echo "##vso[task.logissue type=error]$FAILED test case(s) failed"
          exit 1
        fi
      displayName: 'Launch, wait, verify'
      env:
        TEST_SET_KEY: $(TEST_SET_KEY)
        PROJECT_KEY:  $(PROJECT_KEY)

Exemplarische Vorgehensweise

Phase 1 – Erstellen

• NodeTool@0 heftet Node.js an Version 20 an. An Haupt anheften; Die CLI erfordert 18+.
• Cache@2 zwischenspeichert das globale npm-Verzeichnis node_modules . Der Cache-Schlüssel enthält $(CLI_VERSION) , sodass ein Versions-Upgrade sauber ungültig wird.
• Der Installationsschritt schaltet das globale Präfix von npm auf $HOME/.npm-global (kein sudo erforderlich), stellt es dem PATH voran und installiert @uipath/cli – nur wenn der Cache fehlte. Beim ersten Aufruf eines Toolbefehls (uip solution …, uip tm …) wird dieses Tool automatisch installiert, sodass kein explizites uip tools install erforderlich ist. Siehe Installieren von UiPath CLI – CI/CD und Skriptmuster – Anheften von Versionen.
• Der Packschritt ruft uip solution pack mit einem expliziten --version auf (verlassen Sie sich nie auf den 1.0.0 -Standard in CI).
• publish: ... lädt das gesamte $(OUTPUT_DIR) als Pipelineartefakt mit dem Namen solution-zip hoch, damit die Bereitstellungsphase es verbrauchen kann. Die Veröffentlichung des Verzeichnisses anstelle eines hartcodierten Dateinamens hält das Schema über Änderungen der CLI-Namenskonvention hinweg stabil.

Phase 2 – Bereitstellen

Verwendet einen Bereitstellungsauftrag, der an eine benannte Umgebung gebunden ist. In Umgebungen konfigurieren Sie Gates und Genehmigungen in Azure DevOps – das YAML selbst bleibt einfach.

• Installiert die CLI erneut (der Cache sollte in der zweiten Phase derselben Ausführung auftreten).
• uip login verwendet das Präfix env.VAR_NAME sowohl für die Client-ID als auch für das Geheimnis. Der env: -Block auf Schrittebene ordnet $(UIPATH_CLIENT_ID) (aus der Variablengruppe) der tatsächlichen Umgebungsvariablen UIPATH_CLIENT_ID zu, die das Flag auflöst. Übergeben Sie das Geheimnis nicht wörtlich in der Befehlszeile (--client-secret "$(UIPATH_CLIENT_SECRET)") – dadurch wird es in das Buildprotokoll und die ps -Ausgabe übertragen. Die Präfixfunktion env. ist in Authentifizierung – das Präfix env.VAR_NAME dokumentiert.
• download: current ruft das Artefakt solution-zip aus Phase 1 in $(Pipeline.Workspace)/solution-zip ab.
• uip solution publish lädt .zip in den Mandantenfeed hoch.
• uip solution deploy run erstellt die Bereitstellung. --name verwendet $(Build.BuildId) , sodass jede Ausführung identifizierbar ist und erneute Bereitstellungen den Bereitstellungsdatensatz des anderen nicht belasten.

Phase 3 – Test

Wird nur ausgeführt, wenn TEST_SET_KEY auf Variablengruppenebene festgelegt ist – der condition: -Guard überspringt die Phase sauber, wenn Sie keine Testsuite konfiguriert haben.

Der Shell-Block ist der kanonische Ablauf → Warten → Verifizieren von So: Ausführen von Tests über die CLI:

1. uip tm testsets run startet die Ausführung und gibt ExecutionId zurück.
2. uip tm wait blockiert, bis die Ausführung einen Endstatus erreicht ( 2 bedeutet Timeout, nicht Authentifizierungsfehler – eine domänenspezifische Wiederverwendung des Exit-Code-Slots).
3. uip tm report get liest Data.Failed; Der Schritt schlägt mit ##vso[task.logissue type=error] fehl, sodass das Ergebnis sauber in der Azure DevOps-Benutzeroberfläche angezeigt wird.

Häufige Varianten

Umgebungenübergreifend heraufstufen

Verknüpfen Sie zwei Variablengruppen – uipath-stage und uipath-prod – und machen Sie jede in einen separaten deployment: -Auftrag um. Verwenden Sie umgebungsspezifische Gates/Genehmigungen, um zu entscheiden, wann Prod ausgeführt wird:

- stage: DeployStage
  dependsOn: Build
  jobs:
  - deployment: deploy-stage
    variables: [ { group: uipath-stage } ]
    environment: 'uipath-stage'
    # …same steps as above, but with stage's tenant

- stage: DeployProd
  dependsOn: DeployStage
  jobs:
  - deployment: deploy-prod
    variables: [ { group: uipath-prod } ]
    environment: 'uipath-prod'    # attach a manual approval gate here
    # …same steps as above

Tiefere Abdeckung bei der Anleitung: Packen und Veröffentlichen einer Lösung – Bewerben eines Pakets für mehrere Mandanten.

Rollback

Azure DevOps wird nicht automatisch zurückgesetzt; fügen Sie eine manuelle Phase hinzu, die die vorherige Version erneut bereitstellt:

- stage: Rollback
  dependsOn: []                   # run on demand, not from Deploy
  jobs:
  - job: rollback
    pool: { vmImage: 'ubuntu-latest' }
    steps:
    # …install + auth…
    - script: |
        uip solution deploy run \
          --name "$(SOLUTION_NAME)-rollback" \
          --package-name "$(SOLUTION_NAME)" \
          --package-version "$(ROLLBACK_VERSION)" \
          --folder-name MySolution \
          --folder-path Shared
      displayName: 'Re-deploy previous version'

Übergeben Sie ROLLBACK_VERSION zur Warteschlangenzeit. Informationen zum destruktiven Rollback (Deinstallieren + Löschen des Artefakts) finden Sie unter Anleitung: Packen und Veröffentlichen einer Lösung – Rollback.

Tests werden übersprungen

Um ohne die Testphase auszuführen, löschen Sie den Phasenblock Test (oder lassen Sie TEST_SET_KEY unformatiert – der condition: auf der Phase wird ihn überspringen).

Häufige Fallstricke

• env. Präfix im Vergleich zu Literalgeheimnis. Immer --client-secret env.UIPATH_CLIENT_SECRET, nie --client-secret "$(UIPATH_CLIENT_SECRET)". Die Literalform eingebettet den Wert in die gerenderte Befehlszeile. Siehe Authentifizierungswarnung.
• ##vso[task.setvariable] ist für die Auflösung env. erforderlich – env: im Schritt macht die Variable direkt verfügbar.
• Eine mehrzeilige Bash benötigt set -euo pipefail oben in jedem script: -Block. Ohne diese kann pack fehlschlagen, während spätere Schritte weiterhin ausgeführt werden. Siehe Skriptmuster – Strikte Shell-Optionen.
• Cache-Tipps sind nicht garantiert. Umschließen Sie die Installationsbefehle immer in if ! command -v uip , damit die Pipeline sich selbst heilt, wenn der Cache leer ist.

Siehe auch

• Anleitung: Bereitstellen von CI – plattformagnostische Anleitung für Orchestrator .
• So: Packen und Veröffentlichen einer Lösung – Versionierung und Rollback.
• So: Ausführen von Tests über die CLI – Starten → Warten → Verifizieren des Musters im Detail.
• CI/CD-Real: GitHub Actions, Jenkins, GitLab CI – die gleiche Pipeline in anderen Plattformen.