gRPC para Kotlin: bibliotecas, servidor y cliente — ejemplos de código

gRPC para Kotlin: bibliotecas y ejemplos

gRPC es un framework de alto rendimiento para llamadas a procedimientos remotos (RPC), desarrollado por Google. Utiliza Protocol Buffers (protobuf) para la serialización de datos y HTTP/2 para el transporte. En el ecosistema de Kotlin, gRPC se integra perfectamente con corrutinas, lo que lo convierte en una opción ideal para crear microservicios asíncronos.

En este artículo, analizaremos cómo configurar un servidor y un cliente gRPC en Kotlin utilizando la biblioteca oficial gRPC-Kotlin (grpc-kotlin). Verás el ciclo completo: desde la descripción del archivo proto hasta la ejecución y las pruebas.

1. Bibliotecas principales

Para trabajar con gRPC en Kotlin se utilizan los siguientes componentes clave:

• protobuf-gradle-plugin — plugin para compilar archivos .proto en clases de Kotlin/Java.
• grpc-kotlin-stub — biblioteca que genera stubs de corrutinas de Kotlin (funciones suspend).
• grpc-netty-shaded — capa de transporte basada en Netty (HTTP/2 integrado).
• grpc-protobuf-lite — versión ligera de protobuf para Android/clientes.

2. Estructura del proyecto

Usaremos Gradle (Kotlin DSL). Crea un proyecto con la siguiente estructura:

my-grpc-app/├── build.gradle.kts├── settings.gradle.kts└── src/    ├── main/    │   ├── proto/    │   │   └── hello.proto    │   └── kotlin/    │       ├── server/    │       │   └── HelloServer.kt    │       └── client/    │           └── HelloClient.kt

3. Descripción del archivo proto

Crea hello.proto en src/main/proto/:

syntax = "proto3";

package com.example.grpc;

service Greeter {    rpc SayHello (HelloRequest) returns (HelloReply);}

message HelloRequest {    string name = 1;}

message HelloReply {    string message = 1;}

4. Configuración de Gradle (build.gradle.kts)

Agrega los plugins y dependencias necesarios:

plugins {    id("org.jetbrains.kotlin.jvm") version "1.9.22"    id("com.google.protobuf") version "0.9.4"}

repositories {    mavenCentral()}

dependencies {    implementation("io.grpc:grpc-kotlin-stub:1.4.1")    implementation("io.grpc:grpc-netty-shaded:1.60.0")    implementation("io.grpc:grpc-protobuf-lite:1.60.0")}

protobuf {    protoc {        artifact = "com.google.protobuf:protoc:3.25.1"    }    plugins {        create("grpc") {            artifact = "io.grpc:protoc-gen-grpc-java:1.60.0"        }        create("grpckt") {            artifact = "io.grpc:protoc-gen-grpc-kotlin:1.4.1:jdk8@jar"        }    }    generateProtoTasks {        all().forEach { task ->            task.plugins {                create("grpc") { }                create("grpckt") { }            }        }    }}

5. Implementación del servidor gRPC

Crea el archivo HelloServer.kt:

package com.example.server

import com.example.grpc.GreeterGrpcKtimport com.example.grpc.HelloReplyimport com.example.grpc.HelloRequestimport io.grpc.ServerBuilder

class GreeterService : GreeterGrpcKt.GreeterCoroutineImplBase() {    override suspend fun sayHello(request: HelloRequest): HelloReply {        println("Solicitud recibida de: ${request.name}")        return HelloReply.newBuilder()            .setMessage("¡Hola, ${request.name}!")            .build()    }}

fun main() {    val port = 50051    val server = ServerBuilder.forPort(port)        .addService(GreeterService())        .build()        .start()

    println("Servidor gRPC iniciado en el puerto $port")    server.awaitTermination()}

6. Implementación del cliente gRPC

Crea el archivo HelloClient.kt:

package com.example.client

import com