Como faço para usar as Ações do GitHub para criar fluxos de trabalho para CI?

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

Para implementar esse processo, você aprende a:

• Crie um fluxo de trabalho a partir de um modelo.
• Evite a duplicação usando fluxos de trabalho reutilizáveis.
• Teste em relação a vários alvos.
• Separe os trabalhos de compilação e teste.

Criar um fluxo de trabalho a partir de 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 o módulo Automatizar tarefas de desenvolvimento usando o módulo Ações do GitHub.

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

Na página Escolha um fluxo de trabalho , você pode escolher entre vários tipos de modelos. Um exemplo é o modelo Node.js. O modeloNode.js instala Node.js e todas as dependências, cria o código-fonte e executa testes para diferentes versões do Node.js. Outro exemplo é o modelo de pacote 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, digite Node.js.

Nos resultados da pesquisa, no painel Node.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

Como visto no on atributo, este fluxo de trabalho de exemplo é executado em resposta a um push para o repositório ou quando uma solicitação pull é criada na ramificação principal.

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

O atributo runs-on especifica que, para o sistema operacional, o fluxo de trabalho é executado em ubuntu-latest. O node-version atributo especifica que há três compilações, uma para cada 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 ações/checkout@v3 do GitHub para obter o código do seu repositório numa máquina virtual (VM) e a ação ações/setup-node@v3 para configurar a versão correta de Node.js. Você especifica que deseja testar três versões do Node.js usando o ${{ matrix.node-version }} atributo . Esse atributo faz referência à matriz definida anteriormente. O atributo cache especifica um gerenciador de pacotes para armazenamento em 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 Executa um script de construção, se existir. npm test executa a estrutura de teste. Este modelo inclui as etapas de compilação e teste no mesmo trabalho.

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

• npm instalar
• npm executar
• de teste npm

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

Evite a duplicação usando fluxos de trabalho reutilizáveis

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

Os fluxos de trabalho reutilizáveis são fluxos de trabalho especiais do GitHub Actions que outros fluxos de trabalho podem chamar, semelhantes a funções de programação. Você os cria para compartilhar lógica repetida, como etapas de compilação, procedimentos de teste ou estratégias de implantação. Depois de criar um fluxo de trabalho reutilizável, você pode fazer referência a ele a partir 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 de usar fluxos de trabalho reutilizáveis:

• Consistência. As equipes podem 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ê o atualiza em um local. Em seguida, todos os fluxos de trabalho que usam o fluxo de trabalho se beneficiam automaticamente.
• Escalabilidade. Os 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 testes, 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 fluxos de trabalho principais (fluxos de trabalho de chamadores), faça referência a esse arquivo reutilizável e forneça todas as entradas ou segredos necessários.

Para ilustrar as vantagens dos fluxos de trabalho reutilizáveis, considere o seguinte cenário do mundo real.

Exemplo

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

• Executar testes
• Código de lint
• Implantar em um determinado ambiente

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ê usa 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 o ambiente ou o nome do aplicativo.

Se uma nova etapa ou ferramenta de segurança for adicionada, como para verificar vulnerabilidades, adicione-a apenas uma vez no fluxo de trabalho reutilizável. Todos os 10 microsserviços começam imediatamente a usar o processo atualizado. Não é necessário 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 uma integração perfeita com seus pipelines de CI/CD.

Melhores práticas

• Centralize seus fluxos de trabalho reutilizáveis em um repositório se você planeja compartilhá-los entre equipes.
• Use ramificações ou tags para criar versões de seus fluxos de trabalho (por exemplo, usar @v1), para que você possa reverter facilmente as alterações, se necessário.
• Documente entradas e segredos de forma clara. Os 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. Quer esteja a gerir um único repositório, microsserviços ou bibliotecas de código aberto, os fluxos de trabalho reutilizáveis podem simplificar a automatização, para que o seu CI/CD seja mais rápido, mais limpo e mais fácil de gerir.

Personalizar modelos de fluxo de trabalho

No início deste módulo, você considerou um cenário no qual você precisa configurar a CI para sua equipe de desenvolvedores. O modelo Node.js é um ótimo começo, mas você quer personalizá-lo para melhor atender às necessidades da sua equipe. Você deseja direcionar versões diferentes do Node.js e sistemas operacionais diferentes. Você também deseja que as etapas de compilação 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 compilação para teste em vários sistemas operacionais e versões de idioma. Essa matriz produz quatro compilações, uma para cada sistema operacional emparelhado com cada versão do Node.js.

Quatro compilações e seus testes produzem uma grande quantidade de dados de log. Pode ser difícil resolver tudo. No exemplo a seguir, você move a etapa de teste para um trabalho de teste dedicado. Este trabalho testa em relação a múltiplas metas. Separar as etapas de compilação 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