gRPC para Kotlin: bibliotecas y ejemplos de uso

gRPC para Kotlin: bibliotecas y ejemplos de uso

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 de manera especialmente fluida gracias a bibliotecas que admiten corrutinas y tipado estricto. En este artículo, revisaremos las herramientas principales necesarias para trabajar con gRPC en Kotlin y proporcionaremos ejemplos funcionales de servidor y cliente.

Bibliotecas principales

Para trabajar con gRPC en Kotlin, necesitarás el siguiente stack:

• grpc-kotlin — biblioteca oficial de Google que proporciona APIs específicas de Kotlin, incluyendo soporte para corrutinas (suspend-functions, Flow).
• protobuf-java y protobuf-gradle-plugin — para generar clases a partir de archivos .proto.
• grpc-netty o grpc-okhttp — capa de transporte (Netty para servidor, OkHttp para Android/cliente).
• javax.annotation-api — a menudo necesario para la compilación correcta del código generado.

Para gestionar las dependencias, usa Gradle (Kotlin DSL). Ejemplo del bloque dependencies:

dependencies {    implementation("io.grpc:grpc-netty-shaded:1.58.0")    implementation("io.grpc:grpc-protobuf:1.58.0")    implementation("io.grpc:grpc-stub:1.58.0")    implementation("io.grpc:grpc-kotlin-stub:1.4.0")    implementation("com.google.protobuf:protobuf-java:3.24.3")    implementation("javax.annotation:javax.annotation-api:1.3.2")}

También es obligatorio conectar el plugin protobuf para la generación de código:

plugins {    id("com.google.protobuf") version "0.9.4"}

protobuf {    protoc {        artifact = "com.google.protobuf:protoc:3.24.3"    }    plugins {        create("grpc") {            artifact = "io.grpc:protoc-gen-grpc-java:1.58.0"        }        create("grpckt") {            artifact = "io.grpc:protoc-gen-grpc-kotlin:1.4.0:jdk8@jar"        }    }    generateProtoTasks {        all().forEach {            it.plugins {                create("grpc")                create("grpckt")            }        }    }}

Definición del servicio mediante archivo .proto

Crea el archivo src/main/proto/hello.proto:

syntax = "proto3";

package com.example.grpc;

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

message HelloRequest {  string name = 1;}

message HelloReply {  string message = 1;}

Después de ejecutar la compilación de Gradle, se generarán las clases: HelloRequest, HelloReply, GreeterGrpc y GreeterGrpcKt (versión Kotlin con corrutinas).

Implementación del servidor gRPC en Kotlin

El servidor utilizará la clase generada GreeterGrpcKt.GreeterCoroutineImplBase:

import com.example.grpc.GreeterGrpcKtimport com.example.grpc.HelloReplyimport com.example.grpc.HelloRequestimport io.grpc.ServerBuilderimport kotlinx.coroutines.runBlocking

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

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

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

Implementación del cliente gRPC en Kotlin

El cliente utiliza un canal y un stub con soporte para corrutinas:

import com.example.grpc.GreeterGrpcKti