Como o GitHub Actions automatiza as tarefas de desenvolvimento?

Concluído

Aqui, apresentaremos o GitHub Actions e os fluxos de trabalho. Você aprenderá quais tipos de ações poderá usar e onde encontrá-los. Você também verá exemplos desses tipos de ações e como eles se encaixam em um fluxo de trabalho.

O GitHub diminui o tempo entre a ideia e a implantação

O GitHub foi projetado para ajudar as equipes de desenvolvedores e engenheiros de DevOps a criar e implantar aplicativos rapidamente. Há muitos recursos no GitHub que permitem isso, mas geralmente eles se enquadram em uma das duas categorias:

• Comunicação: considere todas as formas como o GitHub facilita para uma equipe de desenvolvedores se comunicar sobre o projeto de desenvolvimento de software: revisões de código em solicitações de pull, problemas do GitHub, quadros de projeto, wikis, notificações e assim por diante.
• Automação: o GitHub Actions permite que sua equipe automatize fluxos de trabalho em cada etapa no processo de desenvolvimento de software, da integração à entrega à implantação. Ele permite até mesmo que você automatize a adição de rótulos a solicitações de pull e verifique se há solicitações de pull e problemas obsoletos.

Quando combinados, esses recursos permitiram que milhares de equipes de desenvolvimento reduzissem efetivamente o tempo entre a ideia inicial e a implantação.

Usar a automação de fluxo de trabalho para reduzir o tempo de desenvolvimento

Focaremos na automação neste módulo. Portanto, vamos dedicar algum tempo a entender como as equipes podem usar a automação para reduzir o tempo necessário para concluir um fluxo de trabalho típico de desenvolvimento e implantação.

Considere todas as tarefas que devem ocorrer depois que o código for escrito, mas antes que você possa usar o código de forma confiável para sua finalidade. Dependendo das metas da organização, você provavelmente precisará executar uma ou mais das seguintes tarefas:

• Garantir que o código passe em todos os testes de unidade
• Executar verificações de qualidade e conformidade do código para garantir que o código-fonte atenda aos padrões da organização
• Verificar no código e em suas dependências se há problemas de segurança conhecidos
• Criar o código integrando novas fontes de diferentes colaboradores (potencialmente)
• Verificar se o software passa nos testes de integração
• Estipular a versão do novo build
• Entregar os novos binários para o local apropriado do sistema de arquivos
• Implantar os novos binários em um ou mais servidores
• Se alguma dessas tarefas não for aprovada, relatar o problema ao indivíduo ou à equipe adequados para resolução

O desafio é realizar essas tarefas de modo consistente, confiável e sustentável. Esse é um trabalho ideal para a automação do fluxo de trabalho. Caso você já esteja usando o GitHub, convém configurar a automação do fluxo de trabalho usando o GitHub Actions.

O que é o GitHub Actions?

As ações do GitHub Actions são scripts empacotados para automatizar tarefas em um fluxo de trabalho de desenvolvimento de software no GitHub. Você pode configurar o GitHub Actions para disparar fluxos de trabalho complexos que atendem às necessidades da organização: cada vez que os desenvolvedores fazem check-in do novo código-fonte em um branch específico, em intervalos de tempo ou manualmente. O resultado é um fluxo de trabalho automatizado confiável e sustentável que resulta na diminuição significativa do tempo de desenvolvimento.

Onde você pode encontrar o GitHub Actions?

O GitHub Actions consiste em scripts que aderem a um formato de dados yml. Cada repositório tem uma guia Ações que fornece uma maneira rápida e fácil de começar a configurar seu primeiro script. Se você vir um fluxo de trabalho que acredita que pode ser um ótimo ponto de partida, basta selecionar o botão Configurar para adicionar o script e começar a editar o yml de origem.

No entanto, além dessas opções do GitHub Actions em destaque na guia Ações, você pode:

• Pesquisar o GitHub Actions no GitHub Marketplace. O GitHub Marketplace permite que você descubra e compre ferramentas que estendam seu fluxo de trabalho.
• Pesquisar projetos open-source. Por exemplo, a organização do GitHub Actions apresenta muitos repositórios populares de código aberto com recursos do GitHub Actions que você pode usar.
• Gravar suas próprias ações do GitHub Actions do zero. Além disso, se desejar, você pode torná-las softwares livres ou até mesmo publicá-las no GitHub Marketplace.

