Neste segundo tutorial da nossa série sobre Cloud e DevOps, avançamos no uso do Docker, explorando maneiras mais eficientes de executar aplicações por meio da orquestração com Docker Compose. Também aprendemos a integrar esse processo ao GitHub utilizando workflows automáticos com GitHub Actions, preparando o caminho para o deploy em nuvem. O foco aqui é a produtividade, a padronização e a portabilidade do ambiente de desenvolvimento.

Otimizando o Uso do Docker com Docker Compose

Na primeira parte da série, rodamos a aplicação com um comando extenso usando docker run. Agora, substituímos essa abordagem manual pela criação de um arquivo docker-compose.yml, que automatiza e simplifica o processo de build e execução da aplicação.

O Docker Compose permite descrever os serviços de uma aplicação usando YAML, o mesmo formato utilizado amplamente em DevOps (como em Kubernetes, Prometheus, entre outros). Com ele, é possível definir serviços, volumes, portas, variáveis de ambiente e dependências entre aplicações – tudo em um único arquivo.

Exemplo de estrutura simples do docker-compose.yml:

services:
  app:
    build: .
    container_name: imersao-api
    ports:
      - "8000:8000"
    volumes:
      - .:/app

Essa estrutura permite que o código fonte editado localmente seja refletido imediatamente no contêiner, sem necessidade de reiniciar o serviço, graças à montagem do volume .:/app.

Criando e Executando com Docker Compose

Com o arquivo YAML configurado, o comando necessário para subir o ambiente se resume a:

docker compose up

Esse comando compila a imagem (caso necessário) e sobe o contêiner em background ou com os logs visíveis, dependendo do uso da flag -d. Isso representa um grande ganho em relação ao processo anterior, que exigia múltiplos comandos de terminal, configuração de ambiente virtual, instalação de dependências e execução manual da aplicação.

Commit e Versionamento do Projeto

Com a aplicação funcional e o ambiente Docker pronto, o próximo passo é versionar o projeto e enviá-lo ao GitHub. A convenção de commits sugerida segue o modelo do Angular, com prefixos como feat, fix, entre outros. Por exemplo:

git commit -m "feat: adiciona Docker Compose ao repositório"

O projeto é então enviado ao GitHub via git push, já contendo os arquivos Dockerfile e docker-compose.yml, prontos para replicar o ambiente em qualquer máquina.

Integração Contínua com GitHub Actions

Em seguida, foi configurado um pipeline básico de integração contínua (CI) com GitHub Actions. A configuração está em um arquivo YAML no caminho .github/workflows/docker-image.yml. Esse pipeline é disparado automaticamente a cada push na branch main e executa a build da imagem Docker.

A Action utiliza um runner baseado em Ubuntu e realiza passos como:

• Verificação do push
• Build da imagem Docker com o Dockerfile
• Output da imagem com uma tag (que pode ser personalizada com hash de commit ou versão semântica)

Isso garante que toda atualização de código seja validada automaticamente, reduzindo erros e garantindo consistência para deploys futuros.

Boas Práticas: Versionamento e SemVer

Foi abordada também a importância de versionar imagens corretamente, evitando o uso da tag latest em produção. Recomenda-se seguir o padrão SemVer (Semantic Versioning), com versões major.minor.patch, o que facilita rollbacks e controle de mudanças.

Próximos Passos

Com a imagem construída e validada via GitHub Actions, o próximo passo será enviar essa aplicação para a nuvem – mais especificamente, para o Google Cloud. Para isso, foi apresentado o processo de resgate de créditos na plataforma, criação de projeto e ativação do faturamento.

Criando o Projeto na Google Cloud

Agora é necessário criar um projeto no console do Google Cloud, que será o destino do deploy da aplicação.

Etapas:

1. Acesse o console e clique em “Abrir seletor de projetos”.
2. Clique em “Novo Projeto”, dê um nome (ex: Alura-Imersao) e crie.
3. Após criado, clique sobre o projeto para selecioná-lo.
4. Em seguida, vá até a aba Faturamento e vincule os créditos ativados ao projeto. Selecione a conta de faturamento “de avaliação” e clique em “Definir conta”.

