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, consulte "Conceitos básicos para GitHub Actions".

Principais diferenças

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

• O Azure Pipelines suporta um legado do editor clássico, que permite que você defina sua configuração de CI em um editor 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 é compatível com as etapas 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 do script podem ser especificadas usando a chave script, ou usando as chaves bash, powershell, ou pwsh. É possível especificar os scripts como entrada para uma tarefa de Bash ou a como uma tarefa de PowerShell.

Em GitHub Actions, todos os scripts são especificados usando a chave executar. Para selecionar um shell específico, você pode especificar a chave shell ao fornecer o script. Para obter mais informações, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".

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

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"

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 com erro se houver uma saída for 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, consulte "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 do 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. Você pode fazer isso especificando o shell como cmd.

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

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

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, consulte "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, expressões condicionais são especificadas usando a chave condição. Em GitHub Actions, as expressões condicionais são especificadas usando a chave se.

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ê deve substituir a função eq no Azure Pipelines pelo operador == em GitHub Actions.

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

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

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, consulte "Expressõ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. Em GitHub Actions, isso é feito com a chave needs.

Abaixo, há um exemplo da sintaxe para cada sistema. O fluxo de trabalho inicia um primeiro trabalho denominado inicial e, quando esse trabalho é concluído, dois trabalhos denominados fanout1 e fanout2 serão executados. Por fim, quando esses trabalhos forem concluídos, o trabalho fanin será executado.

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."

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, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".

Migrar tarefas para ações

O Azure Pipelines usa as tarefas, que são componentes do aplicativo que podem ser reutilizados em vários fluxos de trabalho. O GitHub Actions usa as 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:

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

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

Você pode encontrar ações que podem ser usadas em seu fluxo de trabalho em GitHub Marketplace ou você pode criar suas próprias ações. Para obter mais informações, consulte "Criar ações".