Gerenciar fluxos de trabalhos complexos

Visão Geral

Este artigo descreve alguns dos recursos avançados de GitHub Actions que ajudam você a criar criar fluxos de trabalho mais complexos.

Armazenar segredos

Se os seus fluxos de trabalho usarem dados confidenciais, como senhas ou certificados, você pode salvá-los em GitHub como segredos e usá-los nos seus fluxos de trabalho como variáveis de ambiente. Isto significa que você poderá criar e compartilhar fluxos de trabalho sem ter de incorporar valores sensíveis diretamente no fluxo de trabalho de YAML.

Esta ação de exemplo demonstra como fazer referência a um segredo existente como uma variável de ambiente e enviá-lo como um parâmetro para um comando de exemplo.

jobs:
  example-job:
    runs-on: ubuntu-latest
    steps:
      - name: Retrieve secret
        env:
          super_secret: ${{ secrets.SUPERSECRET }}
        run: |
          example-command "$super_secret"

Para obter mais informações, consulte "Criar e armazenar segredos encriptados".

Criar trabalhos dependentes

Por padrão, os trabalhos do seu fluxo de trabalho são executadas em paralelo e ao mesmo tempo. Portanto, se você tem um trabalho que só deve ser executado após a conclusão de outro trabalho, você pode usar a palavra-chave needs para criar esta dependência. Se um dos trabalhos falhar, todos os trabalhos dependentes serão suprimidos. No entanto, se você precisa que os trabalhos continuem, você pode definir isso usando a declaração condicional se.

Neste exemplo, os trabalhos de configuração, criação e teste executados em série, com criação e teste sendo dependentes da conclusão bem-sucedida do trabalho que os precede:

jobs:
  setup:
    runs-on: ubuntu-latest
    steps:
      - run: ./setup_server.sh
  build:
    needs: setup
    runs-on: ubuntu-latest
    steps:
      - run: ./build_server.sh
  test:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - run: ./test_server.sh

Para obter mais informações, consulte jobs.<job_id>.needs.

Usar uma matriz de criação

Você pode usar uma matriz de criação se quiser que seu fluxo de trabalho execute testes em várias combinações de sistemas operacionais, plataformas e linguagens. A matriz de criação é criada usando a palavra-chave estratégia, que recebe as opções de compilação como um array. Por exemplo, essa matriz de criação irá executar o trabalho várias vezes, usando diferentes versões do Node.js:

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [6, 8, 10]
    steps:
      - uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node }}

Para obter mais informações, consulte >jobs.<job_id>.strategy.matrix.

Usar bancos de dados e contêineres de serviço

Se sua tarefa exigir um banco de dados ou serviço de cache, você poderá usar a palavra-chave serviços para criar um contêiner efêmero para hospedar o serviço; o contêiner resultante ficará disponível em todas as etapas do trabalho e será removido quando o trabalho for concluído. Este exemplo demonstra como um trabalho pode usar serviços para criar um contêiner postgres e, em seguida, usar o nó para conectar-se ao serviço.

jobs:
  container-job:
    runs-on: ubuntu-latest
    container: node:10.18-jessie
    services:
      postgres:
        image: postgres
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
      - name: Install dependencies
        run: npm ci
      - name: Connect to PostgreSQL
        run: node client.js
        env:
          POSTGRES_HOST: postgres
          POSTGRES_PORT: 5432

Para obter mais informações, consulte "Usar bancos de dados e contêineres de serviço".

Usar etiquetas para encaminhar fluxos de trabalho

Esse recurso ajuda você a atribuir tarefas a um executor hospedado específico. Se você quiser ter certeza de que um determinado tipo de executor irá processar seu trabalho, você pode usar etiquetas para controlar os locais onde os trabalhos são executados. Você pode atribuir etiquetas a um executor auto-hospedado, além de sua etiqueta padrão de auto-hospedado. Em seguida, você pode consultar essas etiquetas no seu fluxo de trabalho YAML, garantindo que o trabalho seja encaminhado de forma previsível. Os executores hospedados em GitHub têm etiquetas pré-definidas atribuídas.

Este exemplo mostra como um fluxo de trabalho pode usar etiquetas para especificar o executor obrigatório:

jobs:
  example-job:
    runs-on: [self-hosted, linux, x64, gpu]

Um fluxo de trabalho só é executado em um executor que possui todas as etiquetas na matriz runs-on. O trabalho irá preferencialmente para um executor auto-hospedado inativo com as etiquetas especificadas. Se não houver nenhum disponível e houver um corredor hospedado em GitHub com os rótulos especificados, o trabalho irá para um executor hospedado em GitHub.

Para aprender mais sobre etiquetas de executores auto-hospedados, consulte "Usando etiquetas com executores auto-hospedados". Para saber mais sobre Etiquetas de executores hospedados em GitHub, consulte "Executores e recursos de hardware compatíveis".

Usar um modelo do fluxo de trabalho

GitHub fornece modelos de fluxo de trabalho pré-configurados que você pode personalizar para criar o seu próprio fluxo de trabalho de integração contínua. GitHub Enterprise Server analisa seu código e mostra modelos de CI que podem ser úteis para o seu repositório. Por exemplo, se o seu repositório contiver o código Node.js, você verá sugestões para projetos Node.js. Você pode usar os modelos do fluxo de trabalho como um ponto de partida para criar o fluxo de trabalho personalizado ou usá-los como se apresentam.

Você pode navegar pela lista completa dos modelos de fluxo de trabalho no repositório actions/starter-workflows em sua instância do GitHub Enterprise Server.

1. No GitHub Enterprise Server, navegue até a página principal do repositório.
2. No nome do seu repositório, clique em Ações.
3. Caso o seu repositório tenha fluxos de trabalho existentes: No canto superior esquerdo, clique em Novo fluxo de trabalho.
4. Sob, nome do template que você gostaria de usar, clique em Configurar este fluxo de trabalho.

Próximas etapas

Para continuar aprendendo sobre GitHub Actions, consulte "Compartilhar fluxos de trabalho, segredos e executores com a sua organização".