Golang Grpc

O que é GRPC?

O GRPC é uma estrutura de chamada de procedimento remoto de alto desempenho que permite que os desenvolvedores conectem serviços entre os sistemas. Usando o GRPC, os aplicativos do cliente e do servidor podem se comunicar perfeitamente.

Simplificando, o GRPC permite que um aplicativo cliente acesse e use métodos em um aplicativo de servidor (mesmo em máquinas remotas) como se estivesse definido no mesmo aplicativo. É um grande bloco de construção para microsserviços.

Requisitos

Para acompanhar este tutorial, você precisará ter:

1. A versão mais recente do compilador Go.
2. Compilador de buffer de protocolo (protoc) versão 3
3. Go Plugins para trabalhar com buffers de protocolo.

Para instalar o compilador de buffer do protocolo, execute o comando conforme fornecido abaixo:

Vá instalar o Google.Golang.org/protobuf/cmd/protoc-gen-go@mais recente
Vá instalar o Google.Golang.org/grpc/cmd/protoc-gen-go-grpc@mais recente

A próxima etapa é atualizar seu caminho para que você possa usar os comandos Protoc:

Caminho de exportação = "$ PATH: $ (GO ENV GOPATH)/BIN"

Servidor Golang GRPC

Para este tutorial, criaremos um servidor GRPC simples que leva a mensagem enviada por um cliente e ecoa de volta.

Comece criando um diretório de trabalho:

MKDIR GRPC-TUT
CD GRPC-TUT

Em seguida, crie um servidor.GO FILE que manterá o código para o servidor GRPC:

Toque no servidor.ir

Abra o arquivo com seu editor de texto e adicione as seguintes linhas:

Pacote principal
importação (
"registro"
"líquido"
)

No código anterior, importamos os pacotes de log e rede, o que nos permitirá registrar erros e estabelecer um ouvinte usando o pacote de rede.

Em seguida, configuraremos a função principal e criaremos um ouvinte na porta 9001/TCP:

func main ()
ouvinte, err: = net.Ouça ("TCP", ": 9001")
se err != nil
registro.Fatal (ERR)

O próximo passo é importar o pacote GRPC para o programa GO. Isso nos permitirá configurar um servidor GRPC e os terminais que desejamos servir antes de conectá -lo com o ouvinte no TCP.

importar "Google.Golang.org/grpc "

De volta à função principal, podemos criar um servidor GRPC, conforme mostrado no código a seguir:

GRPSERVER: = GRPC.Newsserver ()
se err: = grpsserver.Servir (ouvinte); errar != nil
registro.Fatal (ERR)

Criamos um servidor GRPC usando o método Newsserver () no código anterior. Em seguida, servimos o servidor sobre o ouvinte TCP que criamos anteriormente.

E com isso, temos um servidor GRPC. No entanto, não faz muito. Podemos estender isso criando um aplicativo de eco simples.

O aplicativo receberá a mensagem do cliente e retornará a mesma mensagem ao cliente.

Arquivo proto eco

Para configurar nosso aplicativo de eco, precisaremos criar um .arquivo proto. O arquivo proto manterá as definições para o aplicativo.

toque eco.proto

A primeira entrada no arquivo proto será a declaração do pacote. Isso evita colisões de nomes em outros aplicativos.

Syntax = "Proto3";
Echo Package;
opção go_package = "./eco";

Você pode alterar o nome para refletir o nome do seu pacote.

Depois de termos a declaração do pacote, precisamos adicionar definições de mensagem. Isso define um contêiner ou estrutura da mensagem para receber dos clientes:

mensagem de mensagem
corpo de cordas = 1;

Em seguida, precisamos definir o serviço. Em nosso exemplo, chamamos o serviço como ecoService, como mostrado:

ECHOSERVICE DE SERVIÇO
RPC ECHO (mensagem) Retorna (mensagem)

O serviço define um método que um cliente GRPC ligará. O método simplesmente leva a mensagem e retorna a mensagem. Isso cria um aplicativo de eco.

Compilando os buffers de protocolo

Agora, temos o proto definindo para o nosso aplicativo. Em seguida, precisamos gerar as classes que usaremos para ler e escrever dados usando a linguagem de programação Go.

Podemos fazer isso usando o compilador de buffer de protocolo:

protoc --go_out =./echo --go-grpc_out =./echo --go-grpc_opt = require_unimplemented_servers = ECHO falso.proto

Os comandos anteriores devem gerar o código GO necessário para se registrar e ligar para o servidor GRPC.

O próximo passo é definir o RPC para o método de eco. Podemos fazer isso criando um arquivo GO no diretório Echo como:

toque eco.ir

No arquivo, adicione o código como mostrado:

Echo Package
importação (
"FMT"
"Golang.org/x/net/context "// Obter contexto de solicitação
)
Tipo de estrutura do servidor

func (servidor s *) eco (contexto ctx.Contexto, mensagem *mensagem) ( *mensagem, erro)
fmt.Printf ("Mensagem recessora: %s", mensagem.Corpo)
retornar e mensagem body: "oi de volta!", nada

O próximo passo é importar o código dentro do pacote Echo. Volte para o servidor.Vá arquivo e adicione a seguinte cláusula de importação:

importar "GRPC/ECHO"

Você precisará inicializar o gerente do módulo Go para o seu projeto.

No arquivo do servidor principal, adicione as seguintes linhas para criar um novo servidor de bate -papo e registrá -lo:

s: = eco.Servidor
eco.RegisterechoserviceServer (GrPServer, & s)

E com isso, temos o código para o servidor GRPC do caminho.

cliente grpc

O próximo passo é construir um cliente que possa interagir com o servidor GRPC. Comece criando um cliente de arquivo.vá no diretório principal.

tocar ./cliente.ir

Vamos começar com nossas importações. Para este, precisaremos de pacotes de log, contexto, eco e GRPC

importação (
"registro"
"Golang.org/x/net/context "
"Google.Golang.org/grpc "
"GRPC/ECHO"
)

Em seguida, vamos começar com a função principal:

func main ()
// Ponteiro para GRPC Conn
var Conn *Grpc.ClientConn
// Conecte -se ao servidor GRPC (conexão insegura)
Conn, Err: = GRPC.Dial (": 9001", GRPC.WithInsecure ())
se err != nil
registro.Fatal (ERR)

// Fechar Conn
adiar conn.Fechar()
// Echo Service Client
e: = eco.Newechoserviceclient (Conn)
// Corpo da mensagem
Mensagem: = eco.Mensagem
Corpo: "oi",

resp, err: = e.Eco (contexto.Background (), & Message)
se err != nil
registro.Fatal (ERR)

fmt.Printf ("%s", resp.Corpo)

O código anterior implementa um cliente GRPC, que envia a mensagem "HI" e recebe "oi de volta" do servidor.

Teste

Depois de concluído, execute o servidor.vá e cliente.ir. Se for bem -sucedido, o servidor deve responder com "Hi Back", como mostrado abaixo:

Você construiu com sucesso um servidor GRPC e cliente em go.

Conclusão

Este guia serve como um básico absoluto para implementar o GRPC em Go. Se você é novo no GRPC e Protobufs, pode levar tempo para entender a implementação. No entanto, com algumas práticas e implementação, você estará em posição de criar serviços GRPC complexos. Esperamos que você tenha achado este artigo útil. Confira outros artigos do Linux para obter mais dicas e tutoriais.