Usar funções de código aberto do GitHub Actions

Muitas funções do GitHub Actions são de código aberto e estão disponíveis para qualquer pessoa que queira usá-las. No entanto, assim como ocorre com qualquer software de código aberto, você precisa verificá-las cuidadosamente antes de usá-las no seu projeto. Semelhante aos padrões de comunidade recomendados com software livre, como incluir um LEIAME, código de conduta, arquivo de contribuição, modelos de problemas etc., você pode seguir estas recomendações ao usar GitHub Actions:

• Examine o arquivo action.yml da ação em busca de entradas, saídas e para verificar se o código faz o que ele diz fazer.
• Verifique se a ação está no GitHub Marketplace. Essa é uma boa verificação, mesmo que uma ação não precise estar no GitHub Marketplace para ser válida.
• Confira se a ação foi verificada no GitHub Marketplace. Isso significa que o GitHub aprovou o uso dessa ação. No entanto, você ainda deve examiná-la antes de usá-la.
• Inclua a versão da ação que você está usando especificando uma referência do Git, SHA ou marcação.

Tipos de ações do GitHub

Há três tipos de ações do GitHub: ações de contêiner, ações de JavaScript e ações compostas.

Com as ações de contêiner, o ambiente faz parte do código da ação. Essas ações só podem ser executadas em um ambiente Linux hospedado pelo GitHub. As ações de contêiner são compatíveis com vários idiomas diferentes.

As ações de JavaScript não incluem o ambiente no código. Você terá que especificar o ambiente para executar essas ações. Você poderá executar essas ações em uma VM local ou na nuvem. As ações do JavaScript são compatíveis com ambientes Linux, macOS e Windows.

As ações compostas permitem combinar várias etapas de fluxo de trabalho em uma ação. Por exemplo, você pode usar esse recurso para juntar vários comandos executando em uma ação e, em seguida, ter um fluxo de trabalho que executa os comandos empacotados como uma única etapa usando essa ação.

A anatomia de uma ação do GitHub

Este é um exemplo de uma ação que executa um check-out git de um repositório. Essa ação, actions/checkout@v1, faz parte de uma etapa em um fluxo de trabalho. Esta etapa também cria o código Node.js para o qual foi feito check-out. Vamos falar sobre fluxos de trabalho, trabalhos e etapas na próxima seção.

steps:
  - uses: actions/checkout@v1
  - name: npm install and build webpack
    run: |
      npm install
      npm run build

Suponha que você queira usar uma ação de contêiner para executar código em contêineres. A ação teria a seguinte aparência:

name: "Hello Actions"
description: "Greet someone"
author: "octocat@github.com"

inputs:
    MY_NAME:
      description: "Who to greet"
      required: true
      default: "World"

runs:
    uses: "docker"
    image: "Dockerfile"

branding:
    icon: "mic"
    color: "purple"

Observe a seção inputs. Aqui você recebe o valor de uma variável chamada MY_NAME. Essa variável será definida no fluxo de trabalho que executa essa ação.

Na seção runs, observe que você especifica docker no atributo uses. Ao fazer isso, você precisará fornecer o caminho para o arquivo de imagem do Docker. Aqui, ele é chamado de Dockerfile. Não entraremos em detalhes sobre o Docker aqui, mas se você quiser mais informações, confira o módulo Introdução aos contêineres do Docker.

A última seção, identidade visual, personalizará sua ação no GitHub Marketplace se você decidir publicá-la.

Você poderá encontrar uma lista completa de metadados de ação em Sintaxe de metadados para o GitHub Actions.

O que é um fluxo de trabalho do GitHub Actions?

Um fluxo de trabalho do GitHub Actions é um processo que você configura em seu repositório para automatizar as tarefas do ciclo de vida do desenvolvimento de software, incluindo as ações do GitHub Actions. Com um fluxo de trabalho, você poderá criar, testar, agrupar em um pacote, lançar e implantar qualquer projeto no GitHub.

Para criar um fluxo de trabalho, você adiciona ações a um arquivo .yml no diretório .github/workflows do repositório do GitHub.

No próximo exercício, o arquivo do fluxo de trabalho, main.yml, terá a aparência a seguir:

