Como é que o GitHub Actions automatiza as tarefas de desenvolvimento?

Aqui, apresentamos as ações e fluxos de trabalho do GitHub. Você aprende os tipos de ações que você pode usar e onde encontrá-las. Você também vê exemplos desses tipos de ações e como elas se encaixam em um fluxo de trabalho.

O GitHub diminui o tempo desde a ideia à implementação

O GitHub foi concebido para ajudar as equipas de programadores e engenheiros DevOps a criar e a implementar aplicações rapidamente. Há muitos recursos no GitHub que permitem essas eficiências, mas eles geralmente se enquadram em uma de duas categorias:

• Comunicação: Considere todas as maneiras pelas quais o GitHub facilita a comunicação de uma equipe de desenvolvedores sobre o projeto de desenvolvimento de software: revisões de código em solicitações 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 todas as etapas do processo de desenvolvimento de software, desde a integração até a entrega e a implantação. Ele até permite automatizar a adição de rótulos a pull requests e verificar se há problemas obsoletos e pull requests.

Quando combinados, esses recursos permitiram que milhares de equipes de desenvolvimento diminuíssem efetivamente o tempo necessário desde a ideia inicial até a implantação.

Use a automação do fluxo de trabalho para diminuir o tempo de desenvolvimento

Neste módulo, focamo-nos na automação. Vamos reservar um momento para 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 acontecer depois que o código é escrito, mas antes que você possa usar o código de forma confiável para a finalidade pretendida. Dependendo dos objetivos da sua organização, você provavelmente precisará executar uma ou mais das seguintes tarefas:

• Verifique se o código passa em todos os testes de unidade.
• Execute verificações de qualidade e conformidade do código para garantir que o código-fonte atenda aos padrões da organização.
• Verifique o código e suas dependências para problemas de segurança conhecidos.
• Crie o código integrando novo código-fonte de (potencialmente) vários contribuidores.
• Certifique-se de que o software passa nos testes de integração.
• Especifique a versão da nova compilação.
• Entregue os novos binários no local apropriado do sistema de arquivos.
• Implante os novos binários em um ou mais servidores.
• Determine se alguma dessas tarefas não passa e relate o problema ao indivíduo ou à equipe adequada para resolução.

O desafio é fazer essas tarefas de forma confiável, consistente e sustentável. Este processo é um trabalho ideal para a automação do fluxo de trabalho. Se você já confia no GitHub, provavelmente deseja configurar a automação do fluxo de trabalho usando as Ações do GitHub.

O que é o GitHub Actions?

As ações do GitHub são scripts empacotados para automatizar tarefas em um fluxo de trabalho de desenvolvimento de software no GitHub. Você pode configurar as Ações do GitHub para acionar fluxos de trabalho complexos que atendam às necessidades da sua organização. O gatilho pode acontecer sempre que os desenvolvedores verificam o novo código-fonte em uma ramificação específica, em intervalos cronometrados ou manualmente. O resultado é um fluxo de trabalho automatizado confiável e sustentável, que leva a uma diminuição significativa no tempo de desenvolvimento.

Onde pode encontrar o GitHub Actions?

As GitHub Actions são 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 você acha 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, para além dos GitHub Actions em destaque no separador Ações, pode:

• Procurar por GitHub Actions no GitHub Marketplace. O GitHub Marketplace permite-lhe descobrir e comprar ferramentas que estendem o fluxo de trabalho.
• Procurar projetos open-source. Por exemplo, a organização GitHub Actions apresenta muitos repositórios populares de código aberto contendo Ações do GitHub que você pode usar.
• Escreva os seus próprios GitHub Actions do zero. Você pode torná-los de código aberto ou até mesmo publicá-los no GitHub Marketplace.

Usando ações do GitHub de código aberto

Muitas ações do GitHub são de código aberto e estão disponíveis para quem quiser usá-las. No entanto, assim como com qualquer software de código aberto, você precisa verificá-los cuidadosamente antes de usá-los em seu projeto. Semelhante aos padrões recomendados da comunidade com software de código aberto, como incluir um LEIA-ME, código de conduta, arquivo de contribuição e modelos de problema, você pode seguir estas recomendações ao usar as Ações do GitHub:

