Docker y Kotlin: contenedorización de aplicaciones de la A a la Z

Docker y Kotlin: contenedorización de aplicaciones de la A a la Z

La contenedorización se ha convertido en el estándar de facto para el desarrollo moderno. Resuelve el problema de "en mi máquina funciona" y simplifica el CI/CD. En este artículo, analizaremos cómo contenedorizar eficazmente aplicaciones Kotlin con Docker, desde la creación de un Dockerfile simple hasta optimizaciones de producción y orquestación.

1. Fundamentos: Dockerfile para una aplicación Kotlin

El corazón de la contenedorización es el Dockerfile. Para aplicaciones Kotlin que se compilan a bytecode JVM, utilizamos la compilación en múltiples etapas (multi-stage build). Esto permite separar el entorno de compilación del entorno de ejecución, reduciendo el tamaño de la imagen final.

Consideremos una aplicación típica en Kotlin que utiliza Gradle (el archivo build.gradle.kts está simplificado):

// build.gradle.ktsplugins {    kotlin("jvm") version "1.9.0"    application    id("com.google.cloud.tools.jib") version "3.4.0" // opcional}

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

Creemos un Dockerfile con dos etapas:

# Etapa 1: CompilaciónFROM gradle:8.5-jdk21 AS builderWORKDIR /appCOPY build.gradle.kts settings.gradle.kts ./COPY gradle ./gradleCOPY src ./srcRUN gradle build --no-daemon

# Etapa 2: EjecuciónFROM eclipse-temurin:21-jre-alpineWORKDIR /appCOPY --from=builder /app/build/libs/my-app-*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Comandos para compilar y ejecutar:

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

Recomendaciones:

• Utilice eclipse-temurin (OpenJDK) en lugar del JDK completo: la imagen es más pequeña.
• Almacene en caché las dependencias: primero copie build.gradle.kts, luego src.
• Para aplicaciones Spring Boot, puede usar layers para compilación incremental.

2. Optimización con Jib y Gradle

Escribir un Dockerfile manualmente es lo clásico, pero existen herramientas que automatizan el proceso. Jib (de Google) se integra con Maven/Gradle y crea imágenes Docker optimizadas sin necesidad del daemon de Docker.

Agregue el plugin Jib en build.gradle.kts:

plugins {    id("com.google.cloud.tools.jib") version "3.4.0"}

jib {    from {        image = "eclipse-temurin:21-jre-alpine"    }    to {        image = "my-registry/my-kotlin-app:latest"    }    container {        ports = listOf("8080")        jvmFlags = listOf("-Xms512m", "-Xmx1024m")    }}

Compilación con un solo comando:

./gradlew jibDockerBuild

Ventajas de Jib:

• División automática en capas (dependencias, recursos, clases).
• No requiere Dockerfile.
• Funciona sin el daemon de Docker, ideal para CI/CD.

Ejemplo de aplicación Kotlin (servidor HTTP simple):

// src/main/kotlin/com/example/Main.ktpackage com.example

import com.sun.net.httpserver.HttpServerimport java.net.InetSocketAddress

fun main() {    val server = HttpServer.create(InetSocketAddress(8080), 0)    server.createContext("/") { exchange ->        val response = "¡Hola desde Kotlin en Docker!"        exchange.sendResponseHeaders(200, response.length.toLong())        exchange.responseBody.write(response.toByteArray())        exchange.close()    }    server.start()    println("Servidor iniciado en el puerto 8080")}

3. Docker Compose: aplicaciones multicontenedor

Los proyectos reales rara vez consisten en un solo servicio. Docker Compose permite describir y ejecutar múltiples contenedores (por ejemplo, aplicación + base de datos + Redis).

Creemos un docker-compose.yml para una aplicación Kotlin con PostgreSQL:<