Schéma CI/CD: Azure Pipelines

Cette page vous fournit une azure-pipelines.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. Le pipeline est autonome: copiez-le à la racine de votre référentiel, reliez-le à 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 pipelines Azure.

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 clés secrètes dans un groupe de variables Azure DevOps:
   • Paramètres du projet → Pipelines → Bibliothèque → Nouveau groupe de variables (par exemple, uipath-prod).
   • Ajoutez UIPATH_CLIENT_ID et UIPATH_CLIENT_SECRET — marquez les deux comme secret (icône de cadenas).
   • Ajoutez éventuellement UIPATH_TENANT (pas un secret).
3. Liez le groupe de variables au pipeline (voir le bloc variables ci-dessous).
4. Enregistrez un projet et un ensemble de tests Test Manager (si vous souhaitez l'étape de test). Vous aurez besoin de TEST_SET_KEY (format PROJECT:42) et PROJECT_KEY. Consultez Comment procéder: exécuter des tests à partir de la 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)

Présentation

Étape 1 - Construire

• NodeTool@0 épingle Node.js à la version 20. Épingler à un principal; la CLI nécessite 18 versions ou plus.
• Cache@2 met en cache le répertoire node_modules global npm. La clé de cache inclut $(CLI_VERSION) pour qu’une bogue de version s’invalide correctement.
• L'étape d'installation fait basculer le préfixe global de npm sur $HOME/.npm-global (aucun sudo nécessaire), l'ajoute au PATH et, — uniquement si le cache est manquant, installe @uipath/cli. La première invocation d'une commande d'outil (uip solution …, uip tm …) installe automatiquement cet outil, donc aucun uip tools install explicite n'est nécessaire. Voir Installation de la UiPath CLI — CI/CD et Modèles de script — versions épinglées.
• L'étape de compression invoque uip solution pack avec une --version explicite (ne vous fondez jamais sur la valeur 1.0.0 par défaut dans CI).
• publish: ... télécharge l'intégralité de $(OUTPUT_DIR) sous forme d'artefact de pipeline nommé solution-zip afin que l'étape de déploiement puisse l'utiliser. La publication du répertoire plutôt qu’un nom de fichier codé en dur maintient la formule stable en fonction des modifications de convention d’affectation de noms CLI.

Étape 2 - Déployer

Utilise une tâche de déploiement liée à un environnement nommé. Les environnements sont l'endroit où vous configurez les passerelles et les approbations dans Azure DevOps — l'YAML reste simple.

• Réinstalle la CLI (le cache doit atteindre la deuxième étape de la même exécution).
• uip login utilise le préfixe env.VAR_NAME pour l’ID client et la clé secrète. Le bloc env: au niveau de l'étape mappe $(UIPATH_CLIENT_ID) (du groupe de variables) à la variable d'environnement réelle UIPATH_CLIENT_ID que l'indicateur résout. Ne transmettez pas le secret littéralement sur la ligne de commande (--client-secret "$(UIPATH_CLIENT_SECRET)") - qui le introduit dans le journal de build et la sortie ps . La fonctionnalité de préfixe env. est documentée dans Authentification — le préfixe env.VAR_NAME.
• download: current extrait l'artefact solution-zip de l'étape 1 dans $(Pipeline.Workspace)/solution-zip.
• uip solution publish charge le fichier .zip dans le flux de locataire.
• uip solution deploy run crée le déploiement. --name utilise $(Build.BuildId) de sorte que chaque exécution soit identifiable et que les redéploiements ne se bloquent pas sur l'enregistrement de déploiement des autres.

Étape 3 — Test

S'exécute uniquement si TEST_SET_KEY est défini au niveau du groupe de variables - le garde-fou condition: ignore l'étape proprement si vous n'avez pas configuré de suite de tests.

Le bloc shell est le lancement canonique → attendre → vérifier le flux de Comment faire: exécuter des tests à partir de la CLI:

1. uip tm testsets run lance l'exécution et renvoie une ExecutionId.
2. uip tm wait bloque jusqu'à ce que l'exécution atteigne un état terminal (la sortie 2 signifie un délai d'expiration, et non un échec d'authentification — une réutilisation spécifique au domaine de l'emplacement du code de sortie).
3. uip tm report get lit Data.Failed; l'étape échoue avec ##vso[task.logissue type=error] de sorte que le résultat s'affiche proprement dans l'interface utilisateur d'Azure DevOps.

Variations courantes

Promouvoir dans tous les environnements

Liez deux groupes de variables — uipath-stage et uipath-prod — et transformez chacun en une tâche deployment: distincte. Utilisez des passerelles/approbations spécifiques à l'environnement pour décider quand exécuter la production:

- 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

Couverture plus approfondie dans Comment procéder: compresser et publier une solution — promouvoir un package entre les locataires.

Restaurer (Rollback)

Azure DevOps n'est pas restauré automatiquement; ajoutez une étape manuelle qui déploie à nouveau la version précédente:

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

Transmettez ROLLBACK_VERSION au moment de la file d'attente. Pour une restauration irréversible (désinstallation + suppression d'artefact), consultez la section Comment procéder: compresser et publier une solution — restauration.

Ignorer les tests

Pour exécuter sans l’étape de test, supprimez le bloc d’étape Test (ou laissez TEST_SET_KEY indéfini - le condition: de l’étape l’ignorera).

Erreurs courantes

• env. préfixe vs secret littéral. Toujours --client-secret env.UIPATH_CLIENT_SECRET, jamais --client-secret "$(UIPATH_CLIENT_SECRET)". La forme littérale intègre la valeur dans la ligne de commande rendue. Consultez l' avertissement d'authentification.
• ##vso[task.setvariable] n'est pas nécessaire pour la résolution env. - env: sur l'étape expose directement la variable.
• Le bash multiligne a besoin de set -euo pipefail en haut de chaque bloc script: . Sans cela, pack peut échouer tandis que les étapes ultérieures se continuent à s'exécuter. Voir Modèles de script — Options shell strictes.
• Les résultats de cache ne sont pas garantis. Enveloppez toujours les commandes d'installation dans if ! command -v uip afin que le pipeline se répare automatiquement lorsque le cache est gelé.

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 en profondeur.
• Formule CI/CD: GitHub Actions, Jenkins, GitLab CI — le même pipeline dans les autres plates-formes.