CI/CD-Real: GitHub Actions

Auf dieser Seite erhalten Sie eine vollständige .github/workflows/deploy.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 . Legen Sie es in Ihrem Repository ab, fügen Sie zwei Geheimnisse hinzu und es 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 GitHub-Aktionssyntax.

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 im Repository (oder in den Einstellungen der Organisation/Umgebung):
   • Einstellungen → Geheimnisse und Variablen → Aktionen → Neues Repository-Geheimnis.
   • Fügen Sie UIPATH_CLIENT_ID und UIPATH_CLIENT_SECRET als Geheimnisse hinzu.
   • Fügen Sie UIPATH_TENANT als Variable hinzu (kein Geheimnis – es ist nicht vertraulich).
3. Stellen Sie ein Test Manager-Projekt und einen Testsatz bereit, wenn Sie den Testauftrag möchten. Geben Sie TEST_SET_KEY (z. B PROJECT:42) und PROJECT_KEY in den Repository-Variablen. Siehe Anleitung: Ausführen von Tests über die CLI.

.github/workflows/deploy.yml

name: Deploy UiPath Solution

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  workflow_dispatch:

env:
  CLI_VERSION:      '1.0.0'
  NODE_VERSION:     '20'
  SOLUTION_NAME:    'my-solution'
  SOLUTION_DIR:     './my-solution'
  OUTPUT_DIR:       './dist'

jobs:

  build:
    name: Pack Solution
    runs-on: ubuntu-latest
    outputs:
      solution_version: ${{ steps.version.outputs.version }}
    steps:

      - uses: actions/checkout@v4

      - name: Compute version
        id: version
        run: echo "version=1.2.0-ci.${{ github.run_number }}" >> "$GITHUB_OUTPUT"

      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: Cache npm global (@uipath/cli)
        uses: actions/cache@v4
        with:
          path: ~/.npm-global/lib/node_modules
          key:  uip-${{ env.CLI_VERSION }}-${{ runner.os }}

      - name: Install UiPath CLI
        shell: bash
        run: |
          set -euo pipefail
          mkdir -p "$HOME/.npm-global"
          npm config set prefix "$HOME/.npm-global"
          echo "$HOME/.npm-global/bin" >> "$GITHUB_PATH"
          export PATH="$HOME/.npm-global/bin:$PATH"

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

      - name: Pack Solution
        id: pack
        shell: bash
        run: |
          set -euo pipefail
          mkdir -p "$OUTPUT_DIR"
          uip solution pack "$SOLUTION_DIR" "$OUTPUT_DIR" \
            --name "$SOLUTION_NAME" \
            --version "${{ steps.version.outputs.version }}"
          ARTIFACT=$(find "$OUTPUT_DIR" -maxdepth 1 -name "*.zip" | head -1)
          echo "artifact=$ARTIFACT" >> "$GITHUB_OUTPUT"

      - uses: actions/upload-artifact@v4
        with:
          name: solution-zip
          path: ${{ steps.pack.outputs.artifact }}

  deploy:
    name: Publish and deploy
    needs: build
    runs-on: ubuntu-latest
    environment: uipath-prod   # attach approval gates here if needed
    steps:

      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: Cache npm global (@uipath/cli)
        uses: actions/cache@v4
        with:
          path: ~/.npm-global/lib/node_modules
          key:  uip-${{ env.CLI_VERSION }}-${{ runner.os }}

      - name: Install UiPath CLI
        shell: bash
        run: |
          set -euo pipefail
          mkdir -p "$HOME/.npm-global"
          npm config set prefix "$HOME/.npm-global"
          echo "$HOME/.npm-global/bin" >> "$GITHUB_PATH"
          export PATH="$HOME/.npm-global/bin:$PATH"

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

      - uses: actions/download-artifact@v4
        with:
          name: solution-zip
          path: ${{ env.OUTPUT_DIR }}

      - name: Authenticate
        shell: bash
        env:
          UIPATH_CLIENT_ID:     ${{ secrets.UIPATH_CLIENT_ID }}
          UIPATH_CLIENT_SECRET: ${{ secrets.UIPATH_CLIENT_SECRET }}
          UIPATH_TENANT:        ${{ vars.UIPATH_TENANT }}
        run: |
          set -euo pipefail
          uip login \
            --client-id env.UIPATH_CLIENT_ID \
            --client-secret env.UIPATH_CLIENT_SECRET \
            --tenant "$UIPATH_TENANT"

      - name: Publish to tenant feed
        shell: bash
        run: |
          set -euo pipefail
          ARTIFACT=$(find "$OUTPUT_DIR" -maxdepth 1 -name "*.zip" | head -1)
          uip solution publish "$ARTIFACT"

      - name: Deploy to Orchestrator
        shell: bash
        run: |
          set -euo pipefail
          uip solution deploy run \
            --name "${SOLUTION_NAME}-${{ github.run_number }}" \
            --package-name "$SOLUTION_NAME" \
            --package-version "${{ needs.build.outputs.solution_version }}" \
            --folder-name MySolution \
            --folder-path Shared

  test:
    name: Run Test Manager suite
    needs: deploy
    if: ${{ vars.TEST_SET_KEY != '' }}
    runs-on: ubuntu-latest
    steps:

      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: Cache npm global (@uipath/cli)
        uses: actions/cache@v4
        with:
          path: ~/.npm-global/lib/node_modules
          key:  uip-${{ env.CLI_VERSION }}-${{ runner.os }}

      - name: Install CLI and authenticate
        shell: bash
        env:
          UIPATH_CLIENT_ID:     ${{ secrets.UIPATH_CLIENT_ID }}
          UIPATH_CLIENT_SECRET: ${{ secrets.UIPATH_CLIENT_SECRET }}
          UIPATH_TENANT:        ${{ vars.UIPATH_TENANT }}
        run: |
          set -euo pipefail
          mkdir -p "$HOME/.npm-global"
          npm config set prefix "$HOME/.npm-global"
          echo "$HOME/.npm-global/bin" >> "$GITHUB_PATH"
          export PATH="$HOME/.npm-global/bin:$PATH"

          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"

      - name: Launch, wait, verify
        shell: bash
        env:
          TEST_SET_KEY: ${{ vars.TEST_SET_KEY }}
          PROJECT_KEY:  ${{ vars.PROJECT_KEY }}
        run: |
          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 "::error::test run did not finish within 30 minutes"; exit 2 ;;
              *) echo "::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 "::error::$FAILED test case(s) failed"
            exit 1
          fi

