Cómo Dockerizar una Aplicación Spring Boot con Kotlin: Guía Paso a Paso

Dockerizar tu backend, microservicio o aplicación en Spring Boot y con lenguaje Kotlin es un paso esencial en el desarrollo de software moderno, ya que garantiza entornos consistentes y simplifica el proceso de despliegue.

En esta guía, te explicaré a través del proceso de crear una imagen Docker para tu proyecto en Kotlin y Spring Boot, configurando un archivo docker-compose.yml y gestionando tus variables de entorno con un archivo .env para que todo luzca mas profesional. Ya sea que seas nuevo en Docker o estés buscando optimizar tu flujo de trabajo de desarrollo, este tutorial ofrece un enfoque sencillo para containerizar tu aplicación.

Al final de esta guía, tendrás un sólido entendimiento de cómo construir y configurar tu entorno Docker, lo que te permitirá ejecutar tu aplicación Kotlin Spring Boot en un entorno containerizado. Esto garantiza que tu aplicación esté aislada de las dependencias locales, haciendo que los procesos de desarrollo y despliegue sean más fluidos y confiables.

Al final de este post te dejo la url del repositorio en GitHub por si tienes alguna duda o quieres clonar el proyecto.

Si encontraste este post en la web, te recomiendo ver este video en donde doy una explicación de como hacerlo, si vienes de Youtube, omite el video

Lo primero que debemos revisar es que dependencias tenemos en nuestro archivo build.gradle.kts

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
	id("org.springframework.boot") version "3.3.0"
	id("io.spring.dependency-management") version "1.1.5"
	kotlin("jvm") version "1.9.24"
	kotlin("plugin.spring") version "1.9.24"
	kotlin("plugin.jpa") version "1.9.24"
}

group = "com.yoandroide"
version = "0.0.1-SNAPSHOT"

java {
	sourceCompatibility = JavaVersion.VERSION_21
	targetCompatibility = JavaVersion.VERSION_21
}

repositories {
	mavenCentral()
}

dependencies {
	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
	implementation("org.springframework.boot:spring-boot-starter-web")
	implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
	implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.6.0")
	implementation("org.jetbrains.kotlin:kotlin-reflect")
	runtimeOnly("org.postgresql:postgresql")

	testImplementation("com.h2database:h2")
	testImplementation("org.springframework.boot:spring-boot-starter-test")
	testRuntimeOnly("org.junit.platform:junit-platform-launcher")


	developmentOnly("org.springframework.boot:spring-boot-devtools")

}

tasks.withType<KotlinCompile> {
	kotlinOptions {
		freeCompilerArgs += "-Xjsr305=strict"
		jvmTarget = "21"
	}
}

tasks.withType<Test> {
	useJUnitPlatform()
	systemProperty("spring.profiles.active", "test")
}

En mi caso como mi proyecto es un CRUD sencillo, no hay muchas dependencias. Ahora procedemos a crear los siguientes 3 archivos en la raíz de sus proyectos de la siguiente manera:

Primero revisemos el archivo Dockerfile

FROM openjdk:21-jdk-slim

COPY build/libs/crud-kotlin-0.0.1-SNAPSHOT.jar /app/app.jar

WORKDIR /app

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Luego debemos crear el archivo docker.compose.yml con la siguiente configuración

version: '3.9'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
      DB_NAME: ${DB_NAME}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
    depends_on:
      - db

volumes:
  postgres_data:

Vemos que en el archivo tenemos dos servicios, db que seria la base de datos con su configuración de versión y las variables de entorno con el nombre, nombre de usuario y contraseña, luego tener el app que seria el backend, al cual le pasaremos la información necesaria para gestionar la conexión a la base de datos.

Ahora solo nos queda probar, primero construimos la aplicacion usando:

./gradlew build

Luego dockerizamos nuestra app:

docker-compose up --build

Si vamos a Docker Desktop veremos que se ha creado un contenedor con las siguientes imágenes

Si quieres conocer otros artículos parecidos a Cómo Dockerizar una Aplicación Spring Boot con Kotlin: Guía Paso a Paso puedes visitar la categoría Kotlin.