DEV Community: Erick Andrade

Execução de múltiplos contêiners com Docker Compose

Erick Andrade — Mon, 10 Mar 2025 23:04:52 +0000

Qual desenvolvedor nunca teve que subir uma aplicação em uma máquina virtual e teve que instalar algum banco de dados ou algum java da vida pra executar a aplicação.
Para evitar essas dores de cabeça geralmente é utilizado o Docker para iniciar um contêiner contendo um banco de dados ou algum servidor exemplo Tomcat.
Nesse artigo irei explicar como o Docker Compose pode facilitar sua vida e inicialização vários contêiners com algumas configurações bem simples.

O que é Docker Compose

Basicamente um ferramenta para gerenciar vários conteiners Docker, informando os serviços, dependências, volumes e etc.
Nesse tutorial vamos falar do simples, se é uma ferramenta que é pra facilitar, pra que complicar?

Configurações necessárias

Para isso é necessário ter o Docker Engine instalado na sua máquina, agora copie o código abaixo em um arquivo chamado docker-compose.yaml

Nosso código:

version: '3'

services:
  web:
    image: nginx
    volumes:
      - ./templates:/etc/nginx/templates/default.conf
    ports:
      - "8080:80"

Definimos o version que é a versão do formato do nosso código.
Definimos o services que são os conteiners que desejamos utilizar e dentro deles temos alguma configurações, como:
A imagem que está no DockerHub, volumes para persistir os dados do conteiner e ports para definir como iremos acessar aquele recurso.

Agora ao executar o comando docker compose up iremos baixar as imagens e iniciar os contêiners, agora se quisermos dar o mesmo comando e execucar em segundo plano fazemos assim docker compose up -d, para parar a execução no nosso terminal só dar um Ctrl+C ou quando executar em segundo plano docker compose stop.

Adicionando um banco de dados

Agora iremos adicionar um Postgres em nosso projeto pra isso copie o código:

version: '3'

services:
  web:
    image: nginx
    volumes:
      - ./templates:/etc/nginx/templates/default.conf
    ports:
      - "8080:80"
  db:
    image: postgres:latest
    restart: always
    environment:
      - POSTGRES_PASSWORD=123
    ports:
      - "5433:5432"

Com isso iremos iniciar um servidor nginx e um banco de dados em somente uma configuração, sem precisar ter instalado nada em nossas máquinas, apenas com a dockerização usando o Docker.

Imagem personalizadas

Para criar um conteiner com uma imagem personalizada é muito simples basta adicionar o atributo build e pronto, pode utilizar sua imagem de um Dockerfile no Compose.

Exemplo:

services:
  app:
    build: ./
    ports:
      - "8080:8080"
    container_name: app
    depends_on:
      - db
    environment:
      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/database
      - SPRING_DATASOURCE_USERNAME=root
      - SPRING_DATASOURCE_PASSWORD=123

Aqui no caso estou criando uma imagem de um projeto Spring Boot que depende de outra imagem que se chama db para ser executada corretamente.
Isso é tudo pra esse artigo, bem simples e rápido, caso deseje se aventurar no mundo do Docker Compose ou Docker acessa a documentação:
Documentação Docker Compose

Até a próxima!!!

Produzindo e ouvindo eventos com Spring Boot

Erick Andrade — Tue, 04 Mar 2025 15:42:28 +0000

Olá, nesse artigo irei mostrar uma pequena parte do mundo de arquitetura orientada a eventos, resumidamente utilizando Apache Kafka e Spring Boot.

Instalação do Apache Kafka

Para começar nosso projeto precisamos de um servidor Kafka rodando em nossa máquina, para isso iremos utilizar o Docker.

1. Baixar imagem do Apache Kafka

docker pull apache/kafka:3.9.0

2. Iniciar um container com a imagem

docker run -p 9092:9092 apache/kafka:3.9.0

Após isso você terá um container rodando na porta 9092

