Como Colocar um Projeto Java em um Contêiner Docker com Docker Compose

Este guia mostra como configurar um projeto Java com banco de dados PostgreSQL em contêineres Docker. Vamos usar o Dockerfile para definir a imagem do contêiner do aplicativo Java e o docker-compose.yml para orquestrar o aplicativo e o banco de dados.

Estrutura do Projeto

Aqui está a estrutura de diretórios esperada para o projeto:

/seu-projeto
├── Dockerfile
├── docker-compose.yml
├── target/
│   └── hurr-0.0.1-SNAPSHOT.jar
├── sql/
│   └── seus-scripts.sql

1. Dockerfile para Configurar o Contêiner Java

Primeiro, vamos analisar o Dockerfile para o contêiner Java, que será responsável por executar o aplicativo:

# Usando uma imagem do JDK 21 da Amazon Corretto como base
FROM amazoncorretto:21

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando o JAR da aplicação para o contêiner
COPY target/hurr-0.0.1-SNAPSHOT.jar /app/app.jar

# Copiando todos os scripts SQL para o diretório /app/sql no contêiner
COPY sql/ /app/sql/

# Variável de ambiente para o tempo de execução Java
ENV JAVA_OPTS=""

# Expondo a porta que a aplicação usa
EXPOSE 8080

# Comando para rodar a aplicação
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar"]

Explicação do Dockerfile

• Imagem Base: amazoncorretto:21 é usada como a base da imagem, fornecendo o JDK 21 necessário para rodar o aplicativo.
• Diretório de Trabalho: WORKDIR /app define /app como o diretório de trabalho dentro do contêiner.
• Cópia do JAR da Aplicação: COPY target/hurr-0.0.1-SNAPSHOT.jar /app/app.jar copia o arquivo JAR compilado para o contêiner.
• Cópia de Scripts SQL: COPY sql/ /app/sql/ copia todos os scripts SQL para o diretório /app/sql no contêiner, caso sejam necessários para inicializar o banco de dados.
• Variável de Ambiente: ENV JAVA_OPTS="" permite definir variáveis de execução Java para ajustes de memória e outros parâmetros de execução.
• Exposição de Porta: EXPOSE 8080 indica a porta que o aplicativo usará para se comunicar com o exterior.
• Comando de Inicialização: ENTRYPOINT inicia a aplicação usando o comando java -jar /app/app.jar, aplicando as variáveis de ambiente JAVA_OPTS.

2. Arquivo docker-compose.yml para Orquestração

O arquivo docker-compose.yml define como os serviços do aplicativo Java e do banco de dados PostgreSQL interagem.

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - JAVA_OPTS=-Dspring.datasource.url=jdbc:postgresql://db:5432/hurr?currentSchema=hurr
      - SPRING_DATASOURCE_USERNAME=postgres
      - SPRING_DATASOURCE_PASSWORD=postgres
    ports:
      - "8080:8080"
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: hurr
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

Explicação do docker-compose.yml

1. Serviço app:
   • Build: build define que a imagem do serviço será construída a partir do Dockerfile na raiz do projeto.
   • Variáveis de Ambiente:
     • JAVA_OPTS: Configura o endereço do banco de dados db, o nome do banco (hurr), e o schema (hurr), além das credenciais de usuário e senha.
     • SPRING_DATASOURCE_USERNAME e SPRING_DATASOURCE_PASSWORD: Definem o usuário e a senha do banco de dados.
   • Portas: ports mapeia a porta 8080 do contêiner para 8080 na máquina host.
   • Depends_on: depends_on define que o serviço app só iniciará após o serviço db estar em execução.
2. Serviço db:
   • Imagem do PostgreSQL: postgres:15 usa uma imagem oficial do PostgreSQL na versão 15.
   • Variáveis de Ambiente: Configuram o nome do banco (POSTGRES_DB), o usuário (POSTGRES_USER) e a senha (POSTGRES_PASSWORD) para o banco de dados.
   • Portas: ports mapeia a porta 5432 do contêiner para 5432 no host, permitindo que o banco seja acessado localmente.
   • Volume: volumes cria um volume persistente (postgres-data) para armazenar dados do banco.
3. Volume postgres-data:
   • Esse volume garante que os dados do banco de dados persistam, mesmo se o contêiner for reiniciado.

3. Iniciando a Aplicação com Docker Compose

Para iniciar os contêineres do aplicativo Java e do banco de dados PostgreSQL, execute o seguinte comando:

docker-compose up --build

Esse comando cria e inicia os contêineres, exibindo os logs diretamente no terminal. A aplicação estará disponível em http://localhost:8080 e o banco de dados PostgreSQL estará disponível na porta 5432.

4. Verificando a Configuração

• Acessando a Aplicação: Acesse http://localhost:8080 para verificar se o aplicativo está rodando corretamente.
• Acessando o Banco de Dados: Você pode conectar-se ao banco PostgreSQL usando um cliente SQL e os seguintes parâmetros:
  • Host: localhost
  • Porta: 5432
  • Banco de Dados: hurr
  • Usuário: postgres
  • Senha: postgres

Conclusão

Com essa configuração, você tem um ambiente Docker completo para rodar um projeto Java com PostgreSQL. Esse setup facilita o desenvolvimento e a replicação do ambiente em outras máquinas. Além disso, o uso de variáveis de ambiente torna a configuração flexível e adaptável a diferentes ambientes, como desenvolvimento, testes e produção.