Menyiapkan layanan gRPC tanpa proxy

Catatan: Panduan ini hanya mendukung Cloud Service Mesh dengan Google Cloud API dan tidak mendukung Istio API. Untuk mengetahui informasi selengkapnya, lihat Ringkasan Cloud Service Mesh.

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

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

Sebelum memulai

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

Mengonfigurasi resource Mesh

Saat aplikasi gRPC tanpa proxy terhubung ke xds:///hostname, library klien gRPC akan membuat koneksi ke Cloud Service Mesh. Library klien menggunakan koneksi untuk mendapatkan konfigurasi perutean yang diperlukan untuk merutekan permintaan untuk nama host.

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

1. Buat spesifikasi Mesh dan simpan dalam file bernama mesh.yaml.

   name: grpc-mesh

2. 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 menayangkan konfigurasi, tetapi karena belum ada layanan yang ditentukan, konfigurasi akan 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 otomatis dalam grup instance terkelola. VM menayangkan frasa hello world menggunakan protokol gRPC di port 50051.

1. Buat file konfigurasi cloud-init.yaml yang mendeklarasikan layanan systemd untuk menjalankan penampung helloworld di port 50051:

   #cloud-config
   write_files:
   - path: /etc/systemd/system/grpc-server.service
     permissions: '0644'
     owner: root
     content: |
       [Unit]
       Description=gRPC Server Container
       After=network-online.target docker.service
       Wants=network-online.target
       Requires=docker.service
   
       [Service]
       TimeoutStartSec=0
       Restart=always
       ExecStartPre=-/usr/bin/docker stop %n
       ExecStartPre=-/usr/bin/docker rm %n
       ExecStart=/usr/bin/docker run --rm --name %n --net=host grpc/java-example-hostname:1.83.1
       ExecStop=/usr/bin/docker stop %n
   
   runcmd:
   - iptables -A INPUT -p tcp --dport 50051 -j ACCEPT
   - systemctl daemon-reload
   - systemctl start --no-block grpc-server.service
   

2. Buat template instance VM Compute Engine menggunakan Container-Optimized OS (cos-stable):

   gcloud compute instance-templates create grpc-td-vm-template \
     --image-project=cos-cloud \
     --image-family=cos-stable \
     --metadata-from-file=user-data=cloud-init.yaml \
     --tags=allow-health-checks \
     --scopes=cloud-platform

3. Buat grup instance terkelola berdasarkan template tersebut:

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

4. Buat port bernama untuk layanan gRPC. Port bernama adalah port tempat layanan gRPC memproses permintaan. Dalam contoh berikut, port bernama adalah 50051:

   gcloud compute instance-groups set-named-ports grpc-td-mig \
    --named-ports=grpc-helloworld-port:50051 \
    --zone=ZONE

5. Buat health check gRPC. Layanan harus menerapkan protokol health check gRPC agar health check gRPC berfungsi dengan baik. Untuk mengetahui informasi selengkapnya, lihat health check.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port

6. Buat 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

7. Buat layanan backend global dengan skema load balancing INTERNAL_SELF_MANAGED dan tambahkan health check ke layanan backend. Port yang ditentukan di sini digunakan untuk terhubung ke VM di 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

8. Tambahkan grup instance terkelola ke layanan backend.

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

Resource dan layanan Mesh telah dikonfigurasi. Di bagian berikutnya, Anda akan menyiapkan perutean.

Menyiapkan perutean dengan GRPCRoute

Gunakan petunjuk berikut untuk menyiapkan perutean.

1. Buat spesifikasi GRPCRoute dan simpan 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

2. 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 untuk menyeimbangkan beban traffic untuk layanan yang ditentukan dalam resource GRPCRoute di seluruh backend dalam grup instance terkelola.

Membuat klien gRPC

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

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

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

1. Buat VM klien.

   gcloud compute instances create grpc-client \
     --zone=ZONE\
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --image-family=debian-12 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#!/bin/bash
   set -ex
   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.19.0.tar.gz | tar -xz
   ./td-grpc-bootstrap-0.19.0/td-grpc-bootstrap --config-mesh=grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Menyiapkan file bootstrap

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

Catatan: Sesuai kebijakan, kami mendorong pengguna untuk memeriksa update generator bootstrap gRPC TD setiap tahun.

Untuk memverifikasi konfigurasi, login ke VM klien dan jalankan perintah berikut.

1. SSH ke VM klien.

   gcloud compute ssh grpc-client --zone=ZONE

2. Download dan instal alat grpcurl.

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

3. Jalankan alat grpcurl dengan xds:///helloworld-gce sebagai URI layanan dan helloworld.Greeter/SayHello sebagai nama layanan dan metode yang akan dipanggil. 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 adalah nama salah satu instance VM server gRPC:

   {
     "message": "Hello world, from INSTANCE_HOSTNAME"
   }
   

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

Langkah berikutnya

• Untuk mengetahui informasi tentang cara mencantumkan resource rute yang terkait dengan resource Mesh atau Gateway, lihat Mencantumkan resource Route.