Começar nosso projeto

Para isso iremos criar o projeto no https://start.spring.io/.
Vamos instalar as dependências do Spring Web e Spring for Apache Kafka.

Recomendo utilizar o Offset Explorer para ver os tópicos e partições

Configurar produtor e consumidor em nosso Projeto

Aqui está o pulo do gato, o Spring fornece uma integração simplificada com o Apache Kafka, sem necessidade de realizar diversas configurações, claro que dependendo do cenário que você está será necessário ter algo mais personalizado.
O código abaixo será responsável por criar um tópico e as partições do mesmo:

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.TopicBuilder;

@Configuration
@EnableKafka
public class KafkaConfig {

    @Bean
    public NewTopic newTopic() {
        return TopicBuilder.name("topico")
                .partitions(1)
                .build();
    }

}

Criamos apenas um tópico com o nome "topico" e que tem apenas uma partições, caso queira criar vários tópicos será necessário criar um bean pra cada tópico.
Após isso já temos nosso tópico rodando e pronto para enviar eventos nele, agora no código abaixo iremos produzir e ouvir os eventos:

package br.com.kafka.kafka.controllers;

import br.com.kafka.kafka.models.Mensagem;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/mensagem")
public class MensagemController {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @PostMapping
    public void send(@RequestBody Mensagem mensagem) {
        kafkaTemplate.send("topico", mensagem.toString());
    }

    @KafkaListener(groupId = "group-1", topics = "topico")
    public void listener(ConsumerRecord<String, String > event) throws Exception {
        System.out.println(event.value());
    }


}

Com isso já podemos brincar com algo, realizar integrações entre sistemas, lembrando que para manter um broker de eventos é bem custoso, mas em compensação seu sistema terá uma disponibilidade maior e caso ter algum erro o seu usuário final não ficará sabendo.
Basicamente é isso pretendo explorar afundo em outros artigos, como criar configurações personalizadas, adicionar serialização e deserialização de JSON para facilitar o escuta de eventos.

Realmente vale aplicar Arquitetura Limpa?

Erick Andrade — Tue, 25 Feb 2025 22:42:13 +0000

Alguns dias decidi realizar um projeto bem simples e já que estava estudando arquitetura limpa, implementei utilizando esse tipo de arquitetura.
Basicamente a regra de negócio seria criar uma transferência bancaria de usuário para outro, ai que está, uma coisa simples que decidi complicar, esse tipo de sistema um simples MVC resolveria e me pouparia tempo para concluir.

Vamos lá primeiro precisamos entender pra que utilizar a arquitetura limpa...

Pense em um caso que você tenha uma regra de negócio utilizando JPA, clássico esquema de @Entity numa classe junto com as lógicas de regras de negócio e por acaso algum dia seu gerente diz que o cliente necessita de uma funcionalidade, por mais simples que seja você teria que mexer na classe de persistência e também na de domínio, pois ambas estão na mesma classe, a arquitetura limpa foi proposta pra contornar essas ocasiões, pois as regras de negócio não tem nenhuma ligação direta com o banco de dados pois estão a nível de aplicação, tem casos que usamos regras aplicadas ao banco de dados, mas ai que está, ambas agora estão em classes separadas sem depender de um e de outro.

Foi uma explicação bem rasa, pretendo escrever mais em outro post, mas voltando ao tema do post, decidi utilizar arquitetura limpa nesse projeto e o que eu poderia ter feito em 2 horas, demorei quase 4 horas, pense numa lógica assim:

Cliente faz transferência -> autoriza em uma api externa e a partir disso que o outro usuário recebe.

Isso em um simples serviço poderia ser feito facilmente somente utilizando uma classe com poucas funções.

O que aprendi com isso?
Antes de começar algum projeto, pense primeiro na sua arquitetura e no nível de complexidade que ele pode chegar, nesse meu caso como era uma simples task, poderia ser feito em um MVC e estaria pronto na metade do tempo.