Memanggil dengan gRPC

Halaman ini menunjukkan detail khusus penayangan Knative bagi developer yang ingin menggunakan gRPC untuk menghubungkan layanan penayangan Knative dengan layanan lain, misalnya, untuk menyediakan komunikasi yang sederhana dan berperforma tinggi antara microservice internal. Penayangan Knative mendukung panggilan gRPC unary dan streaming.

Unary gRPC

Pada panggilan RPC unary, klien mengirimkan satu permintaan ke server dan mendapatkan satu respons kembali, mirip dengan panggilan fungsi normal:

rpc SayHello(HelloRequest) returns (HelloResponse);

Oke

Streaming gRPC

Opsi streaming berikut tersedia dengan gRPC. RPC streaming server tempat klien mengirim permintaan ke server dan mendapatkan streaming untuk dibaca yang berisi urutan pesan. Klien membaca streaming yang ditampilkan hingga tidak ada pesan lagi.

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

RPC streaming klien tempat klien menulis urutan pesan dan mengirimkannya ke server dalam streaming. Setelah klien selesai menulis pesan, klien menunggu server menampilkan responsnya.

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

RPC streaming dua arah tempat klien dan server mengirim pesan dalam dua aliran baca-tulis 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 menayangkan hal-hal tertentu untuk ditambahkan ke definisi proto Anda. Sama seperti penggunaan gRPC lainnya, Anda menggunakan buffering protokol gRPC untuk definisi layanan dan serialisasi data.

Membuat klien gRPC

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

Memproses permintaan gRPC dalam layanan penyaluran Knative

Satu-satunya persyaratan khusus untuk server gRPC yang berjalan dalam penayangan Knative adalah melakukan pemrosesan di port yang ditentukan oleh variabel lingkungan PORT seperti yang ditunjukkan pada 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 harus menentukan domain host, yaitu URL layanan penayangan Knative atau domain kustom yang dipetakan ke layanan tersebut, beserta port 443, yang merupakan port 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)
}