Memanggil dengan gRPC

Halaman ini menampilkan detail khusus penayangan Knative untuk developer yang ingin menggunakan gRPC untuk menghubungkan layanan penayangan Knative dengan layanan lain, misalnya, untuk memberikan komunikasi performa tinggi yang sederhana antara microservice internal. Layanan Knative mendukung panggilan gRPC unary dan streaming.

Unary gRPC

Dalam panggilan RPC unary, klien mengirim 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, di mana klien mengirim permintaan ke server dan mendapatkan stream untuk dibaca yang berisi urutan pesan. Klien membaca aliran yang ditampilkan hingga tidak ada lagi pesan.

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

RPC streaming klien tempat klien menulis urutan pesan dan mengirimkannya ke server dalam aliran. 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 hal tambahan atau penayangan Knative khusus yang dapat 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 tambahan atau penayangan Knative khusus yang perlu ditambahkan ke klien yang menggunakan gRPC: ikuti dokumen gRPC tentang cara menggunakan definisi layanan dalam kode klien, dan contoh klien disediakan dalam tutorial gRPC bahasa khusus.

Memproses permintaan gRPC di layanan penayangan Knative

Satu-satunya persyaratan khusus untuk server gRPC yang berjalan di penayangan Knative adalah memproses port yang ditentukan oleh variabel lingkungan PORT 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 sehingga Anda dapat mengirim pesan gRPC, Anda harus menentukan domain host, yang merupakan URL layanan Knative serving atau domain kustom yang dipetakan ke layanan tersebut, bersama dengan 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)
}