• Analise o arquivo da ação para entradas e saídas action.yml e certifique-se de que o código faz o que diz que faz.
• 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.
• Verifique se a ação está verificada no GitHub Marketplace. Verificação significa que o GitHub aprovou o uso dessa ação. No entanto, você ainda deve revisá-lo antes de usá-lo.
• Inclua a versão da ação que você está usando especificando uma ref, SHA ou tag do Git.

Tipos de ações do GitHub

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

Com as ações de contentores, o ambiente faz parte do código da ação. Estas ações só podem ser executadas num ambiente Linux que o GitHub aloja. As ações de contêineres suportam múltiplas línguas diferentes.

As ações JavaScript não incluem o ambiente no código. Você precisa especificar o ambiente para executar essas ações. Você pode executar essas ações em uma VM (máquina virtual) na nuvem ou localmente. As ações JavaScript suportam ambientes Linux, macOS e Windows.

As ações compostas permitem combinar várias etapas do fluxo de trabalho em uma única ação. Por exemplo, você pode 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

Aqui está um exemplo de uma ação que executa um check-out git de um repositório. Esta ação, ações/checkout@v1, faz parte de uma etapa de um fluxo de trabalho. Esta etapa também compila o código Node.js que foi descarregado. De seguida, falaremos sobre fluxos de trabalho, tarefas 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 quer utilizar uma ação de contentor para executar o código contentorizado. A ação poderá ter o seguinte aspeto:

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 secção inputs. Aqui, você está obtendo o valor de uma variável chamada MY_NAME. Essa variável é definida no fluxo de trabalho que executa essa ação.

Na secção runs, observe que especifica docker no atributo uses. Ao definir esse valor, você precisa fornecer o caminho para o arquivo de imagem do Docker. Neste caso, Dockerfile. Não estamos abordando os detalhes do Docker aqui, mas se você quiser mais informações, confira o módulo Introdução aos contêineres do Docker .

A última secção, imagem corporativa, personaliza a ação no GitHub Marketplace se decidir publicá-la.

Pode encontrar uma lista completa dos metadados de ações em Sintaxe dos metadados do GitHub Actions.

O que é um fluxo de trabalho do GitHub Actions?

Um fluxo de trabalho de Ações do GitHub é um processo que você configura em seu repositório para automatizar tarefas do ciclo de vida de desenvolvimento de software, incluindo Ações do GitHub. Com um fluxo de trabalho, você pode criar, testar, empacotar, liberar e implantar qualquer projeto no GitHub.

Para criar um fluxo de trabalho, adicione ações a um ficheiro .yml no diretório .github/workflows no repositório do GitHub.

No exercício que se aproxima, o arquivo de fluxo de trabalho main.yml parece-se com o seguinte 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 on: atributo, seu valor é um gatilho para especificar quando esse fluxo de trabalho é executado. Aqui, ele dispara uma execução quando há um evento de push para o seu repositório. Você pode 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 a arquivos, tags ou alterações de ramificação específicos. O mapa poderá 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 é acionado para todas as categorias de atividades, a menos que você especifique o tipo ou tipos. Para obter uma lista abrangente de eventos e seus tipos de atividade, consulte: Eventos que acionam fluxos de trabalho na documentação do GitHub.

Um fluxo de trabalho deve ter, pelo menos, uma tarefa. Um trabalho é uma seção do fluxo de trabalho associada a um corredor. Um corredor pode ser hospedado no GitHub ou auto-hospedado, e o trabalho pode ser executado em uma máquina ou em um contêiner. Você especifica o corredor com o runs-on: atributo. Aqui, você está dizendo ao fluxo de trabalho para executar esse trabalho no ubuntu-latest.

Cada trabalho tem etapas a serem concluídas. No nosso exemplo, a etapa usa a ação actions/checkout@v1 para fazer o checkout do repositório. O que é interessante é o uses: ./action-a valor, que é o caminho para a ação de contentor que se cria num ficheiro action.yml.

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

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

Referenciando ações em fluxos de trabalho

Ao criar fluxos de trabalho no GitHub Actions, você pode fazer referência a 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 onde os fluxos de trabalho podem referenciar ações:

