Como usar o GitHub Actions para criar fluxos de trabalho para CI?

Lembre-se de que sua meta é automatizar o processo de compilação e publicação de código para que os recursos sejam atualizados sempre que um desenvolvedor adiciona uma alteração à base de código.

Para implementar esse processo, você aprenderá a:

• Crie um fluxo de trabalho com base em um modelo.
• Evite a duplicação usando fluxos de trabalho reutilizáveis.
• Teste em relação a vários destinos.
• Trabalhos de build e teste separados.

Criar um fluxo de trabalho com base em um modelo

Para criar um fluxo de trabalho, é comum começar usando um modelo. Um modelo tem trabalhos e etapas comuns pré-configurados para o tipo específico de automação que você está implementando. Se você não estiver familiarizado com fluxos de trabalho, trabalhos e etapas, confira as tarefas de desenvolvimento do Automamate usando o módulo GitHub Actions .

Na página principal do repositório GitHub, selecione Ações e selecione Novo fluxo de trabalho.

Na página Escolher um fluxo de trabalho , você pode escolher entre muitos tipos de modelos. Um exemplo é o modelo de Node.js. O modeloNode.js instala Node.js e todas as dependências, cria o código-fonte e executa testes para versões diferentes de Node.js. Outro exemplo é o modelo de pacote do Python , que instala o Python e suas dependências e, em seguida, executa testes, incluindo lint, em várias versões do Python.

Para começar com o modelo de fluxo de trabalho Node.js, na caixa de pesquisa, insiraNode.js.

Nos resultados da pesquisa, no painelNode.js , selecione Configurar.

Um node.js.yml arquivo para seu projeto é criado a partir do modelo:

name: Node.js CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14.x, 16.x, 18.x]

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
    - run: npm ci
    - run: npm run build --if-present
    - run: npm test

Conforme visto no atributo on, este fluxo de trabalho de exemplo é executado em resposta a um push para o repositório ou quando um pull request é criado no branch principal.

Esse fluxo de trabalho executa um trabalho, indicado pelo job atributo.

O runs-on atributo especifica que, para o sistema operacional, o fluxo de trabalho é executado em ubuntu-latest. O node-version atributo especifica que há três builds, um para Node.js versão 14.x, 16.x e 18.x. O matrix atributo é descrito em profundidade posteriormente no módulo.

jobs No atributo, as etapas usam a ação actions/checkout@v3 do GitHub Actions para transferir o código do seu repositório para uma máquina virtual (VM) e actions/setup-node@v3 para configurar a versão correta do Node.js. Especifique que deseja testar três versões de Node.js usando o ${{ matrix.node-version }} atributo. Esse atributo faz referência à matriz que você definiu anteriormente. O cache atributo especifica um gerenciador de pacotes para cache no diretório padrão.

A última parte desta etapa executa comandos que os projetos Node.js usam. O npm ci comando instala dependências do package-lock.json arquivo. npm run build --if-present executará um script de build se ele existir. npm test executa a estrutura de teste. Esse modelo inclui etapas de build e teste no mesmo trabalho.

Para saber mais sobre o npm, confira a documentação do npm:

• instalação do npm
• execução do npm
• teste do npm

Uma equipe de desenvolvedores pode se beneficiar do uso de fluxos de trabalho reutilizáveis para simplificar e padronizar as etapas de automação repetidas. Usando fluxos de trabalho reutilizáveis, você pode reduzir a redundância, melhorar a manutenção e garantir a consistência em seus pipelines de CI/CD (integração contínua/implantação contínua).

Evitar duplicação usando fluxos de trabalho reutilizáveis

À medida que a escala e os projetos das equipes crescem, é comum ver as mesmas etapas repetidas em vários arquivos de fluxo de trabalho. Essas etapas podem incluir check-out de código, instalação de dependência, teste e implantação. Esse tipo de duplicação não apenas desorganiza sua base de código, mas também aumenta o tempo de manutenção quando as alterações de código são necessárias. Fluxos de trabalho reutilizáveis resolvem esse problema permitindo que você defina a lógica de automação uma vez e chame a lógica de outros fluxos de trabalho.

Fluxos de trabalho reutilizáveis são fluxos de trabalho especiais do GitHub Actions que outros fluxos de trabalho podem chamar, semelhantes às funções na programação. Você os cria para compartilhar lógica repetida, como etapas de build, procedimentos de teste ou estratégias de implantação. Depois de criar um fluxo de trabalho reutilizável, você pode referenciá-lo de qualquer outro fluxo de trabalho no mesmo repositório ou até mesmo em repositórios diferentes.

Por que usar fluxos de trabalho reutilizáveis?

Estes são os benefícios do uso de fluxos de trabalho reutilizáveis:

