Richiamo con gRPC

Questa pagina mostra i dettagli specifici di Cloud Run for Anthos per gli sviluppatori che vogliono utilizzare gRPC per connettere un servizio Cloud Run for Anthos ad altri servizi, ad esempio per fornire comunicazioni semplici e ad alte prestazioni tra microservizi interni. Cloud Run for Anthos supporta le chiamate gRPC unaria e in streaming.

gRPC unary

In una chiamata RPC unaria, il client invia una singola richiesta al server e riceve una singola risposta, come una normale chiamata a funzione: 
rpc SayHello(HelloRequest) returns (HelloResponse);

Streaming gRPC

Con gRPC sono disponibili le seguenti opzioni di streaming. Il server di streaming RPC in cui il client invia una richiesta al server e riceve un flusso di lettura contenente una sequenza di messaggi. Il client legge il flusso restituito finché non ci sono più messaggi. 

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

Il client esegue il flusso di RPC in cui il client scrive una sequenza di messaggi e li invia al server in un flusso. Dopo che il client ha finito di scrivere i messaggi, attende che il server restituisca la risposta. 

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

RPC di flusso bidirezionale in cui il client e il server inviano messaggi in due flussi di lettura-scrittura che operano in modo indipendente. 

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

I possibili casi d'uso includono:

  • Comunicazione tra microservizi interni.
  • Carichi di dati elevati (gRPC utilizza i buffer di protocollo, che sono fino a sette volte più veloci delle chiamate REST).
  • È necessaria solo una definizione di servizio semplice, non vuoi scrivere una libreria client completa.

Per integrare il tuo servizio con gRPC,

  • Definisci i messaggi di richiesta e le risposte in un file di protocollo e compilali.
  • Creare un server gRPC per gestire le richieste e restituire le risposte: deve rimanere in ascolto della variabile di ambiente PORT.
  • Creare un client che invii richieste e gestisca le risposte dal server gRPC.
  • Se vuoi, aggiungi l'autenticazione.
  • Crea ed esegui il deployment del tuo servizio.

Definizione e compilazione dei messaggi in un file protocollo

Non ci sono elementi aggiuntivi o Cloud Run for Anthos da aggiungere alle definizioni di protocollo. Come con qualsiasi altro utilizzo di gRPC, utilizzi i buffer di protocollo gRPC per le definizioni dei servizi e la serializzazione dei dati.

Creazione di un client gRPC

Non ci sono elementi specifici o Cloud Run for Anthos da aggiungere a un client che utilizza gRPC: segui i documenti gRPC sull'utilizzo delle definizioni dei servizi in codice client e i client di esempio forniti nei tutorial gRPC specifici per i vari linguaggi.

In ascolto delle richieste gRPC in un servizio Cloud Run for Anthos

L'unico requisito speciale per un server gRPC in esecuzione in Cloud Run for Anthos è l'ascolto sulla porta specificata dalla variabile di ambiente PORT, come mostrato nel codice:

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)
	}
}

Apertura di una connessione gRPC a un servizio

Per aprire una connessione gRPC a un servizio in modo da poter inviare messaggi gRPC, devi specificare il dominio host, che è l'URL del servizio Cloud Run for Anthos o il dominio personalizzato mappato a quel servizio, oltre alla porta 443, che è la porta che dovrebbe essere utilizzata da 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 {
		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...)
}

Invio di richieste gRPC senza autenticazione

L'esempio seguente mostra come inviare una richiesta senza autenticazione, utilizzando una connessione gRPC configurata in precedenza.

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)
}