Como o GitHub Actions automatiza as tarefas de desenvolvimento?

Concluído

Aqui, apresentamos o GitHub Actions e fluxos de trabalho. Você aprende os tipos de ações que pode usar e onde encontrá-las. Você também analisa exemplos desses tipos de ações e como elas 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 essas eficiências, mas geralmente se enquadram em uma das duas categorias:

• Comunicação: considere todas as formas pelas quais o GitHub torna fácil 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

Neste módulo, nos concentramos na automação. Vamos separar um tempo para entender como as equipes podem usar a automação a fim de reduzir a quantidade de tempo necessária 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 sua 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.
• Crie o código integrando o novo código-fonte de (potencialmente) vários colaboradores.
• Verificar se o software passa nos testes de integração.
• Especifique 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.
• Determine se alguma dessas tarefas não são aprovadas e relate o problema para o indivíduo ou equipe adequado para que sejam resolvidos.

O desafio é realizar essas tarefas de modo consistente, confiável e sustentável. Esse processo é um trabalho ideal para automação de fluxo de trabalho. Se você já estiver contando com o GitHub, provavelmente deseja configurar sua automação de 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 sua organização. O gatilho pode ocorrer sempre que os desenvolvedores verificarem o novo código-fonte em um branch específico, em intervalos programados 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. Você pode torná-los de código aberto ou até mesmo publicá-los 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 de código aberto, 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 verificação vale a pena, 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. A verificação 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ê precisa especificar o ambiente para executar essas ações. Você poderá executar essas ações em uma VM (máquina virtual) 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ê poderá usar esse recurso para agrupar vários comandos de execução em uma ação e, em seguida, ter um fluxo de trabalho que executa os comandos agrupados 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 é definida no fluxo de trabalho que executa essa ação.

Na seção runs, observe que você especifica docker no atributo uses. Ao definir esse valor, você precisa fornecer o caminho para o arquivo de imagem do Docker. Nesse caso, Dockerfile. Não estamos cobrindo as especificidades do 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 de fluxo de trabalho main.yml se parece com este exemplo:

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:, cujo valor é 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 doesn't affect the page_build event above
      - created

Um evento é disparado em todos os tipos de atividade do evento, a menos que você especifique o tipo ou 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. O executor poderá ser hospedado no GitHub ou auto-hospedado e o trabalho poderá ser executado em um computador ou em um contêiner. Especifique o executor com o atributo runs-on:. Aqui você está informando ao fluxo de trabalho para executar esse trabalho em ubuntu-latest.

Cada trabalho tem 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.

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

Referenciando ações em fluxos de trabalho

Ao criar fluxos de trabalho no GitHub Actions, você pode referenciar ações de várias fontes. Essas ações podem ser usadas para automatizar tarefas em seus fluxos de trabalho. Abaixo estão as principais fontes em que os fluxos de trabalho podem referenciar ações:

1. Uma imagem de contêiner do Docker publicada no Hub do Docker
   Os fluxos de trabalho podem referenciar ações que são publicadas como imagens de contêiner do Docker no Hub do Docker. Essas ações são conteinerizadas e incluem todas as dependências necessárias para executar a ação. Para usar essa ação, especifique a imagem do uses Docker no atributo da etapa de fluxo de trabalho. Por exemplo:

   steps:
     - name: Run a Docker action
       uses: docker://<docker-image-name>:<tag>
   

2. Qualquer repositório público
   As ações hospedadas em repositórios públicos podem ser referenciadas diretamente em seus fluxos de trabalho. Essas ações são acessíveis a qualquer pessoa e podem ser usadas especificando o nome e a versão do repositório (git ref, SHA ou tag) no uses atributo. Por exemplo:

   steps:
     - name: Use a public action
       uses: actions/checkout@v3
   

[! IMPORTANTE]

Para obter uma melhor segurança, use uma SHA de confirmação completa ao referenciar ações, não apenas uma marca como @v3.
Isso garante que o fluxo de trabalho sempre use exatamente o mesmo código, mesmo que a ação seja atualizada ou alterada posteriormente.
Exemplo: uses: actions/checkout@c2c1744e079e0dd11c8e0af4a96064ca4f6a2e9e

3. O mesmo repositório que o arquivo de fluxo de trabalho
   Você pode referenciar ações armazenadas no mesmo repositório que o arquivo de fluxo de trabalho. Esse recurso é útil para ações personalizadas específicas do seu projeto. Para fazer referência a essas ações, use um caminho relativo para o diretório da ação. Por exemplo:

   steps:
     - name: Use a local action
       uses: ./path-to-action
   

Para obter mais detalhes, consulte as diretrizes de proteção de segurança para o GitHub Actions.

