Criação de artefatos

Introdução

No laboratório anterior, você aprendeu sobre controle de qualidade (CI). Agora, vamos para a próxima etapa: empacotamento.

Imagine o software como um produto em uma fábrica. Depois de passar por todos os testes de qualidade, ele precisa ser colocado em uma caixa, lacrado e etiquetado antes de ser enviado aos clientes. No mundo do software, essa “caixa” geralmente é um contêiner Docker.

Chamamos esse resultado empacotado de artefato. Depois de criados, os artefatos precisam ser armazenados em um registry para que as etapas posteriores, como a implantação, possam recuperar exatamente o mesmo build.

Essa reprodutibilidade é a ideia central. A implantação deve usar um produto de build conhecido, e não recriar o código de forma diferente em cada máquina de destino.

O GitHub fornece um registry chamado GitHub Container Registry (GHCR).

Neste laboratório, você ensinará seu assistente robótico a:

• Empacotar sua aplicação em um contêiner Docker.
• Etiquetá-la com uma tag de versão.
• Enviar (push) o contêiner automaticamente para o armazém do GitHub.

Pré-requisitos

Continuaremos usando o repositório github-actions-basics.

Criar um Dockerfile

Antes que o robô possa empacotar sua aplicação, ele precisa de instruções. No Docker, essas instruções são escritas em um arquivo especial chamado Dockerfile.

Navegue até o diretório do projeto.

cd ~/project
git clone https://github.com/your-username/github-actions-basics.git
cd github-actions-basics

Observação: substitua your-username pelo seu nome de usuário real do GitHub.

Crie um arquivo chamado Dockerfile (com “D” maiúsculo e sem extensão) usando o conteúdo a seguir.

cat > Dockerfile << EOF
FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "index.js"]
EOF

Veja exatamente o que essa lista de empacotamento instrui o robô a fazer:

• FROM node:16-alpine: começa com um sistema base leve que já tem o Node.js instalado.
• WORKDIR /app: cria uma pasta de trabalho dentro da caixa.
• COPY ...: copia os arquivos do projeto para dentro da caixa.
• RUN npm install: instala as dependências necessárias dentro da caixa.
• CMD ...: quando alguém abre (executa) essa caixa, inicia a aplicação.

Agora, adicione esse arquivo ao seu repositório e faça push para o GitHub.

git add Dockerfile
git commit -m "Add Dockerfile"
git push

Criar o workflow de publicação

Agora criaremos um novo workflow para cuidar do empacotamento e do envio. Vamos chamá-lo de docker-publish.yml.

Crie o arquivo:

touch .github/workflows/docker-publish.yml

Abra o arquivo com o nano.

nano .github/workflows/docker-publish.yml

Adicione a configuração a seguir. Estamos introduzindo um novo conceito chamado permissões.

name: Docker Publish

on:
  push:
    branches: ["master", "main"]

permissions:
  contents: read
  packages: write

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

Por que precisamos de permissões?

Por padrão, o robô tem acesso limitado por motivos de segurança. Como queremos que ele envie itens para sua conta do GitHub (a seção de “packages”), precisamos fornecer explicitamente uma chave para o armazém. É isso que packages: write faz.

Este é um bom exemplo do princípio do menor privilégio no design de pipelines. Os workflows devem receber somente as permissões necessárias para o trabalho que executam.

Salve e saia do nano (Ctrl+X, Y, Enter).

Adicionar as etapas de build e push

Agora vamos verificar a parte mais importante: o build e o push propriamente ditos.

Usaremos duas ferramentas oficiais (actions) da Docker:

1. docker/login-action: para entrar no armazém.
2. docker/build-push-action: para criar a caixa e enviá-la.

Esta etapa conecta CI e entrega. Depois que os testes passam, o pipeline cria um artefato versionado que outros sistemas podem implantar posteriormente sem recriar o código-fonte.

Abra novamente .github/workflows/docker-publish.yml.

nano .github/workflows/docker-publish.yml

Acrescente as etapas a seguir ao job build-and-push:

- name: Log in to the Container registry
  uses: docker/login-action@v2
  with:
    registry: ghcr.io
    username: ${{ github.actor }}
    password: ${{ secrets.GITHUB_TOKEN }}

- name: Build and push Docker image
  uses: docker/build-push-action@v4
  with:
    context: .
    push: true
    tags: ghcr.io/${{ github.repository }}/app:latest

Entendendo as variáveis mágicas:

• ghcr.io: é o endereço do “armazém” do GitHub.
• ${{ github.actor }}: é uma variável que preenche automaticamente seu nome de usuário do GitHub.
• ${{ secrets.GITHUB_TOKEN }}: é uma senha temporária especial que o GitHub cria para o robô. Você não precisa fazer nada: ela simplesmente funciona! Esse token permite que o robô faça login com segurança sem que você digite sua senha.
• tags: cria a etiqueta da sua caixa. Ela segue o formato: Endereço do armazém / Seu nome / Nome do repositório / Nome da aplicação : Versão.

Salve e saia do nano.

Agora, envie este workflow para o GitHub para iniciar o processo.

git add .
git commit -m "Add Docker publishing workflow"
git push

Verificar o artefato

Seu robô já está trabalhando. Ele está configurando um servidor, fazendo login, criando seu contêiner e enviando-o.

1. Acesse seu repositório no GitHub.
2. Clique na aba Actions.
3. Clique na execução do workflow “Docker Publish”.
4. Observe as etapas ficarem verdes.

Quando a etapa “Build and push Docker image” for concluída com sucesso, seu pacote estará no armazém. Vamos verificar.

1. Navegue até a página principal do seu repositório, na aba Code.
2. Observe a barra lateral direita. Você deverá ver uma seção chamada Packages.
3. Um novo pacote será exibido nessa seção!

Clique no nome do pacote para ver os detalhes. Esse é o artefato finalizado. Qualquer pessoa com acesso ao seu repositório (ou o público, se o repositório for público) poderá baixar e executar sua aplicação usando essa imagem.

Resumo

Neste laboratório, você criou um pipeline completo de entrega.

Você aprendeu:

• Empacotamento: como escrever um Dockerfile para colocar sua aplicação em um contêiner.
• Permissões: como conceder ao seu workflow acesso de escrita aos seus pacotes.
• Armazenamento: como usar o GitHub Container Registry (GHCR) para armazenar suas imagens.
• Automação: como criar e enviar seu código automaticamente usando actions padrão.

Agora, seu assistente robótico consegue verificar seu código (CI) e enviá-lo (artefatos). No próximo laboratório, veremos como lidar com informações confidenciais, como senhas, de forma segura.