Exemplarische Vorgehensweise

Auftrag erstellen

• actions/setup-node@v4 heftet Knoten an die durch NODE_VERSION angegebene Hauptversion an. Die CLI erfordert Knoten 18+.
• actions/cache@v4 speichert das globale npm-Verzeichnis node_modules , das auf der angehefteten CLI-Version und dem Ausführungsbetriebssystem gespeichert ist. Wenn der Cache ankommt, wird der if ! command -v uip -Guard des Installationsschritts zu einem No-Op.
• Der Installationsschritt konfiguriert ein benutzerlokales npm-Präfix (kein sudo für von GitHub gehostete Runtimes erforderlich), fügt es zu GITHUB_PATH hinzu, damit spätere Schritte den Befehl uip sehen, und installiert die CLI. Beim ersten Aufruf eines Toolbefehls (uip solution …, uip tm …) wird dieses Tool automatisch installiert – es ist kein explizites uip tools install erforderlich. Siehe Installieren von UiPath CLI – CI/CD.
• Der Paketschritt ruft uip solution pack mit einem expliziten --version auf, der aus github.run_number erstellt wurde (monoton, eindeutig pro Ausführung im Repository). Der Schritt erfasst den erzeugten .zip -Pfad mit find , anstatt den Dateinamen hartcodiert zu haben – bleibt das Schema über Änderungen der CLI-Namenskonvention hinweg stabil.
• actions/upload-artifact@v4 lädt das erfasste .zip hoch, sodass der Auftrag deploy es in der nächsten Ausführung herunterladen kann.
• outputs.solution_version überträgt die berechnete Version an den deploy -Auftrag – die einfachste Möglichkeit, einen Wert zwischen Aufträgen im selben Workflow zu teilen.

Auftrag bereitstellen

• Installiert die CLI neu – needs: build erzwingt die Auftragsreihenfolge, aber jeder Auftrag wird mit einem neuen Ausführungsprogramm ausgeführt. Der Cache sollte bei der zweiten Installation funktionieren.
• actions/download-artifact@v4 ziehen die solution-zip in $OUTPUT_DIR.
• Der Authentifizierungsschritt übergibt Geheimnisse über den env: -Block des Schritts, dann liest uip login sie durch das Präfix env. . Das Präfix env.VAR_NAME ist die unterstützte Methode, um ein Geheimnis außerhalb der Befehlszeile zu halten – siehe Authentifizierung – das Präfix env.VAR_NAME. Schreiben Sie nicht --client-secret "${{ secrets.UIPATH_CLIENT_SECRET }}" – wodurch der Wert in den gerenderten Befehl und in das Schrittprotokoll eingebettet wird.
• Die Schritte für Veröffentlichen und Bereitstellen verwenden uip solution publish und uip solution deploy run. --name verwendet github.run_number , sodass jede Bereitstellung identifizierbar ist.
• environment: uipath-prod verknüpft den Auftrag mit einer Bereitstellungsumgebung. In Umgebungen konfigurieren Sie erforderliche Prüfer, Wartezeit-Timer und Bereitstellungszweige – behalten Sie die Benutzeroberfläche bei und lassen Sie das YAML-Deklarativ.

Testauftrag

Wird nur ausgeführt, wenn die Repository-Variable TEST_SET_KEY festgelegt ist – andernfalls überspringt sie der Guard if: . Der Shell-Block ist das kanonische Muster für den Start → warten → überprüfen von So: Ausführen von Tests über die CLI:

1. uip tm testsets run startet und gibt ein ExecutionId zurück.
2. uip tm wait Blöcke bis zum Endstatus. Das Beenden 2 bedeutet Zeitüberschreitung bei wait (kein Authentifizierungsfehler); Der Exitcode wird über ::error:: gemeldet, sodass er in der Actions-UI angezeigt wird.
3. uip tm report get liest Data.Failed und der Schritt beendet 1 wenn ein Fehler aufgetreten ist.

Häufige Varianten

Umgebungenübergreifend heraufstufen

Fügen Sie einen zweiten deploy -Auftrag hinzu, der vom ersten mit unterschiedlichen Geheimnissen abhängt:

  deploy-stage:
    needs: build
    environment: uipath-stage
    # …same steps as `deploy`, using ${{ secrets.UIPATH_STAGE_CLIENT_ID }} etc.

  deploy-prod:
    needs: deploy-stage
    environment: uipath-prod    # add "Required reviewers" in the environment settings
    # …same steps as `deploy`, using ${{ secrets.UIPATH_PROD_CLIENT_ID }} etc.

Genehmigungsgates live in den Umgebungseinstellungen – die needs: -Kette erzwingt die Reihenfolge. Siehe Anleitung: Packen und Veröffentlichen einer Lösung – Bewerben eines Pakets für Mandanten.

Rollback

Fügen Sie eine workflow_dispatch -Eingabe und einen beaufsichtigten Auftrag hinzu, der eine bestimmte Version erneut bereitstellt:

on:
  workflow_dispatch:
    inputs:
      rollback_version:
        description: 'Version to roll back to (e.g. 1.1.9)'
        required: false
        type: string

jobs:
  rollback:
    if: ${{ github.event.inputs.rollback_version != '' }}
    runs-on: ubuntu-latest
    # …install + auth…
    steps:
      - name: Re-deploy previous version
        run: |
          uip solution deploy run \
            --name "${SOLUTION_NAME}-rollback" \
            --package-name "$SOLUTION_NAME" \
            --package-version "${{ github.event.inputs.rollback_version }}" \
            --folder-name MySolution \
            --folder-path Shared

Trigger mit Aktionen → UiPath-Lösung bereitstellen → Workflow ausführen und geben Sie die Rollback-Version ein. Informationen zum destruktiven Rollback (Deinstallieren + solution packages delete) finden Sie unter Anleitung: Packen und Veröffentlichen einer Lösung – Rollback.

Überspringen Sie Tests

Legen Sie die Repo-Variable TEST_SET_KEY fest (oder lassen Sie sie unfest). Die Guardrail if: ${{ vars.TEST_SET_KEY != '' }} überspringt den gesamten Auftrag.

Häufige Fallstricke

• ${{ secrets.X }} Interpolation. Es ersetzt auf der Schritt-Rendering-Ebene. Wenn Sie ein Geheimnis direkt in eine run: -Befehlszeile einfügen, wird der Wert Teil des gerenderten Skripts – und des Schrittprotokolls, es sei denn, GitHub maskiert es. Leiten Sie Geheimnisse immer über env: weiter und lesen Sie sie mit env.VAR_NAME in uip.
• $GITHUB_PATH im Vergleich zu $PATH. Das Exportieren PATH=… in einem Schritt wird nicht in den nächsten übertragen. Verwenden Sie echo "…" >> "$GITHUB_PATH" , um eine PATH-Ergänzung über mehrere Schritte im selben Ausführungsprogramm hinweg beizubehalten.
• strict shell options. Beginnen Sie jede mehrzeilige run: mit set -euo pipefail – ohne das kann auf ein fehlgeschlagenes uip solution pack eine „erfolgreiche“ Veröffentlichung eines veralteten Artefakts folgen. Siehe Skriptmuster – Strikte Shell-Optionen.
• Falsch-Positive zwischenspeichern. Wenn Sie CLI_VERSION ausführen, der Cache-Schlüssel ihn jedoch nicht enthält, verwenden Sie weiterhin die alte CLI. Der Schlüssel in diesem YAML enthält genau aus diesem Grund ${{ env.CLI_VERSION }} .
• Der Cache-Pfad ist mit dem npm-Präfix verbunden. Der Cacheblock verwendet ~/.npm-global/lib/node_modules, was nur funktioniert, weil der Installationsschritt npm config set prefix "$HOME/.npm-global" ausgeführt wird. Wenn Sie das Präfix ändern (z. B. auf einem selbst gehosteten Windows-Ausführungsprogramm, bei dem die Konvention %APPDATA%\npm\node_modules ist), müssen sowohl die Cache-Zeile path: als auch die Zeile npm config set prefix zusammen verschoben werden. Geben Sie bei einem Ausführungsvorgang, der nicht-Ubuntu-latest ist, zuerst den echten Pfad mit - run: npm root -g ein und spiegeln Sie alles wider, was er meldet.

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 – das Muster Starten → Warten → Verifizieren.
• CI/CD-Real: Azure Pipelines, Jenkins, GitLab CI – die gleiche Pipeline auf anderen Plattformen.