Menyiapkan VM Compute Engine dan layanan gRPC tanpa proxy
Panduan ini menunjukkan cara mengonfigurasi host VM Compute Engine, aplikasi gRPC, dan komponen load balancing yang diperlukan Cloud Service Mesh.
Sebelum mengikuti petunjuk dalam panduan ini, tinjau Persiapan untuk menyiapkan Cloud Service Mesh dengan layanan gRPC tanpa proxy
Ringkasan
Menyiapkan Cloud Service Mesh dengan virtual machine (VM) Compute Engine dan layanan gRPC tanpa proxy melibatkan hal berikut:
- Menyiapkan grup instance terkelola yang menghosting backend Anda.
- Mengonfigurasi backend untuk menjalankan server gRPC yang menampilkan
hello world
sebagai respons terhadap permintaan dari klien. - Mengonfigurasi Cloud Service Mesh menggunakan grup instance terkelola dan komponen load balancing Google Cloud lainnya.
- Memverifikasi bahwa deployment berfungsi dengan benar menggunakan aplikasi klien gRPC tanpa proxy untuk mengirim traffic ke aplikasi server gRPC.
Klien gRPC tanpa proxy terhubung ke Cloud Service Mesh menggunakan xDS. Saat klien terhubung ke Cloud Service Mesh, Cloud Service Mesh akan mengirimkan informasi ke klien tentang backend yang terkait dengan layanan hello world
. Dengan menggunakan informasi ini, klien gRPC tanpa proxy akan mengirimkan permintaan ke
server gRPC hello world
.
Mengonfigurasi grup instance terkelola untuk Cloud Service Mesh
Grup instance terkelola menggunakan penskalaan otomatis untuk membuat VM backend baru, sesuai kebutuhan deployment Anda. Contoh ini menunjukkan cara melakukan hal berikut:
- Buat template instance dengan layanan contoh yang menyalurkan
layanan
hello world
menggunakan protokol gRPC. - Konfigurasikan grup instance terkelola menggunakan template ini.
Membuat template instance
Bagian ini berisi petunjuk untuk membuat template instance. Dalam
contoh, Anda men-deploy layanan gRPC helloworld
yang diekspos pada port
50051.
Konsol
- Di konsol Google Cloud, buka halaman Instance Templates.
- Klik Create instance template.
Isi kolom sebagai berikut:
- Nama: grpc-td-vm-template
- Versi boot disk: Debian / Linux 10
- Akun layanan: Akun layanan default Compute Engine
- Cakupan akses: Izinkan akses penuh ke semua Google Cloud API
Di bagian Firewall, pilih kotak di samping Allow HTTP traffic dan Allow HTTPS traffic.
Klik Management, Security, Disks, Networking, Sole Tenancy.
Di tab Management, salin skrip berikut ke kolom Startup script.
#! /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.37.0.tar.gz | tar -xz cd grpc-java-1.37.0/examples/example-hostname ../gradlew --no-daemon installDist # Server listens on 50051 sudo systemd-run ./build/install/hostname-server/bin/hostname-server
Klik Create.
gcloud
Membuat template instance.
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.37.0.tar.gz | tar -xz cd grpc-java-1.37.0/examples/example-hostname ../gradlew --no-daemon installDist # Server listens on 50051 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')
Membuat grup instance terkelola
Di bagian ini, Anda akan membuat grup instance terkelola menggunakan template instance yang telah dibuat di bagian sebelumnya.
Konsol
- Buka halaman Grup Instance di Konsol Google Cloud.
- Klik Create an instance group. Secara default, Anda akan melihat halaman untuk membuat grup instance terkelola.
- Masukkan
grpc-td-mig-us-central1
sebagai nama untuk grup instance terkelola, lalu pilih zonaus-central1-a
. - Di bagian Instance template, pilih
grpc-td-vm-template
, yang merupakan template instance yang Anda buat. - Tentukan 2 sebagai jumlah minimum dan maksimum instance yang ingin Anda buat dalam grup.
- Klik Create.
gcloud
Membuat grup instance terkelola.
gcloud compute instance-groups managed create grpc-td-mig-us-central1 \ --zone us-central1-a \ --size=2 \ --template=grpc-td-vm-template
Mengonfigurasi port bernama
Di bagian ini, Anda akan mengonfigurasi port bernama untuk layanan gRPC. Port yang dinamai adalah port tempat layanan gRPC memproses permintaan. Dalam contoh ini, port yang dinamai adalah port 50051.
Konsol
- Buka halaman Grup Instance di Konsol Google Cloud.
- Klik nama grup instance
grpc-td-mig-us-central1
yang telah Anda buat. - Klik Edit grup.
- Di kolom Nama port, masukkan
grpc-helloworld-port
. - Di kolom Nomor port, masukkan
50051
. - Klik Simpan.
gcloud
Konfigurasi port yang bernama.
gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \ --named-ports=grpc-helloworld-port:50051 \ --zone us-central1-a
Mengonfigurasi Cloud Service Mesh dengan komponen load balancing Google Cloud
Bagian ini berisi petunjuk untuk mengonfigurasi Cloud Service Mesh dengan komponen load balancing Google Cloud untuk layanan Anda.
Membuat health check, aturan firewall, dan layanan backend
Di bagian ini, Anda akan membuat layanan backend global
dengan skema load balancing INTERNAL_SELF_MANAGED
dan protokol GRPC
,
lalu mengaitkan health check dan grup instance dengan layanan backend.
Dalam contoh ini, Anda menggunakan grup instance terkelola yang Anda buat saat Membuat grup instance terkelola. Grup instance terkelola ini
menjalankan layanan gRPC contoh. Port di tanda --port-name
adalah port bernama
yang Anda buat di Mengonfigurasi port bernama.
gcloud
Buat health check.
gcloud compute health-checks create grpc grpc-helloworld-health-check \ --use-serving-port
Membuat aturan firewall health check.
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.
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-central1 \ --instance-group-zone us-central1-a \ --global
Membuat peta aturan perutean, proxy target, dan aturan penerusan
Di bagian ini, Anda akan membuat peta URL, pencocok jalur, dan aturan host untuk merutekan traffic untuk layanan Anda berdasarkan nama host dan jalur. Contoh berikut
menggunakan helloworld-gce
sebagai nama layanan. Aplikasi gRPC menggunakan nama
layanan ini dalam URI target saat terhubung ke layanan ini. Secara default, pencocok jalur cocok dengan semua permintaan jalur (/*
) untuk host ini. Anda juga membuat
proxy gRPC dan aturan penerusan target.
Untuk informasi selengkapnya, lihat Peta aturan pemilihan rute.
Pada contoh berikut, port 80 adalah port yang ditentukan.
gcloud
Membuat peta URL.
gcloud compute url-maps create grpc-vm-url-map \ --default-service grpc-helloworld-service
Membuat pencocok jalur.
gcloud compute url-maps add-path-matcher grpc-vm-url-map \ --default-service grpc-helloworld-service \ --path-matcher-name grpc-vm-path-matcher \ --new-hosts helloworld-gce
Buat proxy gRPC target.
gcloud compute target-grpc-proxies create grpc-vm-proxy \ --url-map grpc-vm-url-map \ --validate-for-proxyless
Membuat aturan penerusan.
gcloud compute forwarding-rules create grpc-vm-forwarding-rule \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --address=0.0.0.0 --address-region=us-central1 \ --target-grpc-proxy=grpc-vm-proxy \ --ports 80 \ --network default
Cloud Service Mesh sekarang dikonfigurasi untuk melakukan load balancing terhadap traffic di seluruh backend dalam grup instance terkelola untuk layanan yang ditentukan dalam peta URL.
Memverifikasi konfigurasi
Setelah proses konfigurasi selesai, pastikan bahwa Anda dapat membuat koneksi gRPC ke layanan load balancing Cloud Service Mesh yang Anda buat sebelumnya.
Untuk memverifikasi bahwa layanan tersedia, lakukan salah satu hal berikut:
- Login ke salah satu host VM (backend layanan gRPC) dan pastikan layanan gRPC berjalan pada port yang memproses. Dalam contoh, port-nya adalah 50051.
- Buka halaman Cloud Service Mesh di Konsol untuk mengetahui informasi tentang
helloworld-gce
layanan yang dikonfigurasi, dan pastikan backend dilaporkan responsif. - Gunakan petunjuk berikut untuk menggunakan klien gRPC Compute Engine untuk verifikasi.
Memverifikasi layanan dengan aplikasi klien gRPC
Pada contoh berikut, Anda menggunakan klien gRPC dalam bahasa pilihan Anda
atau alat grpcurl
untuk menguji layanan gRPC.
Pertama, buat VM klien tempat Anda menjalankan klien gRPC untuk menguji layanan.
gcloud compute instances create grpc-client \ --zone us-central1-a \ --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 # Expose bootstrap variable to SSH connections echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh # Create the bootstrap file curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.11.0.tar.gz | tar -xz ./td-grpc-bootstrap-0.11.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')
Menyiapkan variabel lingkungan dan file bootstrap
Aplikasi klien memerlukan file konfigurasi bootstrap. Skrip startup
di bagian sebelumnya menetapkan variabel lingkungan GRPC_XDS_BOOTSTRAP
dan
menggunakan skrip helper untuk menghasilkan file bootstrap. Nilai untuk
TRAFFICDIRECTOR_GCP_PROJECT_NUMBER
, TRAFFICDIRECTOR_NETWORK_NAME
, dan
zone
dalam file bootstrap yang dihasilkan diperoleh dari server metadata
yang mengetahui detail mengenai instance VM Compute Engine Anda ini. Anda dapat memberikan nilai ini ke skrip helper secara manual menggunakan opsi -gcp-project-number
dan -vpc-network-name
.
Untuk memverifikasi konfigurasi, login ke VM klien dan jalankan contoh berikut.
Java
Untuk memverifikasi layanan dengan klien Java gRPC:
Download versi terbaru Java gRPC, dengan patch terbaru dan bangun aplikasi klien
xds-hello-world
.sudo apt-get update -y sudo apt-get install -y openjdk-11-jdk-headless curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz cd grpc-java-1.37.0/examples/example-xds ../gradlew --no-daemon installDist
Jalankan klien dengan
world
sebagai namanya danxds:///helloworld-gce
sebagai URI layanan../build/install/example-xds/bin/xds-hello-world-client "world" \ xds:///helloworld-gce
Go
Untuk memverifikasi layanan dengan klien gRPC Go:
Download versi terbaru gRPC Go, dengan patch terbaru, dan bangun aplikasi klien
xds-hello-world
.sudo apt-get update -y sudo apt-get install -y golang git curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz cd grpc-go-1.37.0/examples/features/xds/client go get google.golang.org/grpc@v1.37.0 go build .
Jalankan klien dengan
world
sebagai namanya danxds:///helloworld-gce
sebagai URI layanan../client "world" xds:///helloworld-gce
C++
Untuk memverifikasi layanan dengan klien gRPC C++:
Download versi terbaru gRPC C++, dengan patch terbaru, dan buat contoh klien
helloworld
.sudo apt-get update -y sudo apt-get install -y build-essential cmake git git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc cd grpc mkdir -p cmake/build pushd cmake/build cmake ../.. make sudo make install popd mkdir -p third_party/abseil-cpp/cmake/build pushd third_party/abseil-cpp/cmake/build cmake ../.. make sudo make install popd cd examples/cpp/helloworld mkdir -p cmake/build cd cmake/build/ cmake ../.. make
Jalankan klien dengan "xds:///helloworld-gce" sebagai URI layanan.
./greeter_client --target=xds:///helloworld-gce
Grpcurl
Untuk memverifikasi layanan menggunakan alat grpcurl
:
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 danhelloworld.Greeter/SayHello
sebagai nama dan metode layanan yang akan dipanggil. Parameter ke metodeSayHello
diteruskan menggunakan opsi-d
../grpcurl --plaintext \ -d '{"name": "world"}' \ xds:///helloworld-gce helloworld.Greeter/SayHello
Python
Untuk memverifikasi layanan dengan klien Python gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.
sudo apt-get update sudo apt-get -y install python3-pip sudo pip3 install virtualenv curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz cd grpc-1.37.1/examples/python/xds virtualenv venv -p python3 source venv/bin/activate pip install -r requirements.txt python client.py xds:///helloworld-gce
Ruby
Untuk memverifikasi layanan dengan klien gRPC Ruby, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.
sudo apt-get update sudo apt-get install -y ruby-full sudo gem install grpc curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz cd grpc-1.37.1/examples/ruby ruby greeter_client.rb john xds:///helloworld-gce
PHP
Untuk memverifikasi layanan dengan klien PHP gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.
sudo apt-get update sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git sudo pecl install grpc curl -sS https://getcomposer.org/installer | php sudo mv composer.phar /usr/local/bin/composer curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz cd grpc-1.37.1 export CC=/usr/bin/gcc ./tools/bazel build @com_google_protobuf//:protoc ./tools/bazel build src/compiler:grpc_php_plugin cd examples/php composer install ./../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \ --php_out=. --grpc_out=. \ --plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \ ../protos/helloworld.proto php -d extension=grpc.so greeter_client.php john xds:///helloworld-gce
Node.js
Untuk memverifikasi layanan dengan klien gRPC Node.js, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.
sudo apt-get update sudo apt-get install -y nodejs npm curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz cd grpc-1.34.0/examples/node/xds npm install node ./greeter_client.js --target=xds:///helloworld-gce
Anda akan melihat output yang mirip dengan ini, dengan INSTANCE_NAME
adalah nama
instance VM:
Greeting: Hello world, from INSTANCE_HOSTNAME
Tindakan ini memverifikasi bahwa klien gRPC tanpa proxy berhasil terhubung ke Cloud Service Mesh dan mempelajari backend untuk layanan helloworld-gce
menggunakan resolver nama xds
. Klien mengirim permintaan ke salah satu
backend layanan tanpa perlu mengetahui alamat IP atau melakukan
resolusi DNS.
Langkah selanjutnya
- Pelajari pengelolaan traffic lanjutan.
- Pelajari cara menyiapkan kemampuan observasi.
- Pelajari cara memecahkan masalah deployment Cloud Service Mesh tanpa proxy.