Entendendo o GitHub Actions

Visão geral

GitHub Actions é uma plataforma de integração contínua e entrega contínua (CI/CD) que permite automatizar a sua compilação, testar e pipeline de implantação. É possível criar fluxos de trabalho que criam e testam cada pull request no seu repositório, ou implantar pull requests mesclados em produção.

GitHub Actions vai além de apenas DevOps e permite que você execute fluxos de trabalho quando outros eventos ocorrerem no seu repositório. Por exemplo, você pode executar um fluxo de trabalho para adicionar automaticamente as etiquetas apropriadas sempre que alguém cria um novo problema no repositório.

Você deve hospedar suas próprias máquinas virtuais do Linux, do Windows ou do macOS a fim de executar fluxos de trabalho para o sua instância do GitHub Enterprise Server. Os executores auto-hospedados podem ser físicos, virtuais, em um contêiner, no local ou em uma nuvem.

Para obter mais informações sobre como introduzir o GitHub Actions na sua empresa, confira "Apresentando o GitHub Actions à sua empresa".

Componentes de GitHub Actions

Você pode configurar um fluxo de trabalho do GitHub Actions a ser disparado quando um evento ocorrer no seu repositório, como a abertura de uma solicitação de pull ou a criação de um problema. Seu fluxo de trabalho contém um ou mais trabalhos que podem ser executados em ordem sequencial ou em paralelo. Cada trabalho será executado em um executor próprio de máquina virtual ou em um contêiner e tem uma ou mais etapas que executam um script definido por você ou uma ação, que é uma extensão reutilizável que pode simplificar o fluxo de trabalho.

Fluxos de trabalho

Um fluxo de trabalho é um processo automatizado configurável que executa um ou mais trabalhos. Os fluxos de trabalho são definidos por um arquivo YAML verificado no seu repositório e será executado quando acionado por um evento no repositório, ou eles podem ser acionados manualmente ou de acordo com um cronograma definido.

Os fluxos de trabalho são definidos no diretório .github/workflows em um repositório. Um repositório pode ter vários fluxos de trabalho, cada um dos quais pode executar um conjunto diferente de tarefas. Por exemplo, você pode ter um fluxo de trabalho para criar e testar pull requests, outro fluxo de trabalho para implantar seu aplicativo toda vez que uma versão for criada, e outro fluxo de trabalho que adiciona uma etiqueta toda vez que alguém abre um novo problema.

Você pode referenciar um fluxo de trabalho dentro de outro fluxo de trabalho. Para obter mais informações, confira "Reutilizar fluxos de trabalho".

Para obter mais informações sobre os fluxos de trabalho, confira "Usando fluxos de trabalho".

Eventos

Um evento é uma atividade específica em um repositório que aciona a execução de um fluxo de trabalho. Por exemplo, a atividade pode originar-se de GitHub quando alguém cria uma solicitação de pull request, abre um problema ou faz envio por push de um commit para um repositório. Além disso, é possível acionar um fluxo de trabalho para execução de acordo com um agendamento ao postar em uma API REST ou de forma manual.

Para ver uma lista completa dos eventos que podem ser usados para disparar fluxos de trabalho, confira Eventos que disparam fluxos de trabalho.

Trabalhos

Um trabalho é um conjunto de etapas em um fluxo de trabalho executado no mesmo executor. Cada etapa é um script de shell que será executado ou uma ação que será executada. As etapas são executadas em ordem e dependem uma da outra. Uma vez que cada etapa é executada no mesmo executor, você pode compartilhar dados de um passo para outro. Por exemplo, você pode ter uma etapa que compila a sua aplicação seguida de uma etapa que testa ao aplicativo criado.

Você pode configurar as dependências de um trabalho com outros trabalhos; por padrão, os trabalhos não têm dependências e são executados em paralelo um com o outro. Quando um trabalho leva uma dependência de outro trabalho, ele irá aguardar que o trabalho depeendente seja concluído antes que possa executar. Por exemplo, você pode ter vários trabalhos de criação para diferentes arquiteturas que não têm dependências, e um trabalho de pacotes que depende desses trabalhos. Os trabalhos de criação serão executados em paralelo e, quando todos forem concluídos com sucesso, o trabalho de empacotamento será executado.

Para obter mais informações sobre trabalhos, confira "Usando trabalhos".

Ações

Uma ação é um aplicativo personalizado para a plataforma GitHub Actions que executa uma tarefa complexa, mas frequentemente repetida. Use uma ação para ajudar a reduzir a quantidade de código repetitivo que você grava nos seus arquivos de fluxo de trabalho. Uma ação pode extrair o seu repositório git de GitHub, configurar a cadeia de ferramentas correta para seu ambiente de criação ou configurar a autenticação para seu provedor de nuvem.

Você pode gravar suas próprias ações, ou você pode encontrar ações para usar nos seus fluxos de trabalho em GitHub Marketplace.

