Docker e Java: conteinerização de aplicações — guia completo

Introdução ao Docker e Java: por que a conteinerização está mudando o desenvolvimento

O desenvolvimento moderno de software é impensável sem conteinerização. O Docker se tornou o padrão de facto para empacotar, distribuir e executar aplicações. Para desenvolvedores Java, o uso do Docker resolve problemas-chave: "funciona na minha máquina" e as dificuldades com configuração de ambiente. Neste artigo, vamos abordar como conteinerizar aplicações Java, desde um simples arquivo JAR até um microsserviço complexo em Spring Boot.

O Docker permite isolar a aplicação junto com suas dependências (JVM, bibliotecas, utilitários do sistema) em um contêiner leve e portátil. Isso é especialmente importante para Java, onde a versão do JDK, as configurações de memória e as bibliotecas do sistema podem influenciar fortemente o comportamento do programa.

O que você aprenderá neste artigo

• Criação de Dockerfile para aplicações Java
• Otimização do tamanho das imagens
• Trabalho com projetos multimódulo Maven/Gradle
• Melhores práticas de segurança e desempenho

1. Fundamentos: criando um Dockerfile para uma aplicação Java

Vamos começar com um exemplo simples. Suponha que você tenha uma aplicação Java compilada em um arquivo JAR. Aqui está um Dockerfile mínimo que a empacotará em um contêiner:

# Usamos a imagem oficial do OpenJDKFROM openjdk:17-jdk-slim

# Definimos o diretório de trabalhoWORKDIR /app

# Copiamos o arquivo JAR para o contêinerCOPY target/myapp.jar app.jar

# Abrimos a porta que a aplicação escutaEXPOSE 8080

# Comando para execuçãoENTRYPOINT ["java", "-jar", "app.jar"]

Este Dockerfile faz três coisas simples: pega uma imagem base com JDK 17, copia o JAR compilado e o executa. No entanto, em projetos reais, essa abordagem não é eficiente — cada vez que o código é alterado, o Docker reconstrói toda a imagem, incluindo a cópia do JAR.

Build multi-estágio (Multi-stage build)

Para separar as etapas de compilação e execução, use Dockerfiles multi-estágio. Isso reduz a imagem final, excluindo ferramentas de compilação (Maven, Gradle, JDK para compilação).

# Estágio de compilaçãoFROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /buildCOPY pom.xml .RUN mvn dependency:go-offlineCOPY src ./srcRUN mvn clean package -DskipTests

# Estágio finalFROM openjdk:17-jdk-slimWORKDIR /appCOPY --from=builder /build/target/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

O primeiro estágio usa uma imagem Maven completa para compilação, o segundo usa uma imagem JRE mínima para execução. A imagem final pesa ~200 MB em vez de 700+ MB.

2. Otimização de imagens: reduzindo o tamanho e acelerando a compilação

Imagens grandes retardam a implantação e aumentam o tempo de carregamento. Aqui estão algumas técnicas para Java:

Use JLink para criar uma JRE mínima

A partir do Java 9, você pode criar uma JRE personalizada contendo apenas os módulos necessários. Isso reduz radicalmente o tamanho da imagem.

FROM openjdk:17-jdk-slim AS jre-builderRUN jlink \    --add-modules java.base,java.logging,java.sql \    --strip-debug \    --no-man-pages \    --no-header-files \    --compress=2 \    --output /jre

FROM debian:bookworm-slimCOPY --from=jre-builder /jre /jreWORKDIR /appCOPY target/myapp.jar app.jarENV PATH="/jre/bin:${PATH}"ENTRYPOINT ["java", "-jar", "app.jar"]

Essa imagem pode pesar apenas 40-60 MB em vez de 200+ MB.

Cache de camadas do Docker

O Docker armazena em cache cada camada. Para acelerar a compilação, coloque arquivos que raramente mudam (dependências) no início do Dockerfile e os que mudam com frequência (código fonte) no final.

FROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /build# Primeiro, copiamos apenas o pom.xml e baixamos as dependênciasCOPY pom.xml .RUN mvn dependency:go-offline# Em seguida, copiamos os fontes e compilamosCOPY src ./srcRUN mvn clean packag