Docker e Kotlin: conteinerização de aplicações para desenvolvedores

Docker e Kotlin: conteinerização de aplicações

O desenvolvimento moderno em Kotlin cada vez mais exige o uso de conteinerização. O Docker permite empacotar a aplicação junto com todas as dependências em um ambiente isolado, o que garante o mesmo comportamento na máquina local do desenvolvedor, no servidor de teste e em produção. Neste artigo, vamos analisar como conteinerizar corretamente projetos Kotlin, usando as melhores práticas e exemplos de código.

Por que conteinerizar aplicações Kotlin?

Kotlin funciona sobre a JVM, portanto, as aplicações nele herdam todas as características do ecossistema Java. As principais vantagens da conteinerização:

• Reprodutibilidade do ambiente — evitamos problemas do tipo "funciona na minha máquina".
• Isolamento de dependências — versões do JDK, bibliotecas e utilitários do sistema são fixadas na imagem.
• Escalabilidade — contêineres são facilmente implantados em Kubernetes e outros orquestradores.
• Implantação rápida — imagens Docker são menores em tamanho do que máquinas virtuais.

Criação do Dockerfile para uma aplicação Kotlin

Vamos considerar um projeto típico em Kotlin usando Gradle. Nosso build.gradle.kts pode ser assim:

plugins {    kotlin("jvm") version "1.9.22"    application}

application {    mainClass.set("com.example.MainKt")}

dependencies {    implementation(kotlin("stdlib"))    // outras dependências}

Agora vamos criar o Dockerfile. A primeira opção é a construção em múltiplos estágios (multistage build), que separa a etapa de compilação da etapa de execução:

# Estágio de construçãoFROM gradle:8.5-jdk21 AS buildCOPY --chown=gradle:gradle . /home/gradle/srcWORKDIR /home/gradle/srcRUN gradle build --no-daemon

# Estágio de execuçãoFROM eclipse-temurin:21-jre-alpineWORKDIR /appCOPY --from=build /home/gradle/src/build/libs/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Vamos analisar os pontos-chave:

• gradle:8.5-jdk21 — imagem oficial com Gradle e JDK para construção.
• eclipse-temurin:21-jre-alpine — imagem leve do JRE no Alpine Linux (cerca de 80 MB).
• COPY --from=build — copiamos apenas o JAR compilado, excluindo fontes e cache do Gradle.
• EXPOSE 8080 — indicamos documentalmente a porta (não a abre automaticamente).

Para construir a imagem, execute:

docker build -t kotlin-app:latest .docker run -p 8080:8080 kotlin-app:latest

Otimização do tamanho da imagem

O tamanho da imagem é crítico para a velocidade de implantação. Aqui estão algumas técnicas para aplicações Kotlin:

1. Uso do jlink para criar um JRE personalizado

Se sua aplicação não usa todos os módulos do JDK, você pode criar um JRE mínimo:

# Estágio de construçãoFROM gradle:8.5-jdk21 AS buildCOPY . /appWORKDIR /appRUN gradle build --no-daemon

# Estágio de criação do JRE personalizadoFROM eclipse-temurin:21-jdk-alpine AS jre-builderRUN jlink \    --add-modules java.base,java.logging,java.naming,java.sql \    --strip-debug \    --no-man-pages \    --no-header-files \    --compress=2 \    --output /jre

# Estágio finalFROM alpine:3.19ENV JAVA_HOME=/jreENV PATH="${JAVA_HOME}/bin:${PATH}"COPY --from=jre-builder /jre /jreCOPY --from=build /app/build/libs/*.jar /app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "/app.jar"]

Esta abordagem reduz o tamanho da imagem de ~200 MB para ~40-50 MB.

2. Uso do Spring Boot layertools

Para projetos Spring Boot (com Kotlin), você pode dividir o JAR em camadas para cache do Docker:

# build.gradle.ktstasks.bootJar {    layered {        enabled = true    }}

No Dockerfile, copie as camadas separadamente,