Explorar trabalhos

Os jobs são os blocos de construção dos fluxos de trabalho do GitHub Actions. Cada trabalho é uma coleção de etapas que são executadas sequencialmente no mesmo executor, compartilhando o sistema de arquivos e as variáveis de ambiente.

Noções básicas sobre a execução do trabalho

Principais características dos trabalhos

• Etapas sequenciais: etapas em uma tarefa são executadas uma após a outra
• Ambiente compartilhado: todas as etapas compartilham o mesmo executor e sistema de arquivos
• Execução isolada: cada trabalho obtém um novo ambiente virtual
• Logs pesquisáveis: as saídas dos trabalhos são capturadas automaticamente e podem ser pesquisadas.
• Suporte a artefatos: Os trabalhos podem salvar e compartilhar arquivos entre execuções do fluxo de trabalho

Estrutura de trabalho básica

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

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

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

Execução paralela versus sequencial

Execução paralela (padrão)

Por padrão, vários trabalhos são executados simultaneamente para minimizar a duração do fluxo de trabalho:

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run linter
        run: npm run lint

  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Run tests
        run: npm test

  # Both lint and test jobs run simultaneously

Execução sequencial com dependências

Use a palavra-chave needs para criar dependências entre trabalhos.

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Build application
        run: ./build.sh

  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Run integration tests
        run: ./test.sh

  deploy:
    needs: [build, test] # Waits for multiple jobs
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: ./deploy.sh

Padrões de trabalho avançados

Estratégia de matriz para várias configurações

Execute trabalhos em vários ambientes simultaneamente:

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        node-version: [18, 20, 22]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm test

Execução condicional do trabalho

Execute trabalhos somente quando condições específicas forem atendidas:

jobs:
  deploy:
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: echo "Deploying to production"

  notify:
    needs: deploy
    if: failure() # Only runs if deploy job fails
    runs-on: ubuntu-latest
    steps:
      - name: Send failure notification
        run: echo "Deployment failed!"

Tratamento de falhas de trabalho

Comportamento padrão

• Se qualquer etapa falhar, o trabalho inteiro falhará
• Trabalhos dependentes não serão executados se seus pré-requisitos falharem
• O fluxo de trabalho está marcado como com falha

Gerenciando o comportamento de falha

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Run tests (continue on error)
        run: npm test
        continue-on-error: true

      - name: Upload test results
        if: always() # Runs regardless of previous step outcome
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: test-results.xml

Práticas recomendadas para trabalhos

• Manter os trabalhos focados: cada trabalho deve ter uma única responsabilidade
• Use nomes descritivos: Torne os propósitos dos trabalhos claros na interface do fluxo de trabalho
• Otimizar dependências: crie dependências apenas quando realmente necessário
• Escolha executores apropriados: combine o sistema operacional do executor com as necessidades da sua aplicação
• Lidar com falhas de forma controlada: Usar execução condicional e continuar em caso de erro estrategicamente
• Compartilhar dados com eficiência: usar artefatos ou saídas para passar dados entre trabalhos

Para obter opções abrangentes de configuração de trabalho, consulte Como usar trabalhos em um fluxo de trabalho.