4. Um marketplace empresarial
   Se sua organização usar o GitHub Enterprise, você poderá referenciar ações do marketplace privado da sua empresa. Essas ações são selecionadas e gerenciadas por sua organização, garantindo a conformidade com os padrões internos. Por exemplo:

   steps:
     - name: Use an enterprise marketplace action
       uses: enterprise-org/action-name@v1
   

Observação

• Ações em repositórios privados também podem ser referenciadas, mas exigem autenticação e permissões adequadas.
• Ao referenciar ações, sempre especifique uma versão (git ref, SHA ou tag) para garantir a consistência e evitar alterações inesperadas.

Para obter mais informações, consulte Referenciando ações em fluxos de trabalho.

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 de fluxo de trabalho anterior, havia um runs-on: ubuntu-latest atributo dentro do bloco de trabalhos, que informava ao fluxo de trabalho que o trabalho seria executado usando o executor hospedado no GitHub que está em execução no ubuntu-latest ambiente.

Quando se trata de corredores, há duas opções das quais escolher: executores hospedados pelo 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. O tipo de executor hospedado no GitHub em que você define runs-on: {operating system-version} e que então especifica esse ambiente. 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 uma arquitetura ARM32 seria semelhante à seguinte especificação: 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 poder de processamento ou memória. Esse tipo de configuração ajuda a executar trabalhos maiores, instalar o software disponível em sua rede local e escolher um sistema operacional não oferecido por executores hospedados pelo GitHub.

O GitHub Actions pode ter limites de uso

O GitHub Actions tem alguns limites de uso, dependendo do plano do GitHub que você possui e se o executor é 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.

Executores avançados hospedados no GitHub

O GitHub oferece executores avançados para fluxos de trabalho que exigem mais recursos. Esses executores são hospedados no GitHub e fornecem maior CPU, memória e espaço em disco em comparação com os executores padrão. Eles foram projetados para lidar com fluxos de trabalho com uso intensivo de recursos com eficiência, garantindo um desempenho ideal para tarefas exigentes.

Tamanhos e rótulos do executor

Os executores maiores estão disponíveis em várias configurações, fornecendo vCPUs, RAM e armazenamento SSD aprimorados para atender a diversos requisitos de fluxo de trabalho. Essas configurações são ideais para cenários como:

• Compilando grandes bases de código com arquivos de origem extensos.
• Executando conjuntos de testes abrangentes, incluindo integração e testes de ponta a ponta.
• Processando grandes conjuntos de dados para a análise de dados ou tarefas de aprendizado de máquina.
• Criando aplicativos com dependências complexas ou saídas binárias grandes.
• Executando simulações de alto desempenho ou modelagem computacional.
• Executando codificação de vídeo, renderização ou outros fluxos de trabalho de processamento multimídia.

Para usar um executor maior, especifique o rótulo de executor desejado no atributo runs-on do arquivo de fluxo de trabalho. Por exemplo, para usar um executor com 16 vCPUs e 64 GB de RAM, você definiria runs-on: ubuntu-latest-16core.

jobs:
  build:
    runs-on: ubuntu-latest-16core
    steps:
      - uses: actions/checkout@v2
      - name: Build project
        run: make build

Esses executores maiores mantêm a compatibilidade com fluxos de trabalho existentes, incluindo as mesmas ferramentas pré-instaladas que os executores padrão ubuntu-latest .

Para obter mais informações sobre tamanhos de executores para executores avançados, confira a documentação do GitHub

Gerenciar executores avançados

O GitHub fornece ferramentas para efetivamente gerenciar executores maiores, garantindo a utilização ideal de recursos e o gerenciamento de custos. Aqui estão alguns aspectos importantes do gerenciamento de corredores maiores:

Monitoramento do uso

Você pode monitorar o uso de executores avançados por meio da página de uso do GitHub Actions nas configurações do repositório ou da organização. Esta página fornece insights sobre o número de trabalhos executados, o tempo de execução total e os custos associados.

Gerenciar o acesso

Para controlar o acesso a executores maiores, você pode configurar políticas de repositório ou de nível de organização. Essa configuração garante que somente fluxos de trabalho autorizados ou equipes possam usar esses executores de alto recurso.

Gerenciamento de custos

Executores avançados geram custos extras com base no uso. Para gerenciar custos, considere as seguintes sugestões:

• Use executores avançados apenas para fluxos de trabalho que exigem recursos altos.
• Reduza o runtime otimizando fluxos de trabalho.
• Monitore os detalhes de cobrança regularmente para controlar as despesas.

Dimensionamento de fluxos de trabalho

Se os fluxos de trabalho exigirem o uso frequente de executores avançados, considere estratégias de escala, como:

• Uso de executores auto-hospedados para cargas de trabalho previsíveis.
• Separação de fluxos de trabalho em trabalhos menores para distribuir a carga entre os executores padrão.