Builds de Matriz no GitHub Actions

GitBeginner
Pratique Agora

Introdução

Ao desenvolver software, é crucial garantir que seu código funcione corretamente em diferentes ambientes. Por exemplo, uma biblioteca Node.js deve ser testada em múltiplas versões do Node.js (ex: v18, v20, v22).

Em vez de criar jobs (tarefas) separados para cada versão, o GitHub Actions fornece uma Estratégia de Matriz (Matrix Strategy). Isso permite que você defina um conjunto de variáveis, e o GitHub Actions criará automaticamente um job para cada combinação dessas variáveis.

Neste laboratório, você atualizará seu workflow para executar seus testes em paralelo em três versões diferentes do Node.js.

Este laboratório baseia-se no repositório que você criou nos laboratórios anteriores. Você trabalhará com o repositório github-actions-demo.

Modificar o fluxo de trabalho para incluir a matriz de estratégia

A palavra-chave strategy é usada para configurar a matriz de compilação (build matrix). Definiremos uma matriz com uma única chave node-version.

  1. Na página do seu repositório GitHub para github-actions-demo, clique no botão verde Code.
  2. Certifique-se de que a aba HTTPS esteja selecionada e copie o URL. Deve ser algo como https://github.com/your-username/github-actions-demo.git.
  3. Abra o terminal no ambiente LabEx. O caminho padrão é ~/project.
  4. Use o comando git clone para baixar o repositório. Substitua your-username pelo seu nome de usuário real do GitHub.
cd ~/project
git clone https://github.com/your-username/github-actions-demo.git

Exemplo de Saída:

Cloning into 'github-actions-demo'...
remote: Enumerating objects: X, done.
remote: Counting objects: 100% (X/X), done.
remote: Total X (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (X/X), done.
  1. Navegue até o repositório clonado:
cd ~/project/github-actions-demo
  1. Crie um novo arquivo de workflow .github/workflows/matrix-build.yml usando o editor WebIDE. Você pode encontrar o arquivo no explorador de arquivos à esquerda, em project/github-actions-demo/.github/workflows/.

  2. Comece criando a estrutura básica do workflow. Adicione o nome do workflow e o gatilho (trigger):

name: Matrix Build

on: [push]
  1. Agora adicione a seção de jobs com uma estrutura básica de job de compilação:
jobs:
  build:
    runs-on: ubuntu-latest
  1. Adicione a estratégia de matriz (strategy). Esta é a parte chave que permite executar o job com múltiplas versões do Node.js:
strategy:
  matrix:
    node-version: [18, 20, 22]

Isso define uma variável de matriz node-version com três valores. O GitHub Actions criará um job separado para cada valor.

  1. Adicione a seção de passos (steps). Primeiro, adicione o passo de checkout:
steps:
  - uses: actions/checkout@v4
  1. Adicione o passo de configuração do Node.js. Observe como usamos ${{ matrix.node-version }} para referenciar o valor atual da matriz:
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}
  1. Adicione o passo para instalar as dependências:
- name: Install dependencies
  run: npm install
  1. Adicione o passo de compilação que cria o diretório de artefato:
- name: Build project
  run: |
    mkdir dist
    echo "This is the build artifact" > dist/build.txt
  1. Adicione o passo de teste:
- name: Run tests
  run: npm test
  1. Finalmente, adicione o passo de upload de artefato. Observe como o nome do artefato inclui a versão da matriz para tornar cada artefato exclusivo:
- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist

Seu arquivo completo deve agora se parecer com isto:

name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Explicação

  • strategy: Define a estratégia de compilação.
  • matrix: Define as variáveis da matriz.
  • node-version: Este é um nome de variável que escolhemos. Atribuímos a ele um array de valores [18, 20, 22]. O GitHub Actions executará o job build três vezes, uma para cada valor.
  • ${{ matrix.node-version }}: Esta sintaxe permite acessar o valor atual da matriz em seus passos.

Salve o arquivo (Ctrl+S ou Cmd+S) após fazer as alterações.

Atualizar setup-node e nome do artefato para usar o contexto da matriz

Definir a matriz é apenas metade da batalha; também precisamos instruir os passos a usar o valor atual da matriz. Fazemos isso usando o contexto ${{ matrix.node-version }}.

Também precisamos garantir que os artefatos enviados por cada trabalho paralelo tenham nomes exclusivos, caso contrário, eles se sobrescreverão.

  1. Em .github/workflows/matrix-build.yml, verifique se o passo Use Node.js utiliza a variável da matriz:
- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: ${{ matrix.node-version }}
  1. Verifique se o passo Upload build artifact inclui a versão da matriz no nome do artefato:
- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: build-assets-${{ matrix.node-version }}
    path: dist
  1. Seu arquivo de workflow completo deve se parecer com isto:
name: Matrix Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: |
          mkdir dist
          echo "This is the build artifact" > dist/build.txt
      - name: Run tests
        run: npm test
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-assets-${{ matrix.node-version }}
          path: dist

Salve o arquivo (Ctrl+S ou Cmd+S).

Fazer commit, push e observar os jobs paralelos

Vamos ver a matriz em ação, confirmando (commit) suas alterações no GitHub.

  1. Certifique-se de estar no diretório do repositório:
cd ~/project/github-actions-demo
  1. Prepare as alterações (Stage the changes):
git add .
  1. Confirme as alterações (Commit the changes):
git commit -m "Add matrix strategy for Node.js versions"
  1. Envie as alterações para o repositório remoto no GitHub:
git push

Nota sobre Autenticação:
Ao executar git push, o WebIDE solicitará automaticamente que você se autentique. Siga estas etapas detalhadas:

  1. Um pop-up aparecerá com a mensagem: "The extension 'GitHub' wants to sign in using GitHub." Clique em Allow.
  2. Uma nova notificação aparecerá. Clique em "Copy&Continue to GitHub" e, em seguida, clique em "Open" no próximo prompt.
  3. Faça login na sua conta do GitHub na janela do navegador que se abrir e insira o código de autorização que foi copiado. Após confirmar a autorização, a página será fechada automaticamente.
  4. Aguarde alguns segundos e você verá o terminal concluir com sucesso a operação de push.

Nota de Privacidade: O WebIDE solicitará acesso total à sua conta do GitHub para fins de autenticação. Você não precisa se preocupar com questões de privacidade - a VM LabEx será imediatamente destruída após você concluir o laboratório atual, e suas credenciais e informações de autorização não serão retidas.

Este processo de autenticação não requer configuração manual de nome de usuário ou Personal Access Token.

Verificação no GitHub

  1. Visite seu repositório no GitHub em um navegador da web.
  2. Clique na aba Actions.
  3. Clique na execução de fluxo de trabalho (workflow run) mais recente.
  4. Na barra lateral esquerda (ou na visualização principal do gráfico), você verá agora três jobs separados listados sob o grupo build:
    • build (18)
    • build (20)
    • build (22)
  5. Eles serão executados em paralelo (ou quase em paralelo). Você pode clicar em cada um para ver que o Use Node.js configurou a versão específica solicitada.
GitHub Actions matrix builds

Resumo

Neste laboratório, você aprendeu a usar a Estratégia de Matriz (Matrix Strategy) no GitHub Actions. Você:

  1. Definiu uma matriz com múltiplas versões do Node.js usando strategy: matrix.
  2. Atualizou suas etapas do workflow para usar dinamicamente a versão do contexto da matriz (${{ matrix.node-version }}).
  3. Garantiu que os nomes dos artefatos fossem exclusivos para cada job da matriz.

Este recurso poderoso permite validar seu projeto contra uma ampla gama de configurações com muito pouca duplicação de código.