1. Uma imagem de contêiner do Docker publicada no Docker Hub
   Os fluxos de trabalho podem fazer referência a ações publicadas como imagens de contêiner do Docker no Docker Hub. 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 uses imagem do Docker no atributo da etapa do 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 maior segurança, use um SHA de confirmação completa ao fazer referência a ações, não apenas uma tag como @v3.
Isso garante que seu 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 fazer referência a ações armazenadas no mesmo repositório que seu 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 Ações do GitHub.

4. Um mercado empresarial
   Se sua organização usa o GitHub Enterprise, você pode fazer referência a ações do mercado privado da sua empresa. Estas ações são curadas e geridas pela sua organização, garantindo o cumprimento das normas internas. Por exemplo:

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

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

Corredores hospedados no GitHub versus corredores auto-hospedados

Mencionámos brevemente os corredores como estando associados a um trabalho. Um runner é simplesmente um servidor que tem o aplicativo runner 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 corredor hospedado no GitHub que está sendo executado no ubuntu-latest ambiente.

Quando se trata de corredores, há duas opções para escolher: corredores hospedados no GitHub ou corredores auto-hospedados. Se você usar um runner hospedado no GitHub, cada trabalho será executado em uma nova instância de um ambiente virtual. O tipo de corredor hospedado no GitHub que você define e, em seguida, runs-on: {operating system-version} especifica esse ambiente. Com corredores auto-hospedados, você precisa aplicar o rótulo auto-hospedado, seu sistema operacional e a arquitetura do sistema. Por exemplo, um corredor auto-hospedado com um sistema operativo Linux e arquitetura ARM32 seria parecido com a seguinte especificação: runs-on: [self-hosted, linux, ARM32].

Cada tipo de corredor tem seus benefícios, mas os corredores hospedados no GitHub oferecem uma maneira mais rápida e simples de executar seus fluxos de trabalho, embora com opções limitadas. Os corredores auto-hospedados são uma maneira altamente configurável de executar fluxos de trabalho em seu próprio ambiente local personalizado. Você pode executar executores auto-hospedados no local ou na nuvem. Você também pode usar corredores 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 software disponível em sua rede local e escolher um sistema operacional não oferecido por corredores hospedados no GitHub.

As ações do GitHub podem ter limites de uso

As Ações do GitHub têm alguns limites de uso, dependendo do seu plano GitHub e se o seu runner é hospedado pelo GitHub ou autogerido. Para obter mais informações sobre limites de uso, consulte Limites de uso, cobrança e administração na documentação do GitHub.

O GitHub hospedou corredores maiores

O GitHub oferece corredores maiores para fluxos de trabalho que exigem mais recursos. Esses corredores são hospedados no GitHub e fornecem maior CPU, memória e espaço em disco em comparação com os corredores padrão. Eles são projetados para lidar com fluxos de trabalho que consomem muitos recursos de forma eficiente, garantindo o desempenho ideal para tarefas exigentes.

Tamanhos e rótulos dos corredores

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

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

Para usar um executor maior, especifique a etiqueta desejada do executor no atributo runs-on do seu ficheiro de fluxo de trabalho. Por exemplo, para usar um corredor com 16 vCPUs e 64 GB de RAM, você deve definir 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 os 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 corredores para corredores maiores, consulte a documentação do GitHub

Gerir corredores maiores

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

Monitorização da utilização

Você pode monitorar o uso de corredores maiores através da página de uso de Ações do GitHub nas configurações do repositório ou da organização. Esta página fornece informações sobre o número de trabalhos executados, o tempo de execução total e os custos associados.

Gerir o acesso

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

Gestão de custos

Corredores maiores incorrem em custos extra com base no seu uso. Para gerir custos, considere as seguintes sugestões:

• Use executores maiores apenas para fluxos de trabalho que exigem elevados recursos.
• Reduza o tempo de execução otimizando fluxos de trabalho.
• Monitore os detalhes de faturamento regularmente para acompanhar as despesas.

Dimensionamento de fluxos de trabalho

Se seus fluxos de trabalho exigem o uso frequente de corredores maiores, considere estratégias de dimensionamento como:

• Usando corredores auto-hospedados para cargas de trabalho previsíveis.
• Dividir fluxos de trabalho em trabalhos menores para distribuir a carga entre executores padrão.