Entenda o GitHub Actions

Concluído

Automatize as etapas em seu processo de implantação usando um fluxo de trabalho. Sempre que você fizer uma alteração no código e confirmá-la no repositório Git, o fluxo de trabalho executará o processo predefinido. Um fluxo de trabalho pode verificar se o seu código Bicep atende aos padrões de qualidade e automatizar as ações para implantar seus recursos no Azure. O processo é definido em uma definição de fluxo de trabalho que você cria.

O GitHub Actions é um recurso do GitHub. O GitHub também hospeda os repositórios Git usados para armazenar e compartilhar seu código com seus colaboradores. Quando você armazena seu código Bicep no GitHub, o GitHub Actions pode acessar seu código para automatizar seus processos de implantação. Nesta unidade, você saberá mais sobre o GitHub Actions.

O que é um fluxo de trabalho?

Um fluxo de trabalho é um processo reproduzível configurável definido em um arquivo, que é usado para testar e implantar seu código. Um fluxo de trabalho consiste em todas as etapas, na ordem correta, que você precisa executar.

Ao trabalhar com o GitHub Actions, define a configuração do fluxo de trabalho em um arquivo YAML. "Como um arquivo YAML de fluxo de trabalho é um arquivo de código, ele é armazenado com o código Bicep no seu repositório Git em uma pasta chamada .github/workflows. Um arquivo YAML é um arquivo de texto estruturado, semelhante a um arquivo de texto estruturado do Bicep. Você pode criar e editar um arquivo YAML com qualquer editor de texto. Neste módulo, você vai usar o Visual Studio Code como o editor. A interface da Web do GitHub fornece ferramentas que você pode usar para exibir e editar o arquivo de YAML do fluxo de trabalho, colaborar em sua definição de fluxo de trabalho e gerenciar versões diferentes do seu arquivo de fluxo de trabalho usando commits e branches.

Executores

Até agora, você implantou os arquivos Bicep do computador local. Depois de escrever um modelo Bicep, implante-o no Azure usando a CLI do Azure ou o Azure PowerShell. Essas ferramentas usam os recursos do computador para enviar o modelo para o Azure. Elas usam sua identidade pessoal para autenticar você no Azure e verificar se você tem as permissões para implantar os recursos.

Um fluxo de trabalho também precisa de acesso a um computador ou GPU com o sistema operacional e a plataforma de hardware corretos para executar as ações de implantação. O GitHub Actions usa runners, que são computadores configurados para executar etapas de implantação para um fluxo de trabalho. Cada executor já possui as ferramentas de Bicep e Azure que você usou nos módulos anteriores, ou seja, é capaz de fazer as mesmas coisas feitas em seu próprio computador. Em vez de um humano executando comandos, o serviço GitHub Actions instrui o executor a realizar as etapas definidas em um arquivo YAML de fluxo de trabalho.

O GitHub Actions fornece vários tipos de executores para diferentes sistemas operacionais, como Linux ou Windows, e diferentes conjuntos de ferramentas. O GitHub gerencia esses executores, portanto, você não é preciso manter nenhuma infraestrutura de computação para os executores. Às vezes, os executores são chamados de executores hospedados no GitHub ou executores hospedados porque eles são hospedados em seu nome. Quando o fluxo de trabalho é executado, um executor hospedado é criado automaticamente. Quando o fluxo de trabalho terminar de ser executado, o executor hospedado é excluído automaticamente. Você não pode acessar executores hospedados diretamente, ou seja, é importante que seu fluxo de trabalho contenha todas as etapas necessárias para implantar sua solução.

Observação

Você pode criar um executor personalizado chamado de executor auto-hospedado. Você pode criar um executor auto-hospedado caso tenha um software específico que precise ser executado como parte de seu fluxo de trabalho ou caso seja necessário controlar com precisão como o executor é configurado. Não discutimos executores auto-hospedados neste módulo, mas fornecemos um link para mais informações na seção Resumo.

Gatilhos

Você usa um gatilho para instruir o GitHub Actions sobre quando executar seu fluxo de trabalho. Você pode escolher entre vários tipos de gatilhos. Por enquanto, você usará um gatilho manual para dizer ao GitHub Actions quando iniciar a execução do fluxo de trabalho. Mais adiante neste módulo, você saberá mais sobre outros tipos de gatilhos.

