Por: Gabriel Sotero – Responsável por Desenvolvimento de Software e IA na NETEXPERTS
Dando continuidade à nossa série sobre comunicação entre sistemas, hoje mergulhamos no protocolo que é o padrão ouro para a comunicação interna de microsserviços em larga escala: o gRPC.
Como Google Premier Partners, na NetExperts utilizamos o gRPC quando a latência de milissegundos e a eficiência de banda são críticas para a operação dos nossos clientes.
Do RPC ao gRPC: Uma Breve História
O conceito de RPC (Remote Procedure Call) não é novo; ele nasceu na década de 80 com a ideia de permitir que um programa chamasse uma função em outro computador como se fosse uma função local. No entanto, as implementações antigas (como SOAP) eram pesadas e baseadas em XML, o que gerava um consumo excessivo de recursos.
Em 2015, o Google lançou o gRPC. Ele foi construído sobre décadas de experiência interna com um framework chamado Stubby. O gRPC foi doado à Cloud Native Computing Foundation (CNCF) e se tornou o padrão para conectar microsserviços de forma extremamente rápida e tipada.
Por que o gRPC é tão rápido?
O segredo da velocidade do gRPC reside em dois pilares fundamentais:
- HTTP/2: Diferente do REST tradicional (HTTP/1.1), o gRPC utiliza HTTP/2, que permite multiplexação (várias requisições em uma única conexão), compressão de cabeçalhos e comunicação binária bidirecional.
- Protocol Buffers (Protobuf): Em vez de enviar texto puro (JSON/XML), o gRPC utiliza um formato de serialização binária. O dado trafega de forma compacta, o que reduz drasticamente o uso de rede e o tempo de processamento de CPU para “ler” a mensagem.
Potencial em Microsserviços: Em comunicações internas (Lado do Servidor), o gRPC pode ser até 10 vezes mais rápido que o REST com JSON, tornando-o ideal para arquiteturas de alta carga.
Tutorial: Implementação com Node.js
Para trabalhar com gRPC, o primeiro passo não é o código, mas sim o Contrato.
1. Criando o Protobuff (servidor.proto)
O arquivo .proto define a estrutura dos dados e os serviços disponíveis. É a “planta” da sua comunicação.
Protocol Buffers
syntax = “proto3”;
package netexperts;
// Definição do serviço
service ServidorService {
rpc ObterStatus (ServidorRequest) returns (ServidorResponse) {}
}
// Estrutura da requisição
message ServidorRequest {
string id = 1;
}
// Estrutura da resposta
message ServidorResponse {
string hostname = 1;
string status = 2;
bool online = 3;
}
2. Implementação do Servidor (server.js)
Precisamos instalar as bibliotecas necessárias:
npm install @grpc/grpc-js @grpc/proto-loader
JavaScript
const grpc = require(‘@grpc/grpc-js’);
const protoLoader = require(‘@grpc/proto-loader’);
// Carregar o arquivo proto
const packageDefinition = protoLoader.loadSync(‘servidor.proto’);
const netexpertsProto = grpc.loadPackageDefinition(packageDefinition).netexperts;
// Lógica da função (Provedor)
function obterStatus(call, callback) {
const servidores = {
“1”: { hostname: “cloud-master-google”, status: “Operacional”, online: true },
“2”: { hostname: “vpn-gateway”, status: “Reiniciando”, online: false }
};
const response = servidores[call.request.id] || { hostname: “N/A”, status: “Desconhecido”, online: false };
callback(null, response);
}
// Inicializar o servidor gRPC
const server = new grpc.Server();
server.addService(netexpertsProto.ServidorService.service, { ObterStatus: obterStatus });
server.bindAsync(‘0.0.0.0:50051’, grpc.ServerCredentials.createInsecure(), () => {
console.log(“🚀 Servidor gRPC NetExperts rodando na porta 50051”);
server.start();
});
3. Chamada pelo Cliente (Consumidor)
O cliente utiliza o mesmo arquivo .proto para saber como chamar o servidor.
JavaScript
const client = new netexpertsProto.ServidorService(
‘localhost:50051’,
grpc.credentials.createInsecure()
);
client.ObterStatus({ id: “1” }, (error, response) => {
if (!error) {
console.log(“Resposta do Servidor:”, response.hostname, “-“, response.status);
} else {
console.error(error);
}
});
Conclusão
O gRPC é a escolha definitiva para quem busca o máximo de performance em sistemas distribuídos. Embora o REST ainda seja soberano para APIs públicas (pela facilidade de consumo via navegador), o gRPC é o que sustenta os motores internos das maiores empresas de tecnologia do mundo, incluindo o Google e a NetExperts.
Ao utilizar Protocol Buffers, você garante que seus sistemas falem a mesma língua de forma rápida, segura e fortemente tipada.
Referências e Documentações Oficiais:
- Documentação Oficial do gRPC
- Protocol Buffers Language Guide (proto3)
- HTTP/2 – Introduction to High Performance Browser Networking
- gRPC no Node.js – Exemplos Oficiais
