Docker et Kotlin : conteneurisation d'applications de A à Z

Docker et Kotlin : conteneurisation d'applications de A à Z

La conteneurisation est devenue le standard de facto pour le développement moderne. Elle résout le problème "ça marche sur ma machine" et simplifie l'intégration et le déploiement continus (CI/CD). Dans cet article, nous allons voir comment conteneuriser efficacement des applications Kotlin avec Docker — de la création d'un simple Dockerfile aux optimisations de production et à l'orchestration.

1. Les bases : Dockerfile pour une application Kotlin

Le cœur de la conteneurisation est le Dockerfile. Pour les applications Kotlin, qui sont compilées en bytecode JVM, nous utilisons une construction multi-étapes (multi-stage build). Cela permet de séparer l'environnement de construction de l'environnement d'exécution, réduisant ainsi la taille de l'image finale.

Considérons une application Kotlin typique utilisant Gradle (le fichier build.gradle.kts est simplifié) :

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

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

Créons un Dockerfile avec deux étapes :

# Étape 1 : ConstructionFROM gradle:8.5-jdk21 AS builderWORKDIR /appCOPY build.gradle.kts settings.gradle.kts ./COPY gradle ./gradleCOPY src ./srcRUN gradle build --no-daemon

# Étape 2 : ExécutionFROM eclipse-temurin:21-jre-alpineWORKDIR /appCOPY --from=builder /app/build/libs/my-app-*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Commandes pour construire et exécuter :

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

Recommandations :

• Utilisez eclipse-temurin (OpenJDK) au lieu du JDK complet — l'image est plus petite.
• Mettez en cache les dépendances : copiez d'abord build.gradle.kts, puis src.
• Pour les applications Spring Boot, vous pouvez utiliser layers pour une construction incrémentielle.

2. Optimisation avec Jib et Gradle

L'écriture manuelle d'un Dockerfile est un classique, mais il existe des outils qui automatisent le processus. Jib (de Google) s'intègre avec Maven/Gradle et construit des images Docker optimisées sans nécessiter le démon Docker.

Ajoutez le plugin Jib dans 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")    }}

Construction en une seule commande :

./gradlew jibDockerBuild

Avantages de Jib :

• Division automatique en couches (dépendances, ressources, classes).
• Ne nécessite pas de Dockerfile.
• Fonctionne sans le démon Docker — idéal pour CI/CD.

Exemple d'application Kotlin (serveur 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 = "Bonjour depuis Kotlin dans Docker !"        exchange.sendResponseHeaders(200, response.length.toLong())        exchange.responseBody.write(response.toByteArray())        exchange.close()    }    server.start()    println("Serveur démarré sur le port 8080")}

3. Docker Compose : applications multi-conteneurs

Les projets réels sont rarement composés d'un seul service. Docker Compose permet de décrire et d'exécuter plusieurs conteneurs (par exemple, application + base de données + Redis).

Créons un docker-compose.yml pour une application Kotlin avec PostgreSQL :<