Microsserviços em Kotlin: arquitetura e prática do A ao Z

Introdução: Por que Kotlin é a linguagem ideal para microsserviços?

O desenvolvimento moderno está cada vez mais se afastando de monolitos em favor da arquitetura de microsserviços. Kotlin, como uma linguagem moderna para JVM, oferece uma combinação única de concisão, segurança e desempenho. Graças à compatibilidade total com Java, ao rico ecossistema e ao suporte nativo a corrotinas, Kotlin permite criar microsserviços leves, rápidos e tolerantes a falhas.

Neste artigo, abordaremos a arquitetura de microsserviços em Kotlin, desde o design até a implantação, exploraremos dois frameworks populares — Ktor e Spring Boot — e escreveremos código real.

1. Arquitetura de microsserviços em Kotlin: princípios-chave

A arquitetura de microsserviços envolve a divisão de uma aplicação em serviços independentes e fracamente acoplados. Cada serviço é responsável por sua própria lógica de negócios, possui seu próprio banco de dados e pode ser implantado de forma independente.

1.1. Princípios de design

\n
• Responsabilidade única — cada serviço resolve uma tarefa (por exemplo, gerenciamento de usuários ou processamento de pedidos).
\n
• Baixo acoplamento — os serviços se comunicam por meio de APIs bem definidas (REST, gRPC, filas de mensagens).
\n
• Independência de dados — cada serviço possui seu próprio banco de dados (Polyglot Persistence).
\n
• Tolerância a falhas — a falha de um serviço não deve paralisar todo o sistema (Circuit Breaker, Retry).
\n

1.2. Stack tecnológico para microsserviços Kotlin

Uma stack típica é assim:

\n
• Linguagem: Kotlin 1.9+
\n
• Framework: Ktor (leve, reativo) ou Spring Boot (pesado, com ecossistema rico)
\n
• Banco de dados: PostgreSQL, MongoDB, Redis
\n
• Comunicação: REST, gRPC, Kafka/RabbitMQ
\n
• Build: Gradle (Kotlin DSL)
\n
• Containerização: Docker + Docker Compose
\n

2. Prática: criando um microsserviço com Ktor

Ktor é um framework assíncrono da JetBrains, ideal para microsserviços. Ele não impõe uma estrutura e é facilmente configurável.

2.1. Instalação e configuração do projeto

Vamos criar um projeto usando Gradle Kotlin DSL. Arquivo build.gradle.kts:

plugins {\n    kotlin("jvm") version "1.9.22"\n    id("io.ktor.plugin") version "2.3.7"\n}\n\napplication {\n    mainClass.set("com.example.ApplicationKt")\n}\n\ndependencies {\n    implementation("io.ktor:ktor-server-core:2.3.7")\n    implementation("io.ktor:ktor-server-netty:2.3.7")\n    implementation("io.ktor:ktor-server-content-negotiation:2.3.7")\n    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.7")\n    implementation("ch.qos.logback:logback-classic:1.4.14")\n}

2.2. Escrevendo um serviço REST simples

Vamos criar um microsserviço para gerenciamento de tarefas (ToDo). Modelo de dados:

@Serializable\ndata class Task(\n    val id: Int,\n    val title: String,\n    val completed: Boolean = false\n)

Arquivo principal da aplicação Application.kt:

import io.ktor.server.engine.*\nimport io.ktor.server.netty.*\nimport io.ktor.server.routing.*\nimport io.ktor.server.response.*\nimport io.ktor.server.request.*\nimport io.ktor.serialization.kotlinx.json.*\nimport io.ktor.server.plugins.contentnegotiation.*\n\nfun main() {\n    embeddedServer(Netty, port = 8080) {\n        install(ContentNegotiation) {\n            json()\n        }\n        routing {\n            get("/tasks") {\n                call.respond(listOf(\n                    Task(1, "Estudar Kotlin", true),\n                    Task(2, "Escrever microsserviço", false)\n                ))\n            }\n            get("/tasks/{id}") {\n                val id = call.parameters["id"]?.toIntOrNull()\n                if (id != null) {\n