Dependências de Jobs no GitHub Actions

Introdução

Em pipelines de CI/CD do mundo real, os fluxos de trabalho raramente são apenas uma única lista de etapas. Eles são frequentemente compostos por múltiplos "jobs" (tarefas) distintos que precisam ser executados em uma ordem específica.

Por exemplo, você pode ter um job de Build (Compilação) que compila seu código e um job de Deploy (Implantação) que o envia para um servidor. Você definitivamente não quer que o job de Deploy seja executado se o job de Build falhar, e você não pode executá-los ao mesmo tempo porque a implantação precisa dos artefatos compilados.

Neste laboratório, você dividirá seu fluxo de trabalho em dois jobs separados e usará a palavra-chave needs para impor uma dependência, garantindo que o job de deploy aguarde a conclusão bem-sucedida do job de build.

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

Definir um job de compilação (build)

Primeiro, vamos limpar nosso workflow existente para ter um build job focado. Simplificaremos a estratégia de matriz do laboratório anterior para maior clareza, voltando a uma única versão para manter o foco nas dependências de jobs.

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 a URL. Ela deve ser parecida com 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.

5. Navegue até o repositório clonado:

cd ~/project/github-actions-demo

6. Crie um novo arquivo de workflow .github/workflows/job-dependencies.yml usando o editor WebIDE. Você pode encontrar o arquivo no explorador de arquivos no lado esquerdo, em project/github-actions-demo/.github/workflows/.

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

name: Job Dependencies

on: [push]

8. Adicione a seção jobs e defina o job de build com seu executor (runner):

jobs:
  build:
    runs-on: ubuntu-latest

9. Adicione a seção steps. Primeiro, adicione a etapa de checkout para obter o código do repositório:

steps:
  - uses: actions/checkout@v4

10. Adicione a etapa de configuração do Node.js:

- name: Use Node.js
  uses: actions/setup-node@v4
  with:
    node-version: "20"

11. Adicione a etapa para instalar as dependências:

- name: Install dependencies
  run: npm install

12. Adicione a etapa para executar os testes:

- name: Run tests
  run: npm test

13. Adicione a etapa de build que cria o diretório de artefato e o arquivo:

- name: Build project
  run: |
    mkdir dist
    echo "Build artifact created at $(date)" > dist/build.txt

14. Finalmente, adicione a etapa de upload de artefato. Esta etapa é crucial porque salva a saída do build para que o próximo job possa usá-la:

- name: Upload build artifact
  uses: actions/upload-artifact@v4
  with:
    name: dist-files
    path: dist

Seu arquivo completo deve estar assim agora:

name: Job Dependencies

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test
      - name: Build project
        run: |
          mkdir dist
          echo "Build artifact created at $(date)" > dist/build.txt
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: dist-files
          path: dist

Explicação

• Removemos a estratégia matrix por simplicidade.
• Mantivemos a etapa Upload build artifact. Isso é crucial porque o próximo job precisará desses arquivos!

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

Definir um job de implantação (deploy) que necessita do build

Agora adicionaremos um segundo job chamado deploy. Este job deve ser executado somente se o build for bem-sucedido. Conseguimos isso usando needs: build.

1. Anexe o seguinte job deploy ao seu arquivo .github/workflows/job-dependencies.yml. Certifique-se de que ele esteja no mesmo nível de indentação que o build.

2. Comece adicionando a definição do job de deploy com seu runner e dependência:

deploy:
  runs-on: ubuntu-latest
  needs: build

A linha needs: build é crucial - ela informa ao GitHub Actions que este job depende da conclusão bem-sucedida do job build.

3. Adicione a seção de steps. Primeiro, adicione o step para baixar o artefato:

steps:
  - name: Download artifact
    uses: actions/download-artifact@v4
    with:
      name: dist-files
      path: dist

Isso baixa o artefato que foi carregado no job build. O name deve corresponder ao nome usado no step de upload.

4. Adicione o step de deploy:

- name: Deploy project
  run: |
    echo "Deploying project..."
    ls -R dist
    echo "Deployment successful!"

Este step simula um deploy listando os arquivos baixados.

2. A estrutura completa do seu arquivo deve ser assim:

name: Job Dependencies

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "20"
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test
      - name: Build project
        run: |
          mkdir dist
          echo "Build artifact created at $(date)" > dist/build.txt
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: dist-files
          path: dist

  deploy:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: dist-files
          path: dist
      - name: Deploy project
        run: |
          echo "Deploying project..."
          ls -R dist
          echo "Deployment successful!"

Explicação

• needs: build: Esta é a linha chave. Ela informa ao GitHub Actions que este job depende da conclusão bem-sucedida do job build.
• uses: actions/download-artifact@v4: Como os jobs são executados em máquinas virtuais diferentes, eles não compartilham sistemas de arquivos. Para obter a pasta dist criada no job build, devemos baixar o artefato que carregamos anteriormente.
• name: dist-files: Deve corresponder ao nome usado no step de upload.

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

Fazer commit, push e verificar a execução sequencial

Agora vamos verificar se os jobs são executados na ordem correta.

1. Certifique-se de estar no diretório do repositório:

cd ~/project/github-actions-demo

2. Prepare as alterações (Stage as mudanças):

git add .

3. Faça o commit das alterações:

git commit -m "Add deploy job with dependency on build"

4. 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 a autenticação. Siga estes passos detalhados:

1. Um popup 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 aviso.
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 fechará 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 web.
2. Clique na aba Actions.
3. Clique na execução de workflow mais recente.
4. Observe o gráfico de visualização. Você deverá ver dois círculos (jobs) conectados por uma linha.
   • O job build estará à esquerda.
   • O job deploy estará à direita.
5. Observe o progresso. Você notará que deploy permanecerá em estado "Pending" ou "Waiting" até que build fique verde (Success).
6. Assim que build terminar, deploy começará.
7. Clique nos logs do job deploy para ver a mensagem "Deploying project..." e a listagem de arquivos do artefato baixado.

Resumo

Neste laboratório, você aprendeu como orquestrar fluxos de trabalho (workflows) com múltiplos jobs no GitHub Actions. Você:

1. Criou jobs separados de build e deploy.
2. Usou a palavra-chave needs para definir uma dependência, garantindo que deploy seja executado somente após build.
3. Usou upload-artifact e download-artifact para passar dados (arquivos) entre esses jobs separados.

Este padrão é fundamental para construir pipelines de CI/CD robustos onde você deseja compilar uma vez e depois implantar em múltiplos ambientes (staging, produção) somente se as etapas anteriores forem bem-sucedidas.