GitHub Actions Executando Comandos Simples

Introdução

GitHub Actions é uma plataforma de integração contínua e entrega contínua (CI/CD) que permite automatizar seu pipeline de compilação, teste e implantação. Você pode criar fluxos de trabalho (workflows) que compilam e testam cada pull request no seu repositório, ou implantam pull requests mesclados (merged) em produção.

Um workflow é um processo automatizado configurável que executará um ou mais trabalhos (jobs). Os workflows são definidos por um arquivo YAML verificado (checked in) no seu repositório e serão executados quando acionados por um evento no seu repositório, ou podem ser acionados manualmente ou em uma programação definida.

Neste laboratório, você aprenderá os blocos de construção fundamentais de um workflow do GitHub Actions:

1. Definindo um trabalho (job).
2. Especificando o ambiente do executor (runner environment) (ex: Ubuntu).
3. Adicionando etapas (steps) para executar comandos.

Você criará um workflow simples que imprime "Hello, World!" no console. Este laboratório baseia-se no repositório que você criou nos laboratórios anteriores. Você clonará o repositório github-actions-demo e atualizará um arquivo de workflow existente.

Adicionar a chave runs-on com ubuntu-latest no job build

Nesta etapa, você clonará o repositório e atualizará um arquivo de fluxo de trabalho (workflow) existente para definir um job e especificar o sistema operacional em que ele deve ser executado.

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

5. Navegue até o repositório clonado:

cd ~/project/github-actions-demo

6. Crie um novo arquivo de fluxo de trabalho chamado simple-commands.yml no diretório .github/workflows:

touch .github/workflows/simple-commands.yml

7. Abra o arquivo .github/workflows/simple-commands.yml no WebIDE. Você pode encontrá-lo no explorador de arquivos no lado esquerdo.

8. Adicione o seguinte conteúdo ao arquivo para definir o nome do fluxo de trabalho, o gatilho (trigger), o job e o runner:

name: Simple Commands
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

A palavra-chave runs-on permite que você especifique o tipo de máquina em que o job será executado. O GitHub fornece runners hospedados para Linux, Windows e macOS. ubuntu-latest é um runner comumente usado que fornece um ambiente Ubuntu padrão.

Adicionar a seção steps sob o job build

Agora que você definiu o ambiente do job, você precisa definir o que o job realmente faz. Isso é feito usando a palavra-chave steps.

Um job contém uma sequência de tarefas chamadas steps. As etapas podem executar comandos, executar tarefas de configuração (setup tasks) ou executar uma ação no seu repositório.

Instruções

1. Abra o arquivo .github/workflows/simple-commands.yml no WebIDE.
2. Adicione a palavra-chave steps sob o job build.

Atualize seu arquivo para que fique assim:

name: Simple Commands
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:

Certifique-se de que steps: esteja no mesmo nível de indentação que runs-on:.

Adicionar um passo com nome 'Echo Hello' e executar echo "Hello, World!"

Nesta etapa, você adicionará múltiplas tarefas à seção steps para executar vários comandos shell. Isso demonstra que você pode executar comandos padrão do Linux no runner.

Instruções

1. Abra o arquivo .github/workflows/simple-commands.yml no WebIDE.
2. Adicione os seguintes passos sob a chave steps::

steps:
  - name: Echo Hello
    run: echo "Hello, World!"

  - name: Show Date
    run: date

  - name: List Files
    run: ls -la

Seu arquivo completo deve se parecer com isto:

name: Simple Commands
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Echo Hello
        run: echo "Hello, World!"

      - name: Show Date
        run: date

      - name: List Files
        run: ls -la

Explicação

• echo "Hello, World!": Imprime texto no console.
• date: Mostra a data e hora atuais no runner.
• ls -la: Lista os arquivos no diretório atual. Você notará que o diretório está quase vazio porque ainda não fizemos o checkout do código (faremos isso no próximo laboratório).

Fazer commit e push do arquivo de workflow atualizado

Os fluxos de trabalho (workflows) do GitHub Actions fazem parte do código do seu repositório. Para ativar o fluxo de trabalho, você precisa commitar as alterações e enviá-las (push) para o GitHub.

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

cd ~/project/github-actions-demo

2. Prepare (stage) o novo arquivo de fluxo de trabalho:

git add .github/workflows/simple-commands.yml

3. Commite as alterações com uma mensagem descritiva:

git commit -m "Add simple commands workflow"

Saída de Exemplo:

[main ... ] Add simple commands workflow
 1 file changed, 14 insertions(+)
 create mode 100644 .github/workflows/simple-commands.yml

4. Envie (push) as alterações para o repositório remoto no GitHub:

git push

Nota sobre Autenticação:
Quando você executa git push, o WebIDE solicitará automaticamente a autenticação. 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.

Saída de Exemplo:

Enumerating objects: 6, done.
Counting objects: 100% (6/6), done.
Delta compression using up to 4 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 447 bytes | 447.00 KiB/s, done.
Total 4 (delta 1), reused 0 (delta 0), pack-reused 0
To https://github.com/your-username/github-actions-demo.git
   abcdef1..1234567  main -> main

Visualizar os logs de execução do workflow na aba GitHub Actions

Após enviar (push) seu código, o fluxo de trabalho será acionado automaticamente no GitHub. Você pode visualizar os logs de execução do fluxo de trabalho para ver o que aconteceu.

1. Visite seu repositório no GitHub em um navegador da web: https://github.com/your-username/github-actions-demo
2. Clique na aba Actions no topo da página do repositório.
3. Você deverá ver uma execução de fluxo de trabalho listada, provavelmente nomeada como "Simple Commands" ou "Add simple commands workflow".

Nota: Ao enviar código, várias Actions podem ser acionadas se você tiver múltiplos arquivos de fluxo de trabalho em seu repositório. Por favor, identifique a execução correta do fluxo de trabalho verificando o nome do fluxo de trabalho na barra lateral esquerda ou usando a lista de execuções de fluxo de trabalho no lado direito.

4. Clique no título da execução do fluxo de trabalho e, em seguida, clique no job build.
5. Expanda os passos Echo Hello, Show Date e List Files para ver sua saída.

Você notará que List Files mostra um diretório vazio (exceto por arquivos ocultos como . e ..), demonstrando que o runner inicia com um ambiente limpo (clean slate).

Resumo

Neste laboratório, você criou com sucesso um fluxo de trabalho (workflow) do GitHub Actions que executa múltiplos comandos shell. Você aprendeu a:

1. Definir um Job: Você criou um job chamado build.
2. Selecionar um Executor (Runner): Você usou runs-on: ubuntu-latest.
3. Executar Múltiplos Comandos: Você adicionou etapas para executar echo, date e ls.
4. Observar o Ambiente do Executor: Você viu que o executor começa com um diretório vazio.

No próximo laboratório, você aprenderá a usar a Ação Checkout (Checkout Action) para acessar os arquivos do seu repositório dentro do executor.