Menyiapkan VM Compute Engine dan layanan gRPC tanpa proxy

Panduan ini menunjukkan cara mengonfigurasi host VM Compute Engine, gRPC aplikasi, dan komponen load balancing yang disediakan oleh Cloud Service Mesh Anda butuhkan.

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 Compute Engine (VM) dan layanan gRPC tanpa proxy melibatkan hal-hal berikut:

  1. Menyiapkan grup instance terkelola yang menghosting backend Anda.
  2. Mengonfigurasi backend untuk menjalankan server gRPC yang menampilkan hello world untuk menanggapi permintaan dari klien.
  3. Mengonfigurasi Cloud Service Mesh menggunakan grup instance terkelola dan komponen Google Cloud Load Balancing lainnya.
  4. Memverifikasi apakah deployment berfungsi dengan benar menggunakan klien gRPC tanpa proxy aplikasi Google untuk mengirim traffic ke aplikasi server gRPC.

Klien gRPC tanpa proxy terhubung ke Cloud Service Mesh menggunakan xDS. Kapan klien terhubung ke Cloud Service Mesh, Cloud Service Mesh mengirim informasi kepada klien tentang backend yang terkait dengan hello world layanan. Menggunakan informasi ini, klien gRPC tanpa proxy mengirim 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 oleh deployment Anda. Contoh ini menunjukkan cara melakukan hal berikut:

  • Membuat template instance dengan layanan contoh yang menyalurkan hello world menggunakan protokol gRPC.
  • Konfigurasikan grup instance terkelola menggunakan template.

Membuat template instance

Bagian ini memberikan petunjuk untuk membuat template instance. Di kolom misalnya, Anda men-deploy layanan gRPC helloworld yang diekspos pada port 50051.

Konsol

  1. Di konsol Google Cloud, buka halaman Instance Templates.

    Buka halaman Instance templates

  2. Klik Create instance template.
  3. 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
  4. Di bagian Firewall, pilih kotak di samping Allow HTTP traffic dan Izinkan traffic HTTPS.

  5. Klik Management, Security, Disks, Networking, Sole Tenancy.

  6. 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
    
  7. 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 Anda buat di bagian sebelumnya.

Konsol

  1. Buka halaman Grup Instance di Konsol Google Cloud.

    Buka halaman Instance Groups

  2. Klik Create an instance group. Secara {i>default<i}, Anda melihat halaman untuk membuat grup instance terkelola.
  3. Masukkan grpc-td-mig-us-central1 untuk nama instance terkelola grup, lalu pilih zona us-central1-a.
  4. Di bagian Instance template, pilih grpc-td-vm-template, yang merupakan template instance yang Anda buat.
  5. Tentukan 2 sebagai jumlah minimum dan maksimum instance yang Anda inginkan untuk dibuat di grup.
  6. 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. Nama porta adalah porta tempat layanan gRPC memproses permintaan. Di sini misalnya, porta yang dinamai adalah porta 50051.

Konsol

  1. Buka halaman Grup Instance di Konsol Google Cloud.

    Buka halaman Instance Groups

  2. Klik nama grup instance grpc-td-mig-us-central1, yang yang Anda buat.
  3. Klik Edit grup.
  4. Di kolom Nama port, masukkan grpc-helloworld-port.
  5. Di kolom Nomor port, masukkan 50051.
  6. Klik Simpan.

gcloud

Konfigurasi port 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 Google Cloud load balancing

Bagian ini memberikan 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 di Membuat grup instance terkelola. Grup instance terkelola ini menjalankan layanan gRPC contoh. Port dalam flag --port-name adalah port yang bernama port yang Anda buat di Mengonfigurasi port bernama.

gcloud

  1. Buat health check.

    gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port
    
  2. 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
    
  3. 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
    
  4. 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 lalu lintas untuk layanan Anda berdasarkan nama {i>host<i} dan jalur. Contoh berikut menggunakan helloworld-gce sebagai nama layanan. Aplikasi gRPC menggunakan dalam URI target saat terhubung ke layanan ini. Secara default, pencocok jalur cocok dengan semua permintaan jalur (/*) untuk host ini. Anda juga membuat aturan penerusan dan proxy gRPC target.

Untuk mengetahui informasi selengkapnya, lihat Peta aturan pemilihan rute.

Pada contoh berikut, port 80 adalah port yang ditentukan.

gcloud

  1. Membuat peta URL.

    gcloud compute url-maps create grpc-vm-url-map \
      --default-service grpc-helloworld-service
    
  2. Buat 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
    
  3. Buat proxy gRPC target.

    gcloud compute target-grpc-proxies create grpc-vm-proxy \
     --url-map grpc-vm-url-map \
     --validate-for-proxyless
    
  4. 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 kini dikonfigurasi untuk melakukan load balancing pada traffic di backend di grup instance terkelola untuk layanan yang ditentukan dalam peta URL.

Memverifikasi konfigurasi

Ketika proses konfigurasi selesai, pastikan Anda dapat membuat koneksi gRPC ke layanan load balanced Cloud Service Mesh yang dibuat 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 porta yang memproses. Dalam contoh, port adalah 50051.
  • Periksa halaman Cloud Service Mesh di Console untuk informasi tentang layanan helloworld-gce yang terkonfigurasi, backend tersebut dilaporkan responsif.
  • Gunakan petunjuk berikut untuk menggunakan klien gRPC Compute Engine 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.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-nilai untuk TRAFFICDIRECTOR_GCP_PROJECT_NUMBER, TRAFFICDIRECTOR_NETWORK_NAME, dan zone dalam file bootstrap yang dihasilkan diperoleh dari server metadata yang mengetahui detail tentang instance VM Compute Engine Anda. Anda dapat menyediakan nilai ini ke skrip helper secara manual dengan menggunakan Opsi -gcp-project-number dan -vpc-network-name.

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

Java

Untuk memverifikasi layanan dengan klien Java gRPC:

  1. Download versi terbaru gRPC Java, 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
    
  2. Jalankan klien dengan world sebagai namanya dan xds:///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:

  1. 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 .
    
  2. Jalankan klien dengan world sebagai namanya dan xds:///helloworld-gce sebagai URI layanan.

    ./client "world" xds:///helloworld-gce
    

C++

Untuk memverifikasi layanan dengan klien C++ gRPC:

  1. Download versi terbaru gRPC C++, dengan patch terbaru, dan bangun 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
    
  2. Jalankan klien dengan "xds:///helloworld-gce" sebagai URI layanan.

    ./greeter_client --target=xds:///helloworld-gce
    

Grpcurl

Untuk memverifikasi layanan menggunakan alat grpcurl:

  1. 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
    
  2. 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
    

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 Cloud Service Mesh dan mempelajari backend untuk 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