• Consistência. O Teams pode seguir os mesmos padrões de automação em todos os projetos.
• Eficiência. Em vez de copiar e colar etapas, basta apontar para um fluxo de trabalho reutilizável.
• Atualizações mais fáceis. Quando um processo é alterado, por exemplo, adicionando uma etapa de teste, você a atualiza em um local. Em seguida, todos os fluxos de trabalho que utilizam o fluxo de trabalho se beneficiam automaticamente.
• Escalabilidade. Fluxos de trabalho reutilizáveis são ideais para equipes de plataforma ou DevOps que gerenciam vários serviços.

Em seguida, explore como usar fluxos de trabalho reutilizáveis para melhorar seus projetos.

Implementar fluxos de trabalho reutilizáveis

Para usar fluxos de trabalho reutilizáveis:

1. Na pasta do repositório, crie um fluxo de trabalho reutilizável. O arquivo inclui as etapas de automação que você deseja compartilhar, como etapas comuns envolvidas em teste, criação e implantação.
2. Habilite explicitamente um fluxo de trabalho para ser reutilizável configurando-o com o workflow_call evento.
3. Em seus principais fluxos de trabalho (fluxos de trabalho de chamador), faça referência a esse arquivo reutilizável e forneça quaisquer entradas ou segredos necessários.

Para ilustrar as vantagens dos fluxos de trabalho reutilizáveis, considere o cenário real a seguir.

Exemplo

Imagine que sua organização tenha 10 microsserviços. Todos os 10 microsserviços precisam das mesmas etapas para:

• Executar testes
• Código lint
• Implantar em um ambiente específico

Sem fluxos de trabalho reutilizáveis, cada repositório acaba duplicando a mesma lógica em vários arquivos de fluxo de trabalho, levando a etapas repetidas e manutenção mais difícil.

Se você usar fluxos de trabalho reutilizáveis:

• Você define o processo uma vez em um arquivo central (por exemplo, em ci-standard.yml).
• Você chama esse arquivo do próprio fluxo de trabalho de cada microsserviço, passando variáveis como ambiente ou o nome do aplicativo.

Se uma nova etapa ou ferramenta de segurança for adicionada, como verificar vulnerabilidades, você a adicionará apenas uma vez no fluxo de trabalho reutilizável. Todos os 10 microsserviços começam imediatamente a usar o processo atualizado. Você não precisa modificar os 10 microsserviços.

Ao entender como os fluxos de trabalho reutilizáveis funcionam e seus benefícios, você pode adotar práticas recomendadas para maximizar sua eficácia e garantir a integração perfeita com seus pipelines de CI/CD.

Práticas recomendadas

• Centralize seus fluxos de trabalho reutilizáveis em um repositório se você planeja compartilhá-los entre equipes.
• Use branches ou tags para versionar seus fluxos de trabalho (por exemplo, use @v1), para que você possa facilmente reverter as alterações, se necessário.
• Documente claramente as entradas e os segredos. Fluxos de trabalho reutilizáveis geralmente dependem de entradas e segredos. As equipes precisam saber quais informações usar.
• Se você precisar reutilizar apenas algumas etapas, combine fluxos de trabalho reutilizáveis com ações compostas em vez de criar um fluxo de trabalho completo.

Os fluxos de trabalho reutilizáveis são uma maneira poderosa de impor consistência, reduzir a duplicação e dimensionar as práticas de DevOps em qualquer equipe de engenharia. Se você estiver gerenciando um único repositório, microsserviços ou bibliotecas de software livre, fluxos de trabalho reutilizáveis podem simplificar a automação, de modo que sua CI/CD seja mais rápida, limpa e fácil de gerenciar.

Personalizar modelos de fluxo de trabalho

No início deste módulo, você considerou um cenário no qual precisa configurar a CI para sua equipe de desenvolvedores. O modelo de Node.js é um ótimo começo, mas você deseja personalizá-lo para atender melhor aos requisitos da sua equipe. Você deseja direcionar diferentes versões de Node.js e sistemas operacionais diferentes. Você também deseja que as etapas de build e teste sejam trabalhos separados.

Aqui está um exemplo de um fluxo de trabalho personalizado:

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest]
    node-version: [16.x, 18.x]

Neste exemplo, você configura uma matriz de build para teste em vários sistemas operacionais e versões de linguagem. Essa matriz produz quatro builds, um para cada sistema operacional emparelhado com cada versão do Node.js.

Quatro builds e seus testes produzem uma grande quantidade de dados de log. Pode ser difícil resolver tudo isso. No exemplo a seguir, você move a etapa de teste para um trabalho de teste dedicado. Esse trabalho testa em relação a vários destinos. Separar as etapas de build e teste facilita o trabalho com os dados de log.

test:
  runs-on: ${{ matrix.os }}
  strategy:
    matrix:
      os: [ubuntu-latest, windows-latest]
      node-version: [16.x, 18.x]
  steps:
  - uses: actions/checkout@v3
  - name: Use Node.js ${{ matrix.node-version }}
    uses: actions/setup-node@v3
    with:
      node-version: ${{ matrix.node-version }}
  - name: npm install, and test
    run: |
      npm install
      npm test
    env:
      CI: true