Etapas

Uma etapa representa uma única operação que o fluxo de trabalho executa. Uma etapa é semelhante a um comando individual executado no Bash ou no PowerShell. Na maioria das implantações, você executa várias etapas em uma sequência. Você define a sequência e todos os detalhes de cada etapa no arquivo YAML do fluxo de trabalho.

O GitHub Actions oferece dois tipos de etapas:

• Etapas de execução: Você pode usar uma etapa de execução para executar um único comando ou uma sequência de comandos no Bash, no PowerShell ou no shell de comando do Windows.
• Etapas de ação: Uma etapa de ação é uma maneira conveniente de acessar muitos recursos diferentes sem ter que escrever instruções de script. Por exemplo, há uma tarefa interna para implantar arquivos Bicep no Azure. Qualquer pessoa pode escrever uma ação e compartilhá-la com outros usuários. Um grande conjunto de tarefas comerciais e de código aberto está disponível.

Algumas pessoas preferem usar instruções de script em vez de ações porque elas oferecem mais controle sobre o que é executado. Outras pessoas preferem usar tarefas para não precisar escrever e gerenciar scripts. Neste módulo, usaremos uma combinação de ambas as abordagens.

Trabalhos

No GitHub Actions, um trabalho representa um conjunto ordenado de etapas. Você sempre tem pelo menos um trabalho em um fluxo de trabalho e é comum ter mais de um trabalho ao criar implantações complexas.

Observação

Você pode definir que cada trabalho seja executado em um executor diferente. Executar trabalhos em diferentes executores é útil quando você cria e implanta soluções que precisam usar sistemas operacionais diferentes em diferentes partes do fluxo de trabalho.

Por exemplo, digamos que você esteja criando um aplicativo iOS e o serviço de back-end dele. Você pode ter um trabalho executado em um executor do macOS para criar o aplicativo iOS e outro executado em um executor do Ubuntu ou do Windows para criar o back-end. Você pode até mesmo dizer ao fluxo de trabalho para executar os dois trabalhos simultaneamente, o que acelera a execução do fluxo de trabalho.

Exemplo de fluxo de trabalho básico

Agora que você conhece os conceitos básicos do GitHub Actions, vamos ver uma definição de fluxo de trabalho simples no YAML:

name: learn-github-actions

on: [workflow_dispatch]

jobs:
  say-hello:
    runs-on: ubuntu-latest
    steps:
      - name: 'Run a one-line command'
        run: echo "hello from GitHub Actions"
      - name: 'Run a multi-line command'
        run: |
          echo "We'll add more steps soon."
          echo "For example, we'll add our Bicep deployment step."

Vamos examinar cada parte do arquivo em detalhes:

• name é o nome do seu fluxo de trabalho. O nome é mostrado na interface da web do GitHub.
• on informa ao fluxo de trabalho quando executar. Neste caso, on: [workflow_dispatch] informa ao GitHub Actions que você deseja disparar manualmente o fluxo de trabalho.
• jobs reúne todos os trabalhos no seu fluxo de trabalho.
• say-hello é o nome do seu primeiro e único trabalho neste fluxo de trabalho.
• runs-on instrui o fluxo de trabalho que o executor deve usar ao executar o trabalho. Neste exemplo, o fluxo de trabalho é executado em um sistema operacional Ubuntu, que vem de um pool de runners hospedados pelo GitHub.
• steps lista a sequência de etapas a serem executadas no trabalho. O YAML de exemplo tem duas etapas. Ambas as etapas são executadas em um único script para exibir um texto. Cada etapa tem um valor name, que pode ser lido por humanos. Você verá o nome nos logs de fluxo de trabalho. Para criar uma etapa de script com várias linhas, use o caractere de pipe (|) conforme mostrado no exemplo. Depois que a etapa for executada, você verá as saídas no log do fluxo de trabalho.

Importante

Em arquivos YAML, o recuo é importante. Veja o exemplo do YAML. Algumas linhas no YAML têm recuo de dois ou quatro espaços. Se você não adicionar os recuos do arquivo corretamente, o GitHub Actions não poderá interpretá-lo. O Visual Studio Code ajuda você a encontrar e corrigir erros no recuo do arquivo YAML.