Versi 1.20

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Halaman ini diterjemahkan oleh Cloud Translation API.

Menyiapkan layanan gRPC tanpa proxy

Panduan ini menunjukkan cara menyiapkan mesh layanan gRPC tanpa proxy dengan Resource Mesh dan GRPCRoute.

Layanan gRPC tanpa proxy dengan resource GRPCRoute dan Mesh — Layanan gRPC tanpa proxy dengan resource `GRPCRoute` dan `Mesh` (klik untuk memperbesar)

Sebelum memulai

Pastikan Anda membaca Persiapan untuk menyiapkan workload Envoy dan tanpa proxy serta menyelesaikan prasyarat yang dijelaskan dalam dokumen tersebut.

Mengonfigurasi resource `Mesh`

Saat aplikasi gRPC tanpa proxy terhubung ke xds://hostname, gRPC library klien membuat koneksi ke Cloud Service Mesh. Library klien menggunakan koneksi untuk mendapatkan konfigurasi {i>routing<i} yang diperlukan untuk merutekan untuk nama host.

Pastikan Anda mencatat nama resource Mesh, yang merupakan kunci yang yang digunakan aplikasi gRPC tanpa proxy untuk meminta konfigurasi yang terkait dengan Mesh ini.

Buat spesifikasi Mesh dan simpan dalam file bernama mesh.yaml.
```
name: grpc-mesh
```

Buat resource Mesh menggunakan spesifikasi mesh.yaml:

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Setelah resource Mesh dibuat, Cloud Service Mesh siap menyalurkan Namun, karena belum ada layanan yang ditentukan, kosong. Di bagian berikutnya, Anda akan menentukan layanan dan melampirkannya ke Resource Mesh.

Mengonfigurasi server gRPC

Untuk tujuan demonstrasi, Anda membuat layanan backend dengan VM yang diskalakan secara otomatis dalam grup instance terkelola. VM melayani frasa hello world menggunakan protokol gRPC pada port 50051.

Buat template instance VM Compute Engine dengan Layanan gRPC helloworld yang ditampilkan pada port 50051:

gcloud compute instance-templates create grpc-td-vm-template \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --image-family=debian-10 \
   --image-project=debian-cloud \
   --metadata-from-file=startup-script=<(echo '#! /bin/bash
 set -e
 cd /root
 sudo apt-get update -y
 sudo apt-get install -y openjdk-11-jdk-headless
 curl -L https://github.com/grpc/grpc-java/archive/v1.38.0.tar.gz | tar -xz
 cd grpc-java-1.38.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Buat grup instance terkelola berdasarkan template tersebut:

gcloud compute instance-groups managed create grpc-td-mig-us-east1 \
  --zone=ZONE \
  --size=2 \
  --template=grpc-td-vm-template

Buat port bernama untuk layanan gRPC. Porta yang dinamai adalah porta tempat layanan gRPC memproses permintaan. Pada contoh berikut, port bernama adalah 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Membuat health check gRPC. Layanan harus menerapkan Protokol health check gRPC agar health check gRPC berfungsi dengan baik. Untuk informasi selengkapnya, lihat health check.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Membuat aturan firewall untuk mengizinkan koneksi health check ke instance di jaringan Anda:

gcloud compute firewall-rules create grpc-vm-allow-health-checks \
  --network=default \
  --action=ALLOW \
  --direction=INGRESS \
  --source-ranges=35.191.0.0/16,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules=tcp:50051

Membuat layanan backend global dengan skema load balancing INTERNAL_SELF_MANAGED dan menambahkan respons memeriksa layanan backend. Porta yang ditentukan di sini digunakan untuk terhubung ke atau VM dalam grup instance terkelola.

gcloud compute backend-services create grpc-helloworld-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --protocol=GRPC \
  --port-name=grpc-helloworld-port \
  --health-checks grpc-helloworld-health-check

Tambahkan grup instance terkelola ke layanan backend.

gcloud compute backend-services add-backend \
  grpc-helloworld-service \
  --instance-group=grpc-td-mig-us-east1 \
  --instance-group-zone=ZONE \
  --global

Resource dan layanan Mesh dikonfigurasi. Pada bagian berikutnya, Anda akan ke atas.

Siapkan pemilihan rute dengan `GRPCRoute`

Gunakan petunjuk berikut untuk menyiapkan pemilihan rute.

Membuat spesifikasi GRPCRoute dan menyimpannya dalam file bernama grpc_route.yaml.

Anda dapat menggunakan PROJECT_ID atau PROJECT_NUMBER.

name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-helloworld-service

Buat resource GrpcRoute menggunakan spesifikasi grpc_route.yaml:

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

Cloud Service Mesh kini dikonfigurasi guna melakukan load balancing terhadap traffic untuk layanan ditentukan dalam resource GRPCRoute di seluruh backend dalam instance terkelola ras.

Membuat klien gRPC

Anda dapat memverifikasi konfigurasi dengan membuat instance gRPC tanpa proxy dan menghubungkannya ke Cloud Service Mesh. Dalam file bootstrap-nya, harus menentukan jaringan VPC yang ditunjukkan dalam Mesh.

Setelah dikonfigurasi, aplikasi dapat mengirimkan permintaan ke instance atau endpoint yang terkait dengan helloworld-gce menggunakan xds:///helloworld-gce URI layanan.

Pada contoh berikut, Anda menggunakan alat grpcurl untuk menguji gRPC layanan.

Membuat VM klien.

gcloud compute instances create grpc-client \
  --zone=ZONE\
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#! /bin/bash
set -e
export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Menyiapkan file bootstrap

Aplikasi klien harus memiliki file konfigurasi bootstrap. Startup skrip di bagian sebelumnya menetapkan GRPC_XDS_BOOTSTRAP variabel lingkungan dan menggunakan skrip helper untuk menghasilkan file bootstrap. Nilai untuk TRAFFICDIRECTOR_GCP_PROJECT_NUMBER dan zona di file bootstrap yang dihasilkan diperoleh dari server metadata yang mengetahui secara mendetail tentang instance VM Anda. Anda dapat memberikan nilai ini kepada helper skrip secara manual menggunakan opsi --gcp-project-number. Anda harus berikan nama mesh yang cocok dengan resource Mesh menggunakan --config-mesh-experimental.

Untuk memverifikasi konfigurasi, login ke VM klien dan jalankan mengikuti.

SSH ke VM klien.
```
gcloud compute ssh grpc-client
```

Download dan instal alat grpcurl.

curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.8.1/grpcurl_1.8.1_linux_x86_64.tar.gz | tar -xz

Jalankan alat grpcurl dengan xds:///helloworld-gce sebagai URI layanan dan helloworld.Greeter/SayHello sebagai nama layanan dan metode yang akan dipanggil. Tujuan parameter ke metode SayHello diteruskan menggunakan opsi -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello
```

Anda akan melihat output yang mirip dengan berikut ini, dengan INSTANCE_HOSTNAME sebagai nama instance VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME

Output memverifikasi bahwa klien gRPC tanpa proxy berhasil terhubung Cloud Service Mesh dan mempelajari backend untuk Layanan helloworld-gce menggunakan resolver nama xds. Klien mengirim permintaan ke salah satu backend layanan tanpa perlu tahu tentang alamat IP atau melakukan resolusi DNS.

Langkah selanjutnya

Untuk informasi tentang cara mencantumkan resource rute yang terkait dengan Mesh atau Gateway, lihat Mencantumkan resource Route. Fitur ini sedang dalam Pratinjau.