Após isso, o painel exibirá o valor disponível para o projeto, que pode ser usado para criar instâncias, serviços e realizar o deploy.

Finalizando a Preparação para o Deploy

Com os créditos ativos e o projeto criado, a estrutura para o deploy está pronta. O próximo passo – a ser abordado no próximo tutorial – será colocar no ar a aplicação que foi versionada e enviada ao GitHub, utilizando os serviços da Google Cloud, como o Artifact Registry ou o Cloud Run, tornando a API acessível de qualquer lugar da internet.

Recapitulando o que aprendemos neste tutorial

• Criamos um docker-compose.yml para orquestrar o build e a execução da aplicação com um único comando.
• Automatizamos o processo de CI com GitHub Actions.
• Versionamos e subimos o projeto no GitHub.
• Ativamos créditos gratuitos no Google Cloud.
• Criamos e configuramos um projeto na plataforma para receber a aplicação.
• Entendemos o papel do CI na consistência de builds e na produtividade do time DevOps.

Automatizando o Build com GitHub Actions

Uma das grandes vantagens do uso do GitHub em projetos DevOps é a possibilidade de criar pipelines de integração contínua (CI) com GitHub Actions, utilizando arquivos YAML que descrevem o passo a passo da automação.

No nosso projeto, configuramos um workflow chamado docker-image.yml, responsável por:

• Monitorar alterações (push ou pull_request) na branch main.
• Executar os passos para construir a imagem Docker da aplicação.
• Validar que a imagem foi construída com sucesso, sem a necessidade de rodar comandos manuais.

Esse processo ajuda a garantir que qualquer mudança feita no repositório principal gere uma nova versão da imagem de forma automática, reproduzível e rastreável.

Boas práticas aplicadas:

• Definição de etapas (steps) claras no YAML, como build, run, login.
• Separação lógica das fases de execução, facilitando a leitura por desenvolvedores e DevOps.
• Uso opcional de tags e versionamento semanticamente significativos (evitando latest em produção).
• Possibilidade de usar hash de commit, data, ou número de versão como parte do nome da imagem.

O Que Mais Podemos Fazer com Workflows?

Embora neste tutorial o foco tenha sido a criação e validação da imagem Docker, os workflows do GitHub Actions vão muito além:

• Rodar testes automatizados (unitários, de integração, de segurança).
• Executar análise estática de código.
• Escanear imagens Docker por vulnerabilidades.
• Efetuar deploys automáticos para ambientes como Docker Hub, Google Cloud ou AWS.
• Gerenciar pipelines CI/CD completas, desde o push até o deploy em produção.

Caminho para o Deploy

Com a imagem criada, validada e o projeto devidamente versionado no GitHub, além de termos o projeto no Google Cloud com os créditos ativados, estamos prontos para a etapa final desta trilogia de tutoriais: colocar a aplicação no ar com um link acessível publicamente.

Esse processo envolverá:

• Escolha de um serviço de deploy (Cloud Run, GKE, App Engine…).
• Autenticação com o Google Cloud.
• Push da imagem para o repositório de imagens (Artifact Registry).
• Configuração de variáveis e ambiente.
• Acesso via navegador com domínio público.

Conclusão do Tutorial Parte 2

Neste tutorial você aprendeu a:

Automatizar o build de sua aplicação com Docker Compose
Configurar workflows de CI com GitHub Actions
Utilizar boas práticas de versionamento e padronização
Criar um projeto no Google Cloud e ativar seus créditos
Preparar o ambiente para o deploy na nuvem

No próximo e último tutorial da série, vamos realizar o deploy completo da aplicação na Google Cloud, garantindo que ela funcione fora da sua máquina local, de forma segura e profissional.

The post Automatizando e Orquestrando Contêineres com Docker Compose e GitHub Actions – Tutorial Parte 2 first appeared on MCU & FPGA.