Como criar um server gRPC usando Kotlin e Spring Boot

Back-End
• 18 maio 2022

Em tecnologia muitos caminhos podem levar a Roma, não é mesmo? O que eu quero dizer é que é possível resolver o mesmo problema de formas diferentes. Por isso, hoje eu queria te mostrar como criar um server gRPC com Kotlin e Spring Boot.

Mas por que criar um server gRPC com Kotlin e Spring Boot?

Recentemente tivemos uma demanda no trabalho onde precisávamos implementar um serviço que seria usado por outras aplicações para executar cálculos. Normalmente faríamos isso com Spring Boot, criaríamos um endpoint REST e pronto.

Porém, enxergamos a possibilidade de criar uma aplicação melhor (melhor para o nosso caso, importante analisar cada situação) e ainda aprender algo novo. Por isso, escolhemos usar gRPC.

O que você precisa para seguir esse tutorial?

Tempo.
Um editor de texto ou IDE da sua preferência (nos testes usamos IntelliJ).
JDK 1.8 ou superior instalado com JAVA_HOME configurado corretamente.
Internet.

Mas primeiramente, o que é gRPC?

Segundo o site oficial do gRPC, ele é um “modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment.”

Não ajudou muito, né?

Mas vamos começar pelo básico,

O que é RPC?

RPC (Remote Procedure Call) é uma tecnologia de comunicação para sistemas distribuídos que tem como principais vantagens a utilização de semânticas claras e diretas. Sua criação remonta aos anos 70 e ele foi muito usado para comunicações de baixo nível. Nas últimas duas décadas, tem sido utilizado para integrações entre aplicações e sistemas de alto nível.

O gRPC é um projeto open source da Google que se iniciou em 2015. Ele é um framework feito em cima do RPC.

A ideia inicial do gRPC é ser muito mais performática que o REST, por usar HTTP/2 e possuir uma linguagem de definição de interfaces (IDL). Pelo fato de usar o HTTP/2 ele tira proveito de algumas features nativas como streaming de dados, load balancing, monitoramento etc.

Uma curiosidade interessante é que o “g” do gRPC não significa Google (pelo menos eles dizem que não hehe), na realidade ele não teria um significado único e mudaria dependendo da release. O g já foi good, green, gentle, great, gravity e mais alguns outros. É possível dar uma olhada nos significados do g no seguinte endereço.

Criando a aplicação

Primeiramente iremos criar o nosso projeto. Para isso iremos utilizar o Spring Initializr, uma ferramenta web que fornece de forma rápida tudo o que precisamos para rodar uma aplicação Spring Boot.

Primeiro, acesse Spring Initializr.

Selecione o projeto como Gradle Project.
Selecione a language Kotlin.
Vamos clicar em ADD DEPENDENCIES e adicione a dependência do Spring Web.
O artifact nós demos o nome de “grpcDemo”. (opcional pode colocar o nome que preferir)
Após isso, apertamos em Generate para criar o projeto e salvamos o projeto no nosso computador.

Observação: Tenha atenção ao nome que definimos para o group e o artifact, pois fazemos referência a ele no arquivo de Protobuf (ou simplesmente proto). Lembre que se caso altere esses valores aqui é importante atualizar o proto e colocar o arquivo de service no mesmo pacote.

Depois de baixar o projeto nós vamos abri-lo no editor/IDE. Aqui nós usamos o IntelliJ, mas fique a vontade para usar o que quiser.

Depois de abrir e carregar todas as configurações iniciais nós vamos começar a realizar as nossas alterações.

O primeiro ponto, é adicionar todas as dependências que nós vamos precisar para realizar esse projeto. As dependências do gRPC são as:

implementation("io.grpc:grpc-netty:1.44.1")
implementation("io.grpc:grpc-protobuf:1.44.1")
implementation("io.grpc:grpc-kotlin-stub:1.2.1")

É importante adicionar as configurações no arquivo build.gradle.kts para conseguir ler o arquivo de proto, gerar as classes Java e também adicionar as pastas onde os arquivos foram gerados na lista de arquivos que devem ser lidos:

protobuf {
     generatedFilesBaseDir = "$buildDir/generated/sources/proto" 
     protoc {
          artifact = "com.google.protobuf:protoc:3.12.2"
     }

     plugins {
          id("grpc") {
               artifact = "io.grpc:protoc-gen-grpc-java:1.30.0"
          }
     }
               generate
          ProtoTasks {
          all().forEach {
               it.plugins {
                    id("grpc"){
                         outputSubDir = "grpc"
                    }
               }
          }
     }
 }

sourceSets{
     main{
          proto{
               srcDir("$buildDir/generated/sources/proto/main/grpc")
          }
     }
}

O build.gradle.kts ficará dessa forma:

Após o import das dependências iremos criar o nosso proto.

Arquivo proto? O que é isso?

Por padrão o gRPC utiliza protobuf ou Protocol Buffers que é um mecanismo open source para serializar estruturas de dados. Os buffers de protocolo (protobuf) são usados como uma IDL (linguagem de definição de interface) e utilizam a extensão .proto. O arquivo *. proto contém:

A definição do serviço gRPC.
As mensagens enviadas entre clientes e servidores.

Para o nosso exemplo iremos criar um arquivo chamado person.proto e utilizar o seguinte código do proto:

Nós criamos uma pasta chamada proto dentro do src/main e colocamos o arquivo lá. O proto será compilado e irá gerar as classes necessárias para que possamos nos comunicar com o gRPC.

Criando o service (endpoint) gRPC

Com essas classes geradas nós vamos criar o serviço para ler uma requisição gRPC. Para isso, iremos criar uma nova classe com o nome PersonService.kt, com o seguinte código:

Nós criamos a classe dentro do package com.example.grpcDemo.adapters.grpc

Nossa classe PersonService usa as classes geradas pelo proto para receber a mensagem e para enviar uma resposta. O gRPC gera tudo o que precisamos para fazer o server, então é basicamente utilizar.

Como criar o server gRPC?

A aplicação não irá iniciar o servidor do gRPC automaticamente, nós precisaremos realizar algumas configurações para ele funcionar.

Vamos abrir o arquivo GrpcDemoApplication.kt criado pelo Spring Initializr e fazer os seguintes ajustes para funcionar:

Iremos ler todos os services gRPC criados no código e adicionar ao servidor. Além disso, definimos a porta 9090 para a aplicação.

Como testar a aplicação?

Para testar o gRPC eu gosto de utilizar o BloomRPC que é um client gRPC bem simples. Para utilizá-lo basta importar o arquivo proto e ele já estará pronto para ser utilizado.

Não esquecer que a porta que definimos para a nossa aplicação é a 9090.

Tela do BloomRPC com um exemplo. Na tela do BloomRPc estão sendo exibidas as seguintes informações Localhost: 0.0.0.0:9090, Editor: { “cpf”: “Hello”}, Response: { “name “ : “Nome de teste”, “id”: 1, “email”: teste@teste.com.

O código completo pode ser encontrado no seguinte repo.

Conclusão

Criar um server gRPC com Kotlin e Spring Boot é uma das formas que encontramos para resolver a necessidade que tínhamos no time, mas lembrando que você pode adotar outras ações.

Inclusive, falamos nesse ZupCast sobre o que levar em conta para adotar uma linguagem de programação em projeto. Muito do que foi debatido vale não só para uma linguagem em específico, mas para uma stack de tecnologia completa. Com certeza vale o play.