name: A workflow for my Hello World file
on: push
jobs:
  build:
    name: Hello world action
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - uses: ./action-a
      with:
        MY_NAME: "Mona"

Observe o atributo on:. Este é um gatilho para especificar quando este fluxo de trabalho será executado. Aqui, ele dispara uma execução quando há um evento de push no repositório. Você poderá especificar eventos únicos como on: push, uma matriz de eventos como on: [push, pull_request] ou um mapa de configuração de eventos que agenda um fluxo de trabalho ou restringe a execução de um fluxo de trabalho para arquivos, marcações ou alterações de branch específicas. O mapa será semelhante ao seguinte:

on:
  # Trigger the workflow on push or pull request,
  # but only for the main branch
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
  # Also trigger on page_build, as well as release created events
  page_build:
  release:
    types: # This configuration does not affect the page_build event above
      - created

Um evento será disparado em todos os tipos de atividade para o evento, a menos que você especifique o tipo ou os tipos. Para obter uma lista abrangente de eventos e os tipos de atividades deles, confira Eventos que disparam fluxos de trabalho na documentação GitHub.

Um fluxo de trabalho deve ter pelo menos um trabalho. O trabalho é uma seção do fluxo de trabalho associada a um executor. Um executor poderá ser hospedado no GitHub ou auto-hospedado, e o trabalho poderá ser executado em um computador ou em um contêiner. Você especificará o executor com o atributo runs-on:. Aqui você está informando ao fluxo de trabalho para executar esse trabalho em ubuntu-latest.

Cada trabalho terá etapas a serem concluídas. No exemplo, a etapa usa a ação actions/checkout@v1 para fazer check-out do repositório. O mais interessante é o valor de uses: ./action-a, que corresponde ao caminho à ação de contêiner criada em um arquivo action.yml. Nós analisamos o conteúdo de um arquivo action.yml na seção O que é o GitHub Actions?.

A última parte desse arquivo de fluxo de trabalho define o valor da variável MY_NAME para esse fluxo de trabalho. Lembre-se de que a ação do contêiner usou uma entrada chamada MY_NAME.

Para obter mais informações sobre a sintaxe do fluxo de trabalho, confira Sintaxe de fluxo de trabalho para o GitHub Actions

Executores hospedados no GitHub versus executores auto-hospedados

Mencionamos brevemente os executores como associados a um trabalho. Um executor é simplesmente um servidor que tem o aplicativo de executor do GitHub Actions instalado. No exemplo anterior de fluxo de trabalho, havia um atributo runs-on: ubuntu-latest dentro do bloco de trabalhos, que informou ao fluxo de trabalho que o trabalho seria executado usando o executor hospedado no GitHub, em execução no ambiente ubuntu-latest.

Quando se trata de executores, há duas opções das quais escolher: Executores hospedados no GitHub ou executores auto-hospedados. Se você usar um executor hospedado no GitHub, cada trabalho será executado em uma nova instância de um ambiente virtual especificado pelo tipo de executor hospedado no GitHub que você definir, runs-on: {operating system-version}. Com executores auto-hospedados, você precisa aplicar o rótulo de auto-hospedado, seu sistema operacional e a arquitetura do sistema. Por exemplo, um executor auto-hospedado com um sistema operacional Linux e a arquitetura ARM32 seria semelhante ao seguinte: runs-on: [self-hosted, linux, ARM32].

Cada tipo de executor tem seus benefícios, mas os executores hospedados no GitHub oferecem um modo mais rápido e simples de executar os fluxos de trabalho, embora com opções limitadas. Os executores auto-hospedados são uma maneira altamente configurável de executar fluxos de trabalho em seu próprio ambiente local personalizado. Você pode executar os executores auto-hospedados localmente ou na nuvem. Você também pode usar executores auto-hospedados para criar uma configuração de hardware personalizada com mais capacidade de processamento ou memória para executar trabalhos maiores, instalar o software disponível em sua rede local e escolher um sistema operacional não oferecido por executores hospedados no GitHub.

O GitHub Actions pode ter limites de uso

O GitHub Actions têm alguns limites de uso, dependendo do seu plano do GitHub e de o executor ser hospedado no GitHub ou auto-hospedado. Para obter mais informações sobre os limites de uso, confira Limites de uso, cobrança e administração na documentação do GitHub.