Para compartilhar ações na empresa sem publicá-las publicamente, armazene as ações em um repositório interno e configure o repositório para permitir o acesso aos fluxos de trabalho do GitHub Actions em outros repositórios pertencentes à mesma organização ou a outras organizações da empresa. Para obter mais informações, confira "Compartilhando ações e fluxos de trabalho com sua empresa".

Para obter mais informações, confira "Criar ações".

Executores

Um executor é um servidor que executa seus fluxos de trabalho quando são acionados. Cada executor pode executar uma tarefa por vez. Você deve hospedar seus próprios executores para GitHub Enterprise Server. Para obter mais informações, confira "Hospedar seus próprios executores".

Criar um exemplo de fluxo de trabalho

GitHub Actions usa a sintaxe do YAML para definir o fluxo de trabalho. Cada fluxo de trabalho é armazenado como um arquivo YAML separado no seu repositório de código, em um diretório chamado .github/workflows.

Você pode criar um exemplo de fluxo de trabalho no repositório que aciona automaticamente uma série de comandos sempre que o código for carregado. Nesse fluxo de trabalho, GitHub Actions verifica o código enviado, instala a estrutura de teste bats e executa um comando básico para gerar a versão bats:bats -v.

1. No repositório, crie o diretório .github/workflows/ para armazenar os arquivos de fluxo de trabalho.

2. No diretório .github/workflows/, crie um arquivo chamado learn-github-actions.yml e adicione o código a seguir.

   YAML

   name: learn-github-actions
   run-name: ${{ github.actor }} is learning GitHub Actions
   on: [push]
   jobs:
     check-bats-version:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v4
         - uses: actions/setup-node@v4
           with:
             node-version: '14'
         - run: npm install -g bats
         - run: bats -v
   

3. Faça commit dessas alterações e faça push para o seu repositório do GitHub.

Seu novo arquivo de fluxo de trabalho de GitHub Actions agora está instalado no seu repositório e será executado automaticamente toda vez que alguém fizer push de uma alteração no repositório. Para conferir os detalhes sobre o histórico de execução de um fluxo de trabalho, confira "Exibir a atividade de uma execução de fluxo de trabalho".

Entender o arquivo de fluxo de trabalho

Para ajudar você a entender como a sintaxe de YAML é usada para criar um arquivo de fluxo de trabalho, esta seção explica cada linha do exemplo Introdução:

# Optional - The name of the workflow as it will appear in the "Actions" tab of the GitHub repository. If this field is omitted, the name of the workflow file will be used instead.
name: learn-github-actions
# Optional - The name for workflow runs generated from the workflow, which will appear in the list of workflow runs on your repository's "Actions" tab. This example uses an expression with the `github` context to display the username of the actor that triggered the workflow run. For more information, see "[AUTOTITLE](/actions/using-workflows/workflow-syntax-for-github-actions#run-name)."
run-name: ${{ github.actor }} is learning GitHub Actions

# Specifies the trigger for this workflow. This example uses the `push` event, so a workflow run is triggered every time someone pushes a change to the repository or merges a pull request.  This is triggered by a push to every branch; for examples of syntax that runs only on pushes to specific branches, paths, or tags, see "[AUTOTITLE](/actions/reference/workflow-syntax-for-github-actions#onpushpull_requestpull_request_targetpathspaths-ignore)."
on: [push]

# Groups together all the jobs that run in the `learn-github-actions` workflow.
jobs:

# Defines a job named `check-bats-version`. The child keys will define properties of the job.
  check-bats-version:

# Configures the job to run on the latest version of an Ubuntu Linux runner. This means that the job will execute on a fresh virtual machine hosted by GitHub. For syntax examples using other runners, see "[AUTOTITLE](/actions/reference/workflow-syntax-for-github-actions#jobsjob_idruns-on)"
    runs-on: ubuntu-latest

# Groups together all the steps that run in the `check-bats-version` job. Each item nested under this section is a separate action or shell script.
    steps:

# The `uses` keyword specifies that this step will run `v4` of the `actions/checkout` action. This is an action that checks out your repository onto the runner, allowing you to run scripts or other actions against your code (such as build and test tools). You should use the checkout action any time your workflow will use the repository's code.
      - uses: actions/checkout@v4

# This step uses the `actions/setup-node@v4` action to install the specified version of the Node.js. (This example uses version 14.) This puts both the `node` and `npm` commands in your `PATH`.
      - uses: actions/setup-node@v4
        with:
          node-version: '14'

# The `run` keyword tells the job to execute a command on the runner. In this case, you are using `npm` to install the `bats` software testing package.
      - run: npm install -g bats

# Finally, you'll run the `bats` command with a parameter that outputs the software version.
      - run: bats -v

name: learn-github-actions

run-name: ${{ github.actor }} is learning GitHub Actions

on: [push]

