Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Questa pagina mostra i dettagli specifici di Cloud Run per gli sviluppatori che
vogliono utilizzare gRPC per connettere un
servizio Cloud Run ad altri servizi, ad esempio per fornire
una comunicazione semplice e ad alte prestazioni tra microservizi
interni. Puoi utilizzare tutti i tipi di gRPC, streaming o unitario, con Cloud Run.
I possibili casi d'uso includono:
Comunicazione tra microservizi interni.
Carichi elevati di dati (gRPC utilizza i 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.
Utilizza gRPC in streaming nel server gRPC per creare applicazioni e API più reattive.
Per integrare il tuo servizio con gRPC:
Configura il servizio in modo che utilizzi HTTP/2 se utilizzi gRPC in streaming. HTTP/2
è il metodo di trasporto per lo streaming 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 ascoltare
la variabile di ambiente PORT.
Crea un client che invia richieste e gestisce le risposte del server gRPC.
Se vuoi, aggiungi l'autenticazione.
Crea ed esegui il deployment del tuo servizio.
Configurazione del servizio per l'utilizzo di HTTP/2
Google consiglia di configurare il servizio in modo che utilizzi HTTP/2 se utilizzi gRPC con Cloud Run. Sebbene alcune funzionalità gRPC semplici funzionino
senza utilizzare HTTP/2, molte funzionalità gRPC, come lo streaming e i metadati, richiedono HTTP/2.
Definire e compilare i messaggi in un file proto
Non ci sono elementi aggiuntivi o specifici di Cloud Run 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 ci sono elementi aggiuntivi o specifici di Cloud Run da aggiungere a un client che utilizza gRPC: segui la documentazione di gRPC sull'utilizzo delle definizioni di servizio nel codice client e gli esempi di client forniti nei tutorial gRPC specifici per la lingua.
Scalabilità automatica e bilanciamento del carico
Cloud Run utilizza bilanciatori del carico gestiti da Google che mantengono connessioni separate tra i client e le istanze Cloud Run.
Con gRPC, la scalabilità automatica si comporta nel seguente modo:
Le connessioni gRPC dai client terminano al bilanciatore del carico perimetrale. La modifica
delle impostazioni KeepAlive influisce solo sulla connessione al bilanciatore del carico, non sulle
istanze Cloud Run. Il client non riconosce quando un'istanza viene eliminata.
Durante la riduzione della scalabilità, il bilanciatore del carico chiude le connessioni inviando messaggi GOAWAY
alle istanze di backend durante l'arresto.
Durante lo scale out, il bilanciatore del carico crea nuove connessioni alle istanze di backend.
Tutte queste operazioni sono trasparenti per i clienti.
Durante la scalabilità automatica, molte istanze possono avviarsi ed eseguire il multiplexing in un'unica connessione tra il client e il bilanciatore del carico proxy.
La concorrenza è determinata dal numero massimo di richieste in parallelo per istanza
per i messaggi. Nello streaming, ogni stream viene conteggiato una volta rispetto al numero massimo di richieste simultanee.
In attesa di richieste gRPC in un servizio Cloud Run
L'unico requisito speciale per un server gRPC in esecuzione in
Cloud Run è l'ascolto sulla porta specificata dalla variabile di ambiente PORT
come mostrato nel seguente codice:
Vai
funcmain(){log.Printf("grpc-ping: starting server...")port:=os.Getenv("PORT")ifport==""{port="8080"log.Printf("Defaulting to port %s",port)}listener,err:=net.Listen("tcp",":"+port)iferr!=nil{log.Fatalf("net.Listen: %v",err)}grpcServer:=grpc.NewServer()pb.RegisterPingServiceServer(grpcServer,&pingService{})iferr=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 Cloud Run o il dominio personalizzato mappato a quel servizio, insieme alla porta 443, che è la porta che dovrebbe essere utilizzata da gRPC.
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:443funcNewConn(hoststring,insecurebool)(*grpc.ClientConn,error){varopts[]grpc.DialOptionifhost!=""{opts=append(opts,grpc.WithAuthority(host))}ifinsecure{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()iferr!=nil{returnnil,err}cred:=credentials.NewTLS(&tls.Config{RootCAs:systemRoots,})opts=append(opts,grpc.WithTransportCredentials(cred))}returngrpc.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 indicato 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.funcpingRequest(conn*grpc.ClientConn,p*pb.Request)(*pb.Response,error){ctx,cancel:=context.WithTimeout(context.Background(),30*time.Second)defercancel()client:=pb.NewPingServiceClient(conn)returnclient.Send(ctx,p)}
Invio di richieste gRPC con autenticazione
Il seguente esempio mostra come utilizzare l'autenticazione tra servizi se il servizio chiamante dispone dell'autorizzazione di invoker per il servizio ricevente. Tieni presente che
questo codice crea un'intestazione di autorizzazione con il token di identità corretto:
è obbligatorio. Le autorizzazioni richieste e l'intestazione di autorizzazione sono
descritte in dettaglio nell'autenticazione da servizio a servizio.
Vai
import("context""fmt""time""google.golang.org/api/idtoken""google.golang.org/grpc"grpcMetadata"google.golang.org/grpc/metadata"pb"github.com/GoogleCloudPlatform/golang-samples/run/grpc-ping/pkg/api/v1")// pingRequestWithAuth mints a new Identity Token for each request.// This token has a 1 hour expiry and should be reused.// audience must be the auto-assigned URL of a Cloud Run service or HTTP Cloud Function without port number.funcpingRequestWithAuth(conn*grpc.ClientConn,p*pb.Request,audiencestring)(*pb.Response,error){ctx,cancel:=context.WithTimeout(context.Background(),30*time.Second)defercancel()// Create an identity token.// With a global TokenSource tokens would be reused and auto-refreshed at need.// A given TokenSource is specific to the audience.tokenSource,err:=idtoken.NewTokenSource(ctx,audience)iferr!=nil{returnnil,fmt.Errorf("idtoken.NewTokenSource: %w",err)}token,err:=tokenSource.Token()iferr!=nil{returnnil,fmt.Errorf("TokenSource.Token: %w",err)}// Add token to gRPC Request.ctx=grpcMetadata.AppendToOutgoingContext(ctx,"authorization","Bearer "+token.AccessToken)// Send the request.client:=pb.NewPingServiceClient(conn)returnclient.Send(ctx,p)}
Codice di esempio per lo streaming gRPC
Per codice campione, consulta l'implementazione di RouteGuide nel tutorial di base di
gRPC per la lingua che preferisci. Quando utilizzi Go, ad esempio, consulta
Implementazione di RouteGuide.
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Difficile da capire","hardToUnderstand","thumb-down"],["Informazioni o codice di esempio errati","incorrectInformationOrSampleCode","thumb-down"],["Mancano le informazioni o gli esempi di cui ho bisogno","missingTheInformationSamplesINeed","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-09-04 UTC."],[],[],null,["# Using gRPC\n\nThis page shows Cloud Run-specific details for developers who\nwant to use [gRPC](https://grpc.io/) to connect a\nCloud Run service with other services, for example, to provide\nsimple, high performance communication between internal\nmicroservices. You can use [all gRPC types](https://grpc.io/docs/what-is-grpc/core-concepts#rpc-life-cycle),\nstreaming or unary, with Cloud Run.\n\nPossible use cases include:\n\n- Communication between internal microservices.\n- High loads of data (gRPC uses [protocol buffers](https://developers.google.com/protocol-buffers), which are up to seven times faster than REST calls).\n- Only a simple service definition is needed, you don't want to write a full client library.\n- Use streaming gRPCs in your gRPC server to build more responsive applications and APIs.\n\nTo integrate your service with gRPC:\n\n- Configure your service to use HTTP/2 if you are using streaming gRPC. HTTP/2 is the transport method for gRPC streaming.\n- Define the request messages and responses in a proto file and compile them.\n- Create a gRPC server to handle requests and return responses: it should listen to the `PORT` environment variable.\n- Create a client that sends requests and handles responses from the gRPC server.\n- Optionally, add authentication.\n- Build and deploy your service.\n\nConfiguring your service to use HTTP/2\n--------------------------------------\n\nGoogle recommends [configuring your service to use HTTP/2](/run/docs/configuring/http2) if you\nuse gRPC with Cloud Run. Although some simple gRPC features work\nwithout using HTTP/2, many gRPC features, such as streaming and metadata, require HTTP/2.\n\nDefining and compiling messages in a proto file\n-----------------------------------------------\n\nThere are no extra or Cloud Run-specific things to add to your proto\ndefinitions. Just as with any other use of gRPC, you use\n[gRPC protocol buffers](https://grpc.io/docs/guides/#working-with-protocol-buffers)\nfor service definitions and data serialization.\n\nCreating a gRPC client\n----------------------\n\nThere are no extra or Cloud Run specific things to add to a client\nthat uses gRPC: follow the gRPC docs on using service definitions in\n[client code](https://grpc.io/docs/guides/concepts/#using-the-api), and the\nsample clients provided in the language-specific\n[gRPC tutorials](https://grpc.io/docs/languages).\n\nAutoscaling and load balancing\n------------------------------\n\nCloud Run uses Google-managed load balancers that keep separate\nconnections between clients and your Cloud Run instances.\nWith gRPC, autoscaling behaves as follows:\n\n- gRPC connections from clients end at the edge load balancer. Adjusting `KeepAlive` settings only affects the connection to the load balancer, not the Cloud Run instances. The client doesn't recognize when an instance drops.\n- During scale-in, the load balancer closes connections by sending GOAWAY messages to the backend instances as they shut down.\n- During scale-out, the load balancer creates new connections to the backend instances. All these operations are transparent to clients.\n- During autoscaling, many instances can start up and multiplex into a single connection between the client and the proxy load balancer.\n- Concurrency is determined by the [maximum concurrent requests per instance](/run/docs/about-concurrency) for messages. In streaming, each stream is counted once against the maximum concurrent requests.\n\nListening for gRPC requests in a Cloud Run service\n--------------------------------------------------\n\nThe only special requirement for a gRPC server running in\nCloud Run is to listen at the port specified by the `PORT`\nenvironment variable as shown in the following code:\n\n\n### Go\n\n func main() {\n \tlog.Printf(\"grpc-ping: starting server...\")\n\n \tport := os.Getenv(\"PORT\")\n \tif port == \"\" {\n \t\tport = \"8080\"\n \t\tlog.Printf(\"Defaulting to port %s\", port)\n \t}\n\n \tlistener, err := net.Listen(\"tcp\", \":\"+port)\n \tif err != nil {\n \t\tlog.Fatalf(\"net.Listen: %v\", err)\n \t}\n\n \tgrpcServer := grpc.NewServer()\n \tpb.RegisterPingServiceServer(grpcServer, &pingService{})\n \tif err = grpcServer.Serve(listener); err != nil {\n \t\tlog.Fatal(err)\n \t}\n }\n\n\u003cbr /\u003e\n\nOpening a gRPC connection to a service\n--------------------------------------\n\nTo open a gRPC connection to a service so you can send gRPC messages, you need\nto specify the host domain, which is the URL of the Cloud Run service\nor the custom domain [mapped](/run/docs/mapping-custom-domains) to that service,\nalong with the port 443, which is the port expected to be used by gRPC.\n\n\n### Go\n\n\n import (\n \t\"crypto/tls\"\n \t\"crypto/x509\"\n\n \t\"google.golang.org/grpc\"\n \t\"google.golang.org/grpc/credentials\"\n )\n\n // NewConn creates a new gRPC connection.\n // host should be of the form domain:port, e.g., example.com:443\n func NewConn(host string, insecure bool) (*grpc.ClientConn, error) {\n \tvar opts []grpc.DialOption\n \tif host != \"\" {\n \t\topts = append(opts, grpc.WithAuthority(host))\n \t}\n\n \tif insecure {\n \t\topts = append(opts, grpc.WithInsecure())\n \t} else {\n \t\t// Note: On the Windows platform, use of x509.SystemCertPool() requires\n \t\t// Go version 1.18 or higher.\n \t\tsystemRoots, err := x509.SystemCertPool()\n \t\tif err != nil {\n \t\t\treturn nil, err\n \t\t}\n \t\tcred := credentials.NewTLS(&tls.Config{\n \t\t\tRootCAs: systemRoots,\n \t\t})\n \t\topts = append(opts, grpc.WithTransportCredentials(cred))\n \t}\n\n \treturn grpc.Dial(host, opts...)\n }\n\n\u003cbr /\u003e\n\nSending gRPC requests without authentication\n--------------------------------------------\n\nThe following sample shows how to send a request without authentication, using\na [gRPC connection](#connect) configured as mentioned previously.\n\n\n### Go\n\n\n import (\n \t\"context\"\n \t\"time\"\n\n \tpb \"github.com/GoogleCloudPlatform/golang-samples/run/grpc-ping/pkg/api/v1\"\n \t\"google.golang.org/grpc\"\n )\n\n // pingRequest sends a new gRPC ping request to the server configured in the connection.\n func pingRequest(conn *grpc.ClientConn, p *pb.Request) (*pb.Response, error) {\n \tctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)\n \tdefer cancel()\n\n \tclient := pb.NewPingServiceClient(conn)\n \treturn client.Send(ctx, p)\n }\n\n\u003cbr /\u003e\n\nSending gRPC requests with authentication\n-----------------------------------------\n\nThe following sample shows how to use authentication between services, if the\ncalling service has invoker permission to the receiving service. Notice that\nthis code creates an authorization header that has the proper identity token:\nthis is required. The required permissions and the authorization header are\ndescribed in detail in\n[service to service authentication](/run/docs/authenticating/service-to-service).\n\n\n### Go\n\n\n import (\n \t\"context\"\n \t\"fmt\"\n \t\"time\"\n\n \t\"google.golang.org/api/idtoken\"\n \t\"google.golang.org/grpc\"\n \tgrpcMetadata \"google.golang.org/grpc/metadata\"\n\n \tpb \"github.com/GoogleCloudPlatform/golang-samples/run/grpc-ping/pkg/api/v1\"\n )\n\n // pingRequestWithAuth mints a new Identity Token for each request.\n // This token has a 1 hour expiry and should be reused.\n // audience must be the auto-assigned URL of a Cloud Run service or HTTP Cloud Function without port number.\n func pingRequestWithAuth(conn *grpc.ClientConn, p *pb.Request, audience string) (*pb.Response, error) {\n \tctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)\n \tdefer cancel()\n\n \t// Create an identity token.\n \t// With a global TokenSource tokens would be reused and auto-refreshed at need.\n \t// A given TokenSource is specific to the audience.\n \ttokenSource, err := idtoken.NewTokenSource(ctx, audience)\n \tif err != nil {\n \t\treturn nil, fmt.Errorf(\"idtoken.NewTokenSource: %w\", err)\n \t}\n \ttoken, err := tokenSource.Token()\n \tif err != nil {\n \t\treturn nil, fmt.Errorf(\"TokenSource.Token: %w\", err)\n \t}\n\n \t// Add token to gRPC Request.\n \tctx = grpcMetadata.AppendToOutgoingContext(ctx, \"authorization\", \"Bearer \"+token.AccessToken)\n\n \t// Send the request.\n \tclient := pb.NewPingServiceClient(conn)\n \treturn client.Send(ctx, p)\n }\n\n\u003cbr /\u003e\n\nSample code for gRPC streaming\n------------------------------\n\nFor sample code, refer to the `RouteGuide` implementation in the\n[gRPC](https://grpc.io/) Basics tutorial for the\nlanguage of your choice. When using Go, for example, refer to\n[Implementing RouteGuide](https://grpc.io/docs/languages/go/basics/#implementing-routeguide)."]]