Richiamo con gRPC

Questa pagina mostra i dettagli specifici di Knative Serving per gli sviluppatori che vogliono utilizzare gRPC per connettere un servizio Knative Serving ad altri servizi, ad esempio per fornire una comunicazione semplice e ad alte prestazioni tra microservizi interni. Knative Serving supporta sia le chiamate gRPC unarie sia quelle di streaming.

gRPC unario

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

Streaming gRPC

Le seguenti opzioni di streaming sono disponibili con gRPC. RPC di streaming del server in cui il client invia una richiesta al server e riceve uno stream da leggere contenente una sequenza di messaggi. Il client legge lo stream restituito finché non ci sono altri messaggi. 

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

RPC di streaming del client in cui il client scrive una sequenza di messaggi e li invia al server in uno stream. Al termine della scrittura dei messaggi, il client attende che il server restituisca la risposta. 

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

RPC di streaming bidirezionali in cui client e server inviano messaggi in due stream 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 elevati di dati (gRPC utilizza buffer di protocollo, che sono fino a sette volte più veloci delle chiamate REST).
  • È necessaria solo una semplice definizione del servizio, non vuoi scrivere una libreria client completa.

Per integrare il servizio con gRPC:

  • Definisci i messaggi di richiesta e le risposte in un file proto e compilali.
  • Crea un server gRPC per gestire le richieste e restituire le risposte: deve essere in ascolto della variabile di ambiente PORT.
  • Crea un client che invia richieste e gestisce le risposte dal server gRPC.
  • Se vuoi, aggiungi l'autenticazione.
  • Crea e implementa il servizio.

Definizione e compilazione dei messaggi in un file proto

Non sono necessari elementi aggiuntivi o specifici di Knative Serving da aggiungere alle definizioni proto. Come per 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 sono necessari elementi aggiuntivi o specifici di Knative Serving da aggiungere a un client che utilizza gRPC: segui la documentazione di gRPC sull'utilizzo delle definizioni dei servizi nel codice client e i client di esempio forniti nei tutorial gRPC specifici per la lingua.

Ascolto delle richieste gRPC in un servizio Knative Serving

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

Vai 

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, ovvero l'URL del servizio Knative Serving o il dominio personalizzato mappato a quel servizio, insieme alla porta 443, che è la porta che gRPC dovrebbe utilizzare.

Vai 


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

Invio di richieste gRPC senza autenticazione

Il seguente esempio mostra come inviare una richiesta senza autenticazione utilizzando una connessione gRPC configurata come descritto in precedenza.

Vai 


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