Formule CI/CD: GitHub Actions

Cette page vous fournit une .github/workflows/deploy.yml complète qui installe la CLI, s'authentifie avec une application externe, compresse et publie une solution UiPath, la déploie dans Orchestrator et exécute une suite Test Manager dans le cadre du déploiement. Placez-le dans votre référentiel, ajoutez deux clés secrètes et il s’exécute.

Pour les principes sous-jacents — authentification, mise en cache, préinstallation d'outils, épinglage de version — voir Comment: déployer dans Orchestrator depuis CI. Cette page se concentre sur la syntaxe des actions GitHub.

Prérequis

Avant de copier le YAML ci-dessous:

1. Créez une application externe dans UiPath avec les étendues OR.* dont votre pipeline a besoin. Voir Authentification — Flux 2.
2. Stockez les secrets dans les paramètres du référentiel (ou de l’organisation/de l’environnement):
   • Paramètres → Clés secrètes et variables → Actions → Nouvelle clé secrète du référentiel.
   • Ajoutez UIPATH_CLIENT_ID et UIPATH_CLIENT_SECRET comme clés secrètes.
   • Ajoutez UIPATH_TENANT en tant que variable (pas un secret — elle n'est pas sensible).
3. Enregistrez un projet et un ensemble de tests Test Manager si vous souhaitez la tâche de test. Indiquez TEST_SET_KEY (par ex. PROJECT:42) et PROJECT_KEY dans les variables du référentiel. Consultez Comment procéder: exécuter des tests à partir de la 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

Présentation

Créer une tâche

• actions/setup-node@v4 épingle le nœud à la version majeure spécifiée par NODE_VERSION. La CLI nécessite le nœud 18+.
• actions/cache@v4 met en cache le répertoire npm global node_modules , selon la version CLI épinglée et le système d'exploitation exécuteur. Lorsque le cache est atteint, la garde-fou if ! command -v uip de l'étape d'installation se transforme en optimisée.
• L'étape d'installation configure un préfixe npm pour l'utilisateur local (aucun sudo nécessaire sur les exécuteurs hébergés par GitHub), l'ajoute à GITHUB_PATH pour que les étapes ultérieures voient la commande uip , et installe la CLI. La première invocation d'une commande d'outil (uip solution …, uip tm …) installe automatiquement cet outil - aucun uip tools install explicite n'est nécessaire. Voir Installation de UiPath CLI — CI/CD.
• L'étape de compression invoque uip solution pack avec un --version explicite construit à partir de github.run_number (mononyme, unique par exécution dans le référentiel). L'étape capture le chemin .zip produit avec find plutôt que de coder en dur le nom du fichier - maintient la formule stable même en cas de modification de la convention d'affectation de noms CLI.
• actions/upload-artifact@v4 télécharge le fichier .zip capturé afin que la tâche deploy puisse le télécharger lors de la prochaine exécution.
• outputs.solution_version propage la version calculée à la tâche deploy , le moyen le plus simple de partager une valeur entre les tâches d'un même workflow.

Déployer la tâche

• Réinstalle la CLI — needs: build force l'ordre des tâches, mais chaque tâche s'exécute sur un nouveau passeur. Le cache doit atteindre lors de la deuxième installation.
• actions/download-artifact@v4 extrait le solution-zip dans $OUTPUT_DIR.
• L’étape d’authentification transmet les secrets via le bloc env: de l’étape, puis uip login les lit via le préfixe env. . Le préfixe env.VAR_NAME est le moyen pris en charge pour maintenir un secret en dehors de la ligne de commande — voir Authentification — le préfixe env.VAR_NAME. N'écrivez pas --client-secret "${{ secrets.UIPATH_CLIENT_SECRET }}" — qui intègre la valeur dans la commande rendue et dans le journal de l'étape.
• Les étapes de publication + de déploiement utilisent uip solution publish et uip solution deploy run. --name utilise github.run_number pour que chaque déploiement soit identifiable.
• environment: uipath-prod lie la tâche à un environnement de déploiement. Les environnements sont l'endroit où vous configurez les réviseurs requis, les minuteurs d'attente et les branches de déploiement. Conservez-les dans l'interface utilisateur et laissez le déclaratif YAML.

Tâche de test

S’exécute uniquement si la variable de référentiel TEST_SET_KEY est définie, — la garde if: l’ignore dans le cas contraire. Le bloc shell est le lancement canonique → attendre → vérifier le modèle de Comment faire: exécuter des tests à partir de la CLI:

1. uip tm testsets run se lance et renvoie une ExecutionId.
2. uip tm wait blocs jusqu'à l'état terminal. La sortie 2 implique un délai d'expiration le wait (pas d'échec d'authentification); est signalé via ::error:: afin qu’il apparaisse dans l’interface utilisateur des Actions.
3. uip tm report get lit Data.Failed et l'étape quitte 1 en cas d'échec.

Variations courantes

Promouvoir dans tous les environnements

Ajoutez une deuxième tâche deploy qui dépend de la première, avec des clés secrètes différentes:

  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.

Les passerelles d'approbation se trouvent dans les paramètres de l'environnement — la chaîne needs: applique l'ordre. Voir Comment procéder: compresser et publier une solution — promouvoir un package entre les locataires.

Restaurer (Rollback)

Ajoutez une entrée workflow_dispatch et une tâche protégée qui déploie à nouveau une version spécifique:

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

Déclencheur avec Actions → Déployer la solution UiPath → Exécuter le workflow et saisir la version de restauration. Pour une restauration irréversible (désinstallation + solution packages delete), consultez la section Comment procéder: compresser et publier une solution — restauration.

Ignorer les tests

Définissez (ou laissez vide) la variable TEST_SET_KEY du référentiel. Le garde-fou if: ${{ vars.TEST_SET_KEY != '' }} ignore toute la tâche.

Erreurs courantes

• ${{ secrets.X }} intervalle. Il se remplace au niveau de la couche de rendu des étapes. Si vous placez une clé secrète directement dans une ligne de commande run: , la valeur fera partie du script rendu et du journal des étapes, à moins que GitHub ne la masque. Acheminez toujours les secrets via env: et les lisez avec env.VAR_NAME à l'intérieur uip.
• $GITHUB_PATH par rapport à $PATH. L'exportation PATH=… dans une étape ne se reporte pas à la suivante. Utilisez echo "…" >> "$GITHUB_PATH" pour conserver une addition PATH entre les étapes sur le même chemin d'accès.
• strict shell options. Commencez chaque run: multiligne par set -euo pipefail — sans cela, un uip solution pack échoué peut être suivi d'une publication « réussie» d'un artefact obsolète. Voir Modèles de script — Options shell strictes.
• Mettez en cache les faux positifs. Si vous insérez CLI_VERSION mais que la clé de cache ne l’inclut pas, vous continuerez à utiliser l’ancienne CLI. La clé de ce YAML inclut ${{ env.CLI_VERSION }} exactement pour cette raison.
• Le chemin du cache est couplé au préfixe npm. Le bloc de cache utilise ~/.npm-global/lib/node_modules, ce qui ne fonctionne que car l'étape d'installation exécute npm config set prefix "$HOME/.npm-global". Si vous modifiez le préfixe (par exemple sur un exécuteur Windows auto-hébergé où la convention est %APPDATA%\npm\node_modules), le cache path: et la ligne npm config set prefix doivent être déplacés ensemble. Sur un exécuteur non ubuntu-latest, videz d'abord le chemin réel avec - run: npm root -g et mettez en miroir tout ce qu'il rapporte.

Voir également

• Procédures: déployer dans Orchestrator à partir de CI — directives indépendantes de la plateforme.
• Procédures: compresser et publier une solution — contrôle de version et restauration.
• Comment procéder: exécuter des tests à partir de la CLI — lancer → attendre → vérifier le modèle.
• Formule CI/CD: Azure Pipelines, Jenkins, GitLab CI — le même pipeline dans les autres plates-formes.