jobs:

  check-bats-version:

    runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '14'

      - run: npm install -g bats

      - run: bats -v

# Optional - The name of the workflow as it will appear in the "Actions" tab of the GitHub repository. If this field is omitted, the name of the workflow file will be used instead.
name: learn-github-actions
# Optional - The name for workflow runs generated from the workflow, which will appear in the list of workflow runs on your repository's "Actions" tab. This example uses an expression with the `github` context to display the username of the actor that triggered the workflow run. For more information, see "[AUTOTITLE](/actions/using-workflows/workflow-syntax-for-github-actions#run-name)."
run-name: ${{ github.actor }} is learning GitHub Actions

# Specifies the trigger for this workflow. This example uses the `push` event, so a workflow run is triggered every time someone pushes a change to the repository or merges a pull request.  This is triggered by a push to every branch; for examples of syntax that runs only on pushes to specific branches, paths, or tags, see "[AUTOTITLE](/actions/reference/workflow-syntax-for-github-actions#onpushpull_requestpull_request_targetpathspaths-ignore)."
on: [push]

# Groups together all the jobs that run in the `learn-github-actions` workflow.
jobs:

# Defines a job named `check-bats-version`. The child keys will define properties of the job.
  check-bats-version:

# Configures the job to run on the latest version of an Ubuntu Linux runner. This means that the job will execute on a fresh virtual machine hosted by GitHub. For syntax examples using other runners, see "[AUTOTITLE](/actions/reference/workflow-syntax-for-github-actions#jobsjob_idruns-on)"
    runs-on: ubuntu-latest

# Groups together all the steps that run in the `check-bats-version` job. Each item nested under this section is a separate action or shell script.
    steps:

# The `uses` keyword specifies that this step will run `v4` of the `actions/checkout` action. This is an action that checks out your repository onto the runner, allowing you to run scripts or other actions against your code (such as build and test tools). You should use the checkout action any time your workflow will use the repository's code.
      - uses: actions/checkout@v4

# This step uses the `actions/setup-node@v4` action to install the specified version of the Node.js. (This example uses version 14.) This puts both the `node` and `npm` commands in your `PATH`.
      - uses: actions/setup-node@v4
        with:
          node-version: '14'

# The `run` keyword tells the job to execute a command on the runner. In this case, you are using `npm` to install the `bats` software testing package.
      - run: npm install -g bats

# Finally, you'll run the `bats` command with a parameter that outputs the software version.
      - run: bats -v

Visualizar o arquivo de fluxo de trabalho

Neste diagrama, você pode ver o arquivo de fluxo de trabalho que acabou de criar e como os componentes de GitHub Actions estão organizados em uma hierarquia. Cada etapa executa uma única ação ou script do shell. As etapas 1 e 2 executam ações, enquanto as etapas 3 e 4 executam scripts de shell. Para encontrar mais ações predefinidas para seus fluxos de trabalho, confira "Procurar e personalizar ações".

Exibir a atividade para uma execução de fluxo de trabalho

Quando seu fluxo de trabalho é acionado, é criada uma execução de fluxo de trabalho que executa o fluxo de trabalho. Após o início de uma execução de fluxo de trabalho, você pode ver um gráfico de visualização do progresso da execução e visualizar a atividade de cada etapa em GitHub.

1. No sua instância do GitHub Enterprise Server, navegue até a página principal do repositório.

2. No nome do repositório, clique em Ações.

   

3. Na barra lateral esquerda, clique no fluxo de trabalho que deseja ver.

   

4. Na lista de execuções de fluxo de trabalho, clique no nome da execução para ver o resumo da execução do fluxo de trabalho.

5. Na barra lateral esquerda ou no grafo de visualização, clique no trabalho que deseja ver.

6. Para ver os resultados de uma etapa, clique na etapa.

Próximas etapas

O GitHub Actions pode ajudá-lo a automatizar quase todos os aspectos dos processos de desenvolvimento do seu aplicativo. Pronto para começar? Aqui estão alguns recursos úteis para dar seus próximos passos com GitHub Actions:

• Para conhecer uma maneira rápida de criar um fluxo de trabalho do GitHub Actions, consulte "Usando fluxos de trabalho iniciais".
• Para fluxos de trabalho de CI (integração contínua) para criar e testar seu código, confira "Automatizando criações e testes".
• Para compilar e publicar pacotes, confira "Publicando pacotes".
• Para implantar projetos, confira "Implantação".
• Para automatizar tarefas e processos em GitHub, confira "Gerenciar problemas e pull requests".
• Para obter exemplos que demonstram recursos mais complexos do GitHub Actions, incluindo muitos dos casos de uso acima, confira " Exemplos". Você pode ver exemplos detalhados que explicam como testar o seu código em um executor, acessar a CLI do GitHub e usar recursos avançados, como simultaneidade e matrizes de teste.

Leitura adicional

• "Sobre o GitHub Actions para empresas"