Migrar do Azure Pipelines para o GitHub Actions

Introdução

O Azure Pipelines e o GitHub Actions permitem criar fluxos de trabalho que automaticamente criam, testam, publicam, lançam e implantam códigos. O Azure Pipelines e o GitHub Actions compartilham algumas similaridades na configuração do fluxo de trabalho:

• Os arquivos de configuração do fluxo de trabalho são gravados YAML e armazenados no repositório do código.
• Os fluxos de trabalho incluem um ou mais trabalhos.
• Os trabalhos incluem uma ou mais etapas ou comandos individuais.
• É possível reutilizar e compartilhar novamente etapas ou tarefas com a comunidade.

Para obter mais informações, confira "Entendendo o GitHub Actions".

Principais diferenças

Ao migrar do Azure Pipelines, considere as diferenças a seguir:

• O Azure Pipelines dá suporte a um editor clássico herdado, que permite que você defina a configuração de CI em um editor de GUI em vez de criar a definição do pipeline em um arquivo YAML. O GitHub Actions usa arquivos YAML para definir fluxos de trabalho e não é compatível com um editor gráfico.
• O Azure Pipelines permite que você omita algumas estruturas nas definições de trabalho. Por exemplo, se você tem apenas um único trabalho, não é necessário definir o trabalho. Você precisa definir apenas as etapas. O GitHub Actions requer configuração explícita e não é possível omitir a estrutura do YAML.
• O Azure Pipelines dá suporte a fases definidas no arquivo YAML, que pode ser usado para criar fluxos de trabalho de implantação. O GitHub Actions exige que você que você separe as etapas em arquivos separados do fluxo de trabalho do YAML.
• É possível selecionar os agentes de criação locais do Azure Pipelines com recursos. GitHub Actions executores auto-hospedados podem ser selecionados com etiquetas.

Migrar trabalhos e etapas

Os trabalhos e as etapas no Azure Pipelines são muito semelhantes a trabalhos e etapas do GitHub Actions. Em ambos os sistemas, os trabalhos têm as características a seguir:

• Os trabalhos contêm uma série de etapas executadas em sequência.
• Os trabalhos são executados em máquinas virtuais separadas ou em contêineres separados.
• Por padrão, os trabalhos executados em paralelo, mas podem ser configuradas para serem executados em sequência.

Migrar etapas de script

Você pode executar um script ou um comando de shell como uma etapa em um fluxo de trabalho. No Azure Pipelines, as etapas de script podem ser especificadas por meio da chave script ou com as chaves bash, powershell ou pwsh. Os scripts também podem ser especificados como uma entrada para a tarefa do Bash ou a tarefa do PowerShell.

No GitHub Actions, todos os scripts são especificados por meio da chave run. Para selecionar um shell específico, você pode especificar a chave shell ao fornecer o script. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Abaixo, há um exemplo da sintaxe para cada sistema.

Sintaxe do Azure Pipelines para etapas de script

jobs:
  - job: scripts
    pool:
      vmImage: 'windows-latest'
    steps:
      - script: echo "This step runs in the default shell"
      - bash: echo "This step runs in bash"
      - pwsh: Write-Host "This step runs in PowerShell Core"
      - task: PowerShell@2
        inputs:
          script: Write-Host "This step runs in PowerShell"

Sintaxe de GitHub Actions para etapas de script

jobs:
  scripts:
    runs-on: windows-latest
    steps:
      - run: echo "This step runs in the default shell"
      - run: echo "This step runs in bash"
        shell: bash
      - run: Write-Host "This step runs in PowerShell Core"
        shell: pwsh
      - run: Write-Host "This step runs in PowerShell"
        shell: powershell

Diferenças na manipulação de erros de script

No Azure Pipelines, os scripts podem ser configurados para erro se uma saída é enviada para stderr. GitHub Actions não suporta esta configuração.

GitHub Actions configura shells como "falha rápida" sempre que possível, que interrompe o script imediatamente caso um dos comandos em um script saia com um código de erro. Em contrapartida, o Azure Pipelines exige uma configuração explícita para sair imediatamente de um erro. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Diferenças no shell-padrão no Windows

No Azure Pipelines, o shell padrão para scripts nas plataformas Windows é o shell de comando (cmd.exe). Em GitHub Actions, o shell-padrão para os scripts nas plataformas do Windows é o PowerShell. O PowerShell tem várias diferenças em comandos integrados, expansão de variáveis e controle de fluxo.

Se você estiver executando um comando simples, você poderá executar um script do shell do comando no PowerShell sem alterações. No entanto, na maioria dos casos, você deverá atualizar seu script com sintaxe PowerShell ou instruir GitHub Actions para executar o script com a shell de comando em vez de executar o PowerShell. Faça isso especificando shell como cmd.

Abaixo, há um exemplo da sintaxe para cada sistema.

Sintaxe do Azure Pipelines usando CMD por padrão

jobs:
  - job: run_command
    pool:
      vmImage: 'windows-latest'
    steps:
      - script: echo "This step runs in CMD on Windows by default"

Sintaxe do GitHub Actions para especificar o CMD

jobs:
  run_command:
    runs-on: windows-latest
    steps:
      - run: echo "This step runs in PowerShell on Windows by default"
      - run: echo "This step runs in CMD on Windows explicitly"
        shell: cmd

Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Migrar condicionais e sintaxe de expressão

O Azure Pipelines e GitHub Actions podem executar as etapas condicionalmente. No Azure Pipelines, as expressões condicionais são especificadas por meio da chave condition. No GitHub Actions, as expressões condicionais são especificadas por meio da chave if.

O Azure Pipelines usa funções dentro de expressões para executar as etapas condicionalmente. Em contrapartida, GitHub Actions usa uma notação de infixo. Por exemplo, você precisa substituir a função eq no Azure Pipelines pelo operador == no GitHub Actions.

Abaixo, há um exemplo da sintaxe para cada sistema.

Sintaxe do Azure Pipelines para expressões condicionais

jobs:
  - job: conditional
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - script: echo "This step runs with str equals 'ABC' and num equals 123"
        condition: and(eq(variables.str, 'ABC'), eq(variables.num, 123))

Sintaxe do GitHub Actions para expressões condicionais

jobs:
  conditional:
    runs-on: ubuntu-latest
    steps:
      - run: echo "This step runs with str equals 'ABC' and num equals 123"
        if: ${{ env.str == 'ABC' && env.num == 123 }}

Para obter mais informações, confira "Avaliar expressões em fluxos de trabalho e ações".

Dependências entre trabalhos

Tanto o Pipelines Azure quanto o GitHub Actions permitem que você defina as dependências para um trabalho. Em ambos os sistemas, os trabalhos são executados em paralelo por padrão, mas as dependências do trabalho podem ser especificadas explicitamente. No Azure Pipelines, isso é feito com a chave dependsOn. No GitHub Actions, isso é feito com a chave needs.

Abaixo, há um exemplo da sintaxe para cada sistema. Os fluxos de trabalho iniciam um primeiro trabalho chamado initial e, quando esse trabalho for concluído, dois trabalhos chamados fanout1 e fanout2 serão executados. Por fim, quando esses trabalhos forem concluídos, o trabalho fanin será executado.

Sintaxe do Azure Pipelines para dependências entre trabalhos

jobs:
  - job: initial
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - script: echo "This job will be run first."
  - job: fanout1
    pool:
      vmImage: 'ubuntu-latest'
    dependsOn: initial
    steps:
      - script: echo "This job will run after the initial job, in parallel with fanout2."
  - job: fanout2
    pool:
      vmImage: 'ubuntu-latest'
    dependsOn: initial
    steps:
      - script: echo "This job will run after the initial job, in parallel with fanout1."
  - job: fanin:
    pool:
      vmImage: 'ubuntu-latest'
    dependsOn: [fanout1, fanout2]
    steps:
      - script: echo "This job will run after fanout1 and fanout2 have finished."

Sintaxe do GitHub Actions para dependências entre trabalhos

jobs:
  initial:
    runs-on: ubuntu-latest
    steps:
      - run: echo "This job will be run first."
  fanout1:
    runs-on: ubuntu-latest
    needs: initial
    steps:
      - run: echo "This job will run after the initial job, in parallel with fanout2."
  fanout2:
    runs-on: ubuntu-latest
    needs: initial
    steps:
      - run: echo "This job will run after the initial job, in parallel with fanout1."
  fanin:
    runs-on: ubuntu-latest
    needs: [fanout1, fanout2]
    steps:
      - run: echo "This job will run after fanout1 and fanout2 have finished."

Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Migrar tarefas para ações

O Azure Pipelines usa tarefas, que são componentes do aplicativo que podem ser reutilizados em vários fluxos de trabalho. O GitHub Actions usa ações, que podem ser usadas para realizar tarefas e personalizar seu fluxo de trabalho. Em ambos os sistemas, é possível especificar o nome da tarefa ou ação a executar, junto com quaisquer entradas necessárias como pares chave/valor.

Abaixo, há um exemplo da sintaxe para cada sistema.

Sintaxe do Azure Pipelines para tarefas

jobs:
  - job: run_python
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - task: UsePythonVersion@0
        inputs:
          versionSpec: '3.7'
          architecture: 'x64'
      - script: python script.py

Sintaxe do GitHub Actions para ações

jobs:
  run_python:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/setup-python@v5
        with:
          python-version: '3.7'
          architecture: 'x64'
      - run: python script.py

Encontre ações que você pode usar no seu fluxo de trabalho no GitHub Marketplace ou crie suas ações. Para obter mais informações, confira "Compartilhar automações".