gRPC pour Kotlin : bibliothèques, serveur et client — exemples de code

gRPC pour Kotlin : bibliothèques et exemples

gRPC est un framework haute performance pour les appels de procédure distante (RPC), développé par Google. Il utilise Protocol Buffers (protobuf) pour la sérialisation des données et HTTP/2 pour le transport. Dans l'écosystème Kotlin, gRPC s'intègre parfaitement avec les coroutines, ce qui en fait un choix idéal pour créer des microservices asynchrones.

Dans cet article, nous allons voir comment configurer un serveur et un client gRPC en Kotlin à l'aide de la bibliothèque officielle gRPC-Kotlin (grpc-kotlin). Vous verrez le cycle complet : de la description du fichier proto au lancement et aux tests.

1. Bibliothèques principales

Pour travailler avec gRPC en Kotlin, les composants clés suivants sont utilisés :

• protobuf-gradle-plugin — plugin pour compiler les fichiers .proto en classes Kotlin/Java.
• grpc-kotlin-stub — bibliothèque générant des stubs Kotlin basés sur les coroutines (fonctions suspend).
• grpc-netty-shaded — couche de transport basée sur Netty (HTTP/2 intégré).
• grpc-protobuf-lite — version légère de protobuf pour Android/clients.

2. Structure du projet

Nous allons utiliser Gradle (Kotlin DSL). Créez un projet avec la structure suivante :

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

3. Description du fichier proto

Créez hello.proto dans 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. Configuration de Gradle (build.gradle.kts)

Ajoutez les plugins et dépendances nécessaires :

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. Implémentation du serveur gRPC

Créez le fichier 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("Requête reçue de : ${request.name}")        return HelloReply.newBuilder()            .setMessage("Bonjour, ${request.name} !")            .build()    }}

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

    println("Serveur gRPC démarré sur le port $port")    server.awaitTermination()}

6. Implémentation du client gRPC

Créez le fichier HelloClient.kt :

package com.example.client

import com