Como invocar com gRPC

Nesta página, mostramos detalhes específicos do Cloud Run for Anthos para desenvolvedores que querem usar o gRPC (em inglês) para conectar um serviço do Cloud Run for Anthos a outros serviços. Por exemplo, a fim de fornecer comunicação simples e de alto desempenho entre microsserviços internos. O Cloud Run for Anthos é compatível com chamadas gRPC unary e streaming.

gRPC unária

Em uma chamada RPC unária, o cliente envia uma única solicitação ao servidor e recebe uma resposta única, semelhante a uma chamada de função normal: 
rpc SayHello(HelloRequest) returns (HelloResponse);

gRPC Streaming

As opções de streaming a seguir estão disponíveis com o gRPC. RPCs de streaming de servidor em que o cliente envia uma solicitação ao servidor e recebe um stream de leitura contendo uma sequência de mensagens. O cliente lê o stream retornado até que não haja mais mensagens. 

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

RPCs de streaming de servidor em que o cliente grava uma sequência de mensagens e as envia ao servidor em um stream. Depois que o cliente terminar de gravar as mensagens, ele aguardará a resposta do servidor. 

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

RPCs de streaming bidirecional em que o cliente e o servidor enviam mensagens em dois streams de leitura e gravação que operam de maneira independente. 

rpc BidiHello(stream HelloRequest) returns (stream HelloResponse);

Os possíveis casos de uso são estes:

  • Comunicação entre microsserviços internos.
  • Altas cargas de dados (o gRPC usa buffers de protocolo (em inglês), que são até sete vezes mais rápidos do que as chamadas REST).
  • Basta uma única definição de serviço simples. Não é necessário escrever uma biblioteca de cliente completa.

Para integrar seu serviço ao gRPC:

  • Defina as mensagens de solicitação e as respostas em um arquivo proto e compile-as.
  • Crie um servidor gRPC para processar solicitações e retornar respostas: ele precisa detectar a variável de ambiente PORT.
  • Crie um cliente que envie solicitações e processe respostas do servidor gRPC.
  • Como opção, adicione uma autenticação.
  • Crie e implante seu serviço.

Como definir e compilar mensagens em um arquivo proto

Não há itens adicionais ou específicos do Cloud Run for Anthos para adicionar às definições de proto. Assim como qualquer outro uso do gRPC, você usa buffers de protocolo gRPC (em inglês) para definições de serviço e serialização de dados.

Como criar um cliente gRPC

Não há itens adicionais ou específicos do Cloud Run for Anthos para adicionar a um cliente que usa o gRPC: siga os documentos do gRPC sobre como usar definições de serviço no código do cliente e os clientes de amostra fornecidos nos tutoriais do gRPC (links em inglês) específicos da linguagem.

Como detectar solicitações gRPC em um serviço do Cloud Run for Anthos

O único requisito especial para um servidor gRPC em execução no Cloud Run for Anthos é detectar a porta especificada pela variável de ambiente PORT, conforme mostrado no código:

Go

run/grpc-ping/main.go 
func main() {
	log.Printf("grpc-ping: starting server...")

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}

	listener, err := net.Listen("tcp", ":"+port)
	if err != nil {
		log.Fatalf("net.Listen: %v", err)
	}

	grpcServer := grpc.NewServer()
	pb.RegisterPingServiceServer(grpcServer, &pingService{})
	if err = grpcServer.Serve(listener); err != nil {
		log.Fatal(err)
	}
}

Como abrir uma conexão gRPC com um serviço

Para abrir uma conexão gRPC com um serviço para enviar mensagens gRPC, é necessário especificar o domínio do host, que é o URL do serviço do Cloud Run for Anthos, ou o domínio personalizado mapeado para esse serviço com a porta 443, que é a porta esperada para o gRPC.

Go

run/grpc-ping/connection.go 

import (
	"crypto/tls"
	"crypto/x509"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
)

// NewConn creates a new gRPC connection.
// host should be of the form domain:port, e.g., example.com:443
func NewConn(host string, insecure bool) (*grpc.ClientConn, error) {
	var opts []grpc.DialOption
	if host != "" {
		opts = append(opts, grpc.WithAuthority(host))
	}

	if insecure {
		opts = append(opts, grpc.WithInsecure())
	} else {
		// Note: On the Windows platform, use of x509.SystemCertPool() requires
		// go version 1.18 or higher.
		systemRoots, err := x509.SystemCertPool()
		if err != nil {
			return nil, err
		}
		cred := credentials.NewTLS(&tls.Config{
			RootCAs: systemRoots,
		})
		opts = append(opts, grpc.WithTransportCredentials(cred))
	}

	return grpc.Dial(host, opts...)
}

Como enviar solicitações gRPC sem autenticação

No exemplo a seguir, mostramos como enviar uma solicitação sem autenticação, usando uma conexão gRPC configurada conforme mencionado anteriormente.

Go

run/grpc-ping/request.go 

import (
	"context"
	"time"

	pb "github.com/GoogleCloudPlatform/golang-samples/run/grpc-ping/pkg/api/v1"
	"google.golang.org/grpc"
)

// pingRequest sends a new gRPC ping request to the server configured in the connection.
func pingRequest(conn *grpc.ClientConn, p *pb.Request) (*pb.Response, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	client := pb.NewPingServiceClient(conn)
	return client.Send(ctx, p)
}