Memanggil dengan gRPC

Halaman ini menampilkan detail khusus penayangan Knative untuk developer yang ingin menggunakan gRPC untuk menghubungkan layanan penyaluran Knative dengan layanan lain, misalnya, untuk menyediakan komunikasi sederhana dan berperforma tinggi antara microservice dalam container. Penyajian Knative mendukung unary dan streaming panggilan gRPC.

gRPC Unary

Dalam panggilan RPC unary, klien mengirimkan satu permintaan ke server dan mendapatkan respons tunggal balik, mirip dengan panggilan fungsi normal:

rpc SayHello(HelloRequest) returns (HelloResponse);

Oke

Streaming gRPC

Opsi streaming berikut tersedia dengan gRPC. RPC streaming server tempat klien mengirimkan permintaan ke server dan mendapatkan {i>stream<i} untuk dibaca yang berisi urutan pesan. Klien membaca output yang ditampilkan mengalirkan pesan hingga tidak ada lagi pesan.

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

RPC streaming klien tempat klien menulis urutan pesan dan mengirim mereka ke server dalam sebuah aliran. Setelah klien selesai menulis pesan, menunggu server untuk mengembalikan responsnya.

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

RPC streaming dua arah tempat klien dan server mengirim pesan dalam dua {i>read-write<i} yang beroperasi secara independen.

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

Oke

Kemungkinan kasus penggunaan meliputi:

• Komunikasi antara microservice internal.
• Pemuatan data yang tinggi (gRPC menggunakan buffering protokol, yang hingga tujuh kali lebih cepat daripada panggilan REST).
• Hanya definisi layanan sederhana yang diperlukan, dan Anda tidak ingin menulis library klien secara lengkap.

Untuk mengintegrasikan layanan Anda dengan gRPC,

• Tentukan pesan dan respons permintaan dalam file proto, lalu kompilasikan.
• Buat server gRPC untuk menangani permintaan dan menampilkan respons: server tersebut harus memproses variabel lingkungan PORT.
• Buat klien yang mengirim permintaan dan menangani respons dari server gRPC.
• Secara opsional, tambahkan autentikasi.
• Build dan deploy layanan Anda.

Menentukan dan mengompilasi pesan dalam file proto

Tidak ada tambahan atau Knative yang menyajikan hal khusus untuk ditambahkan ke proto Anda definisi. Sama seperti penggunaan gRPC lainnya, Anda menggunakan buffering protokol gRPC untuk definisi layanan dan serialisasi data.

Membuat klien gRPC

Tidak ada tambahan atau Knative yang menyajikan hal-hal khusus untuk ditambahkan ke klien yang menggunakan gRPC: ikuti dokumen gRPC tentang penggunaan definisi layanan dalam kode klien, dan contoh klien yang disediakan dalam bahasa Tutorial gRPC.

Memproses permintaan gRPC dalam layanan penayangan Knative

Satu-satunya persyaratan khusus untuk server gRPC yang berjalan di Penyajian Knative adalah memantau port yang ditentukan oleh PORT variabel lingkungan seperti yang ditunjukkan dalam kode:

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

Membuka koneksi gRPC ke layanan

Untuk membuka koneksi gRPC ke layanan agar dapat mengirim pesan gRPC, Anda memerlukan untuk menentukan domain host, yang merupakan URL layanan penayangan Knative atau domain kustom yang dipetakan ke layanan tersebut, bersama dengan port 443, yang merupakan porta yang diharapkan akan digunakan oleh gRPC.

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

Mengirim permintaan gRPC tanpa autentikasi

Contoh berikut menunjukkan cara mengirim permintaan tanpa autentikasi, menggunakan koneksi gRPC yang dikonfigurasi seperti yang disebutkan sebelumnya.

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