gRPC para Kotlin: bibliotecas, servidor e cliente — exemplos de código

gRPC para Kotlin: bibliotecas e exemplos

gRPC é um framework de alto desempenho para chamada remota de procedimentos (RPC), desenvolvido pelo Google. Ele usa Protocol Buffers (protobuf) para serialização de dados e HTTP/2 para transporte. No ecossistema Kotlin, o gRPC se integra perfeitamente com corrotinas, tornando-o ideal para criar microsserviços assíncronos.

Neste artigo, vamos abordar como configurar um servidor e cliente gRPC em Kotlin usando a biblioteca oficial gRPC-Kotlin (grpc-kotlin). Você verá o ciclo completo: desde a descrição do arquivo proto até a execução e teste.

1. Bibliotecas principais

Para trabalhar com gRPC em Kotlin, são usados os seguintes componentes principais:

• protobuf-gradle-plugin — plugin para compilar arquivos .proto em classes Kotlin/Java.
• grpc-kotlin-stub — biblioteca que gera stubs com corrotinas Kotlin (funções suspend).
• grpc-netty-shaded — camada de transporte baseada em Netty (HTTP/2 embutido).
• grpc-protobuf-lite — versão leve do protobuf para Android/clientes.

2. Estrutura do projeto

Usaremos Gradle (Kotlin DSL). Crie um projeto com a seguinte estrutura:

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

3. Descrição do arquivo proto

Crie hello.proto em 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. Configuração do Gradle (build.gradle.kts)

Adicione os plugins e dependências necessários:

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. Implementação do servidor gRPC

Crie o arquivo 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("Requisição recebida de: ${request.name}")        return HelloReply.newBuilder()            .setMessage("Olá, ${request.name}!")            .build()    }}

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

    println("Servidor gRPC iniciado na porta $port")    server.awaitTermination()}

6. Implementação do cliente gRPC

Crie o arquivo HelloClient.kt:

package com.example.client

import com