Receita de CI/CD: ações do GitHub

Esta página fornece um .github/workflows/deploy.yml completo que instala a CLI, autentica com um Aplicativo Externo, empacota e publica uma Solução da UiPath, a implanta no Orchestrator e executa um pacote do Test Manager na implantação. Solte-o no seu repositório, adicione dois segredos e ele será executado.

Para os princípios subjacentes — autenticação, cache, pré-instalação de ferramentas, aplicação de versão — consulte Como fazer: implantar no Orchestrator a partir de CI. Esta página se concentra na sintaxe de ações do GitHub.

Pré-requisitos

Antes de copiar o YAML abaixo:

1. Crie um aplicativo externo na UiPath com os escopos OR.* de que seu pipeline precisa. Consulte Autenticação — Fluxo 2.
2. Armazene os segredos nas configurações do repositório (ou organização/ambiente):
   • Configurações → Segredos e variáveis → Ações → Novo segredo do repositório.
   • Adicione UIPATH_CLIENT_ID e UIPATH_CLIENT_SECRET como segredos.
   • Adicione UIPATH_TENANT como uma variável (não é um segredo — não é confidencial).
3. Provisione um projeto do Test Manager e um conjunto de testes se você quiser o trabalho de teste. Coloque TEST_SET_KEY (por exemplo PROJECT:42) e PROJECT_KEY nas variáveis de repositório. Consulte Como fazer: executar testes a partir da 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

Tutorial

Criar trabalho

• actions/setup-node@v4 fixa o nó à versão principal especificada por NODE_VERSION. A CLI requer o Nó 18+.
• actions/cache@v4 armazena em cache o diretório global node_modules npm, chaveado na versão da CLI fixada e no sistema operacional do executor. Quando o cache é atingido, a proteção if ! command -v uip da etapa de instalação se transforma em um não operacional.
• A etapa de instalação configura um prefixo npm de usuário local (não sudo necessário em executores hospedados pelo GitHub), adiciona-o a GITHUB_PATH para que etapas posteriores consultem o comando uip e instala a CLI. A primeira invocação de um comando de ferramenta (uip solution …, uip tm …) instala automaticamente essa ferramenta — nenhum uip tools install explícito é necessário. Consulte Instalação do UiPath CLI — CI/CD.
• A etapa Empacotar invoca uip solution pack com um --version explícito criado a partir de github.run_number (monito, exclusivo por execução no repositório). A etapa captura o caminho .zip produzido com find em vez de codificar o nome do arquivo — mantém a receita estável entre alterações da convenção de nomenclatura da CLI.
• actions/upload-artifact@v4 carrega o .zip capturado para que o trabalho deploy possa baixá-lo na próxima execução.
• outputs.solution_version propaga a versão computada para o trabalho deploy — a maneira mais simples de compartilhar um valor entre trabalhos no mesmo fluxo de trabalho.

Implantar trabalho

• Reinstala a CLI — needs: build força a ordem de trabalho, mas cada trabalho é executado em um novo executor. O cache deve atingir a segunda instalação.
• actions/download-artifact@v4 extrai solution-zip para $OUTPUT_DIR.
• A etapa Autenticar passa segredos por meio do bloco env: da etapa e, em seguida, uip login os lê por meio do prefixo env. . O prefixo env.VAR_NAME é a maneira compatível de manter um segredo fora da linha de comando — consulte Autenticação — o prefixo env.var_NAME. Não escreva --client-secret "${{ secrets.UIPATH_CLIENT_SECRET }}" — isso incorpora o valor ao comando renderizado e ao log de etapas.
• As etapas de publicação + implantação usam uip solution publish e uip solution deploy run. --name usa github.run_number para que cada implantação seja identificável.
• environment: uipath-prod o trabalho a um ambiente de implantação. Os ambientes são onde você configura revisores necessários, temporizadores de espera e ramificações de implantação — mantenha-os na interface gráfica e deixe o YAML declarativo.

Trabalho de teste

Executa apenas se a variável repositório TEST_SET_KEY estiver definida — caso contrário, a proteção if: a ignorará. O bloco de shell é o padrão de inicialização → aguardar → verificação de Como fazer: executar testes a partir da CLI:

1. uip tm testsets run inicia e retorna um ExecutionId.
2. Blocos uip tm wait até o estado terminal. A saída 2 significa o tempo limite em wait (não falha de autenticação); o código de saída é relatado por meio de ::error:: para que ele apareça na IU de ações.
3. uip tm report get lê Data.Failed e a etapa sai 1 quando algo falhou.

Variações comuns

Promover em ambientes

Adicione um deploy trabalho, que dependa do primeiro, com diferentes segredos:

  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.

As portas de aprovação estão nas configurações do ambiente — a ordem de aplicação da cadeia needs: . Consulte Como fazer: empacotar e publicar uma solução — promover um pacote entre tenants.

Reverter

Adicione uma entrada workflow_dispatch e um trabalho protegido que reimplanta uma versão específica:

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

Dispare com Ações → Implantar solução UiPath → Execute o fluxo de trabalho e insira a versão de reversão. Para reversão destrutiva (desinstalar + solution packages delete), consulte Instruções: empacotar e publicar uma solução — reverter.

Ignorar testes

Defina (ou deixe de definir) a variável de repositório TEST_SET_KEY . A proteção if: ${{ vars.TEST_SET_KEY != '' }} ignora o trabalho inteiro.

armadilhas comuns

• interpolação${{ secrets.X }} . Ele substitui na camada de renderização de etapa. Se você colocar um segredo em uma linha de comando run: diretamente, o valor torna-se parte do script renderizado — e do log da etapa, a menos que o GitHub o mascare. Sempre encaminhe segredos por meio de env: e leia-os com env.VAR_NAME dentro de uip.
• $GITHUB_PATH vs $PATH. A exportação de PATH=… em uma etapa não é carregada na próxima. Use echo "…" >> "$GITHUB_PATH" para persistir uma adição de PATH em etapas no mesmo executor.
• strict shell options Inicie cada run: multilinha com set -euo pipefail — sem ele, um uip solution pack com falha pode ser seguido por uma publicação "bem-sucedida" de um artefato obsoleto. Consulte Padrões de script — opções estritas de shell.
• Armazene em cache falsos positivos. Se você atingir CLI_VERSION mas a chave de cache não a incluir, você continuará usando a CLI antiga. A chave neste YAML inclui ${{ env.CLI_VERSION }} exatamente por esse motivo.
• O caminho do cache está associado ao prefixo npm. O bloco de cache usa ~/.npm-global/lib/node_modules, que só funciona porque a etapa de instalação é executada npm config set prefix "$HOME/.npm-global". Se você alterar o prefixo (por exemplo, em um executor do Windows auto-hospedado onde a convenção é %APPDATA%\npm\node_modules), tanto o cache path: quanto a linha npm config set prefix devem se mover juntos. Em um executor mais recente que não ubuntu, descarte o caminho real primeiro com - run: npm root -g e o que espelhar ele relatar.

Veja também

• Como fazer: implantar no Orchestrator a partir do CI — orientação independente de plataforma.
• Como fazer: empacotar e publicar uma Solução — controle de versão e rollback.
• Como fazer: executar testes a partir da CLI — o padrão de inicialização → aguardar → verificação.
• Receita de CI/CD: Azure Pipelines, Jenkins, GitLab CI — o mesmo pipeline em outras plataformas.