Microservices in Kotlin: Architecture and Practice from A to Z

Introduction: Why Kotlin is the Ideal Language for Microservices

Modern backend development is increasingly moving away from monolithic solutions in favor of microservice architecture. Kotlin, being a statically typed language running on the JVM, offers developers a unique combination of conciseness, safety, and performance. Unlike Java, Kotlin allows you to write more expressive and safe code without boilerplate, which is critical when building complex distributed systems.

In this article, we will cover the full cycle of creating a microservice in Kotlin: from choosing a framework to deploying in a container. You will learn how to use Ktor for the HTTP server, Koin for dependency injection, and Exposed for database interaction. All code examples are ready for use in real projects.

1. Designing the Microservice Architecture

The first step is to define the service boundaries. Unlike a monolith, each microservice is responsible for a single business capability. Let's consider an example of a user management service (User Service).

Project Structure

Recommended structure for a Kotlin microservice:

user-service/├── src/│   ├── main/kotlin/com/example/userservice/│   │   ├── application/       # Application layer (use cases)│   │   ├── domain/            # Domain models│   │   ├── infrastructure/    # Repositories, DB, external APIs│   │   └── presentation/      # Controllers (Ktor routes)│   └── resources/│       └── application.conf└── build.gradle.kts

This architecture follows the principles of Clean Architecture and Domain-Driven Design, which simplifies testing and maintenance.

Technology Stack Selection

• HTTP Framework: Ktor (lightweight, asynchronous, coroutines)
• DI: Koin (simple, no reflection)
• ORM: Exposed (Kotlin-native DSL for SQL)
• Database: PostgreSQL
• Containerization: Docker + Docker Compose

2. Implementing a Microservice in Kotlin with Ktor and Koin

Configuring build.gradle.kts

Add the necessary dependencies:

plugins {    kotlin("jvm") version "1.9.22"    id("io.ktor.plugin") version "2.3.7"    kotlin("plugin.serialization") version "1.9.22"}

dependencies {    implementation("io.ktor:ktor-server-core:2.3.7")    implementation("io.ktor:ktor-server-netty:2.3.7")    implementation("io.ktor:ktor-server-content-negotiation:2.3.7")    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.7")    implementation("org.jetbrains.exposed:exposed-core:0.44.1")    implementation("org.jetbrains.exposed:exposed-dao:0.44.1")    implementation("org.jetbrains.exposed:exposed-jdbc:0.44.1")    implementation("org.postgresql:postgresql:42.6.0")    implementation("io.insert-koin:koin-ktor:3.5.0")}

Creating the Domain Model and Repository

// domain/User.ktdata class User(    val id: Long,    val name: String,    val email: String)

// infrastructure/UserRepository.ktinterface UserRepository {    suspend fun getAll(): List<User>    suspend fun getById(id: Long): User?    suspend fun create(user: User): User}

Implementing the Repository with Exposed

// infrastructure/UserRepositoryImpl.ktimport org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transaction

object UsersTable : Table("users") {    val id = long("id").autoIncrement()    val name = varchar("name", 255)    val email = varchar("email", 255)    override val primaryKey = PrimaryKey(id)}

class UserRepositoryImpl(private val database: Database) : UserRepository {    override suspend fun getAll(): List<User> =