Menyiapkan Google Kubernetes Engine dan layanan gRPC tanpa proxy

Panduan ini menjelaskan cara mengonfigurasi Google Kubernetes Engine, aplikasi gRPC, dan komponen load balancing yang diperlukan Cloud Service Mesh.

Sebelum Anda mengikuti petunjuk dalam panduan ini, tinjau Mempersiapkan penyiapan Cloud Service Mesh dengan layanan gRPC tanpa proxy.

Ringkasan

Menyiapkan Cloud Service Mesh dengan GKE dan layanan gRPC tanpa proxy memerlukan hal berikut:

  1. Menyiapkan cluster GKE Anda.
  2. Men-deploy aplikasi server gRPC sebagai layanan Kubernetes. Anotasikan spesifikasi deployment GKE untuk membuat grup endpoint jaringan (NEG) secara otomatis untuk layanan.
  3. Mengonfigurasi Cloud Service Mesh menggunakan NEG dan komponen load balancing Google Cloud lainnya.
  4. Memverifikasi bahwa deployment berfungsi dengan benar menggunakan aplikasi klien gRPC tanpa proxy untuk mengirim traffic ke aplikasi server gRPC.

Mengonfigurasi cluster GKE untuk Cloud Service Mesh

Bagian ini memberikan petunjuk untuk mengaktifkan cluster GKE agar berfungsi dengan Cloud Service Mesh.

Persyaratan cluster GKE

Cluster GKE harus memenuhi persyaratan berikut:

  • Anda harus mengaktifkan dukungan untuk grup endpoint jaringan. Untuk mengetahui informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri. Fitur NEG mandiri tersedia dalam Ketersediaan Umum untuk Cloud Service Mesh.
  • Akun layanan instance node cluster harus memiliki izin untuk mengakses Cloud Service Mesh API. Untuk mengetahui informasi selengkapnya tentang izin yang diperlukan, lihat Mengaktifkan akun layanan untuk mengakses Cloud Service Mesh API.
  • Penampung harus memiliki akses ke Cloud Service Mesh API, yang dilindungi oleh autentikasi OAuth. Untuk mengetahui informasi selengkapnya, lihat konfigurasi host.

Membuat cluster GKE

Contoh berikut menunjukkan cara membuat cluster GKE bernama grpc-td-cluster di us-central1-a zone.

Konsol

Untuk membuat cluster menggunakan Konsol Google Cloud, lakukan langkah-langkah berikut:

  1. Buka menu Kubernetes Engine di Konsol Google Cloud.

    Buka menu Google Kubernetes Engine

  2. Klik Buat kluster.

  3. Pilih template Cluster standar atau pilih template yang sesuai untuk beban kerja Anda.

  4. Sesuaikan template jika perlu. Kolom berikut diperlukan:

    • Nama: Masukkan grpc-td-cluster.
    • Jenis lokasi: Zonal.
    • Zona: us-central1-a.
    • Node pool:

  5. Di menu sebelah kiri, klik default-pool.

  6. Ubah Name menjadi grpc-td-cluster.

  7. Di bagian Ukuran, masukkan jumlah node yang akan dibuat. Anda harus memiliki kuota resource yang tersedia untuk node dan resource-nya (seperti rute firewall).

  8. Di menu sebelah kiri, klik Node.

  9. Di bagian Machine Configuration, di Machine family, klik Compute Optimized.

  10. Pilih Jenis mesin. Untuk mengetahui informasi harga jenis mesin, lihat halaman harga Compute Engine.

  11. Di bagian Networking, tambahkan Network tag allow-health-checks.

  12. Di menu sebelah kiri, klik Node security.

  13. Di bagian Access scope, pilih Allow full access to all Cloud APIs.

  14. Klik Create.

Setelah membuat cluster di konsol Google Cloud, Anda perlu mengonfigurasi kubectl untuk berinteraksi dengan cluster. Untuk mempelajari lebih lanjut, lihat Membuat entri kubeconfig.

gcloud

Buat cluster.

gcloud container clusters create grpc-td-cluster \
   --zone us-central1-a \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --enable-ip-alias

Mendapatkan hak istimewa cluster GKE yang diperlukan

Beralihlah ke cluster yang baru saja Anda buat dengan mengeluarkan perintah berikut. Tindakan ini akan mengarahkan kubectl ke cluster yang benar.

gcloud 

gcloud container clusters get-credentials grpc-td-cluster \
    --zone us-central1-a

Mengonfigurasi layanan GKE

Bagian ini menjelaskan cara menyiapkan spesifikasi deployment GKE agar dapat berfungsi dengan Cloud Service Mesh. Langkah ini terdiri dari mengonfigurasi layanan contoh helloworld GKE dengan anotasi NEG.

Layanan contoh helloworld adalah aplikasi server gRPC yang menampilkan pesan sebagai respons terhadap permintaan klien gRPC. Perhatikan bahwa tidak ada hal yang istimewa tentang layanan helloworld. Ini bukan layanan gRPC tanpa proxy dan dapat merespons permintaan dari klien gRPC mana pun.

Bagian "tanpa proxy" hanya diterapkan saat aplikasi klien gRPC terhubung ke Cloud Service Mesh, mempelajari layanan helloworld, lalu dapat mengirim traffic ke Pod yang terkait dengan helloworld, tanpa perlu mengandalkan alamat IP atau resolusi nama berbasis DNS.

Mengonfigurasi layanan GKE dengan NEG

Langkah pertama dalam mengonfigurasi layanan GKE untuk digunakan dengan Cloud Service Mesh adalah mengekspos layanan melalui NEG. Agar dapat ditampilkan melalui NEG, setiap spesifikasi harus memiliki anotasi berikut, yang cocok dengan port yang ingin Anda tampilkan.

...
metadata:
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'

Anotasi ini membuat NEG mandiri saat Anda pertama kali men-deploy layanan. NEG ini berisi endpoint yang merupakan alamat IP dan port Pod. Untuk informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri.

Dalam contoh berikut, Anda akan men-deploy layanan Kubernetes helloworld yang diekspos di port 8080. Ini adalah port tempat layanan terlihat di cluster. Layanan gRPC di Pod memproses targetPort 50051. Ini adalah port di Pod tempat permintaan dikirim. Biasanya, port dan targetPort ditetapkan ke nilai yang sama untuk memudahkan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan nilai yang benar untuk digunakan dalam anotasi NEG.

cat << EOF > grpc-td-helloworld.yaml
apiVersion: v1
kind: Service
metadata:
  name: helloworld
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
  ports:
  - port: 8080
    name: helloworld
    protocol: TCP
    targetPort: 50051
  selector:
    run: app1
  type: ClusterIP

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: app1
  name: app1
spec:
  selector:
    matchLabels:
      run: app1
  replicas: 2
  template:
    metadata:
      labels:
        run: app1
    spec:
      containers:
      - image: grpc/java-example-hostname:1.50.2
        name: app1
        ports:
        - protocol: TCP
          containerPort: 50051
EOF

kubectl apply -f grpc-td-helloworld.yaml

Pastikan layanan helloworld baru dibuat:

kubectl get svc

Output kubectl get svc akan terlihat seperti ini:

NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
helloworld     ClusterIP   10.71.9.71   <none>        8080/TCP  41m
[..skip..]

Verifikasi bahwa Pod aplikasi sedang berjalan:

kubectl get pods

Output kubectl get pods akan terlihat seperti ini:

NAME                        READY     STATUS    RESTARTS   AGE
app1-6db459dcb9-zvfg2   1/1       Running   0          6m
app1-6db459dcb9-hlvhj   1/1       Running   0          6m
[..skip..]

Pastikan nama NEG sudah benar.

Konsol

Untuk melihat daftar grup endpoint jaringan, buka halaman Grup Endpoint Jaringan di konsol Google Cloud. Anda akan melihat NEG bernama example-grpc-server.
Buka halaman Network Endpoint Groups

gcloud 

# List the NEGs
gcloud compute network-endpoint-groups list \
    --filter "name=example-grpc-server" --format "value(name)"

# Optionally examine the NEG
gcloud compute network-endpoint-groups describe example-grpc-server \
    --zone us-central1-a

# Optionally examine the endpoint(s) contained
gcloud compute network-endpoint-groups list-network-endpoints example-grpc-server \
    --zone us-central1-a

Mengonfigurasi Cloud Service Mesh dengan komponen load balancing

Bagian ini menjelaskan cara mengonfigurasi komponen load balancing Google Cloud untuk layanan Anda. Komponen ini berisi informasi konfigurasi yang memungkinkan klien gRPC tanpa proxy berkomunikasi dengan layanan GKE Anda.

Contoh konfigurasi Cloud Service Mesh berikut membuat asumsi ini:

  • NEG dan semua resource lainnya dibuat di jaringan default mode otomatis, di zona us-central1-a.
  • Saat Anda menggunakan Google Cloud CLI, nama NEG untuk cluster adalah example-grpc-server.

Membuat health check, aturan firewall, dan layanan backend

Di bagian ini, Anda akan membuat health check dan aturan firewall untuk health check. Health check harus menggunakan protokol health check gRPC. Aturan firewall memungkinkan pemeriksaan health check terhubung ke VM dalam deployment Anda. Perintah --use-serving-port digunakan oleh health check untuk mendapatkan port pemroses yang dikonfigurasi untuk setiap endpoint.

Aturan firewall mengizinkan koneksi health check masuk ke instance di jaringan Anda.

Di bagian ini, Anda akan membuat layanan backend global dengan skema load balancing INTERNAL_SELF_MANAGED dan protokol GRPC, lalu mengaitkan health check dengan layanan backend.

Untuk mengetahui informasi selengkapnya, lihat Membuat health check.

gcloud

  1. Buat health check.

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

  2. Buat aturan firewall.

    gcloud compute firewall-rules create grpc-gke-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. Buat layanan backend.

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

  4. Tambahkan NEG backend ke layanan backend.

    gcloud compute backend-services add-backend grpc-gke-helloworld-service \
   --global \
   --network-endpoint-group example-grpc-server \
   --network-endpoint-group-zone us-central1-a \
   --balancing-mode RATE \
   --max-rate-per-endpoint 5

Membuat peta aturan perutean

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-gke sebagai nama layanan. Klien gRPC menggunakan nama layanan ini di URI target saat terhubung ke layanan helloworld. Anda juga membuat proxy gRPC target dan aturan penerusan.

Untuk informasi selengkapnya, lihat Peta aturan pemilihan rute.

Contoh berikut menggunakan nama layanan helloworld-gke dan port 8000. Artinya, klien gRPC harus menggunakan xds:///helloworld-gke:8000 untuk terhubung ke layanan ini, dan aturan host helloworld-gke:8000 harus dikonfigurasi di peta URL. Perhatikan bahwa port layanan 8080 yang ditampilkan dalam spesifikasi layanan Kubernetes di bagian sebelumnya tidak digunakan oleh Cloud Service Mesh karena helloworld-gke:8000 langsung di-resolve ke endpoint NEG yang memproses targetPort 50051. Biasanya, port dalam aturan host peta URL dan spesifikasi layanan Kubernetes port dan targetPort semuanya ditetapkan ke nilai yang sama untuk memudahkan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan bahwa port dalam spesifikasi layanan tidak digunakan oleh Cloud Service Mesh.

gcloud

  1. Buat peta URL.

    gcloud compute url-maps create grpc-gke-url-map \
--default-service grpc-gke-helloworld-service

  2. Buat pencocok jalur.

    gcloud compute url-maps add-path-matcher grpc-gke-url-map \
--default-service grpc-gke-helloworld-service \
--path-matcher-name grpc-gke-path-matcher \
--new-hosts helloworld-gke:8000

  3. Buat proxy gRPC target.

    gcloud compute target-grpc-proxies create grpc-gke-proxy \
--url-map grpc-gke-url-map \
--validate-for-proxyless

  4. Membuat aturan penerusan.

    gcloud compute forwarding-rules create grpc-gke-forwarding-rule \
--global \
--load-balancing-scheme=INTERNAL_SELF_MANAGED \
--address=0.0.0.0 \
--target-grpc-proxy=grpc-gke-proxy \
--ports 8000 \
--network default

Cloud Service Mesh kini dikonfigurasi untuk melakukan load balancing traffic di seluruh endpoint dalam NEG untuk layanan yang ditentukan dalam peta URL.

Memverifikasi konfigurasi

Setelah proses konfigurasi selesai, pastikan Anda dapat menjangkau server gRPC helloworld menggunakan klien gRPC tanpa proxy. Klien ini terhubung ke Cloud Service Mesh, mendapatkan informasi tentang layanan helloworld (dikonfigurasi dengan Cloud Service Mesh menggunakan layanan backend grpc-gke-helloworld-service) dan menggunakan informasi ini untuk mengirim traffic ke backend layanan.

Anda juga dapat memeriksa bagian Cloud Service Mesh di konsol Google Cloud untuk mengetahui informasi tentang helloworld-gke layanan yang dikonfigurasi dan memeriksa apakah backend dilaporkan sebagai sehat.

Verifikasi dengan klien gRPC tanpa proxy

Dalam contoh berikut, Anda menggunakan klien gRPC dalam bahasa yang berbeda atau alat grpcurl untuk memverifikasi bahwa Cloud Service Mesh merutekan traffic dengan benar di mesh. Anda membuat Pod klien, lalu membuka shell dan menjalankan perintah verifikasi dari shell.

Menyiapkan variabel lingkungan dan file bootstrap

Aplikasi klien memerlukan file konfigurasi bootstrap. Ubah spesifikasi deployment aplikasi Kubernetes dengan menambahkan initContainer yang menghasilkan file bootstrap dan volume untuk mentransfer file. Perbarui penampung yang ada untuk menemukan file.

Tambahkan initContainer berikut ke spesifikasi deployment aplikasi:

      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0

        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory

Perbarui bagian env penampung aplikasi untuk menyertakan hal berikut:

        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/

Berikut adalah contoh lengkap spesifikasi Kubernetes klien:

cat << EOF  | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: sleeper
spec:
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - image: openjdk:8-jdk
        imagePullPolicy: IfNotPresent
        name: sleeper
        command:
        - sleep
        - 365d
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: "2"
            memory: 2000Mi
          requests:
            cpu: 300m
            memory: 1500Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Setelah deployment siap, buka shell ke Pod klien.

kubectl exec -it $(kubectl get pods -o custom-columns=:.metadata.name \
    --selector=run=client) -- /bin/bash

Untuk memverifikasi konfigurasi, jalankan contoh yang sesuai di shell Pod.

Java

Untuk memverifikasi layanan dengan klien Java gRPC:

  1. Download gRPC Java versi terbaru, dengan patch terbaru, dan build aplikasi klien xds-hello-world.

     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-gke:8000" sebagai URI dan port layanan.

    ./build/install/example-xds/bin/xds-hello-world-client "world" \
xds:///helloworld-gke:8000

Go

Untuk memverifikasi layanan dengan klien gRPC Go:

  1. Download gRPC Go versi terbaru, dengan patch terbaru, dan build aplikasi klien xds-hello-world.

    apt-get update -y
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-gke:8000" sebagai URI dan port layanan.

    ./client "world" xds:///helloworld-gke:8000

C++

Untuk memverifikasi layanan dengan klien gRPC C++:

  1. Download gRPC C++ versi terbaru,dengan patch terbaru, dan build contoh klien helloworld.

    apt-get update -y
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
make install
popd
mkdir -p third_party/abseil-cpp/cmake/build
pushd third_party/abseil-cpp/cmake/build
cmake ../..
make
make install
popd
cd examples/cpp/helloworld
mkdir -p cmake/build
cd cmake/build/
cmake ../..
make

  2. Jalankan klien dengan "xds:///helloworld-gke:8000" sebagai URI dan port layanan.

    ./greeter_client --target=xds:///helloworld-gke:8000

grpcurl

Alat grpcurl juga dapat bertindak sebagai klien gRPC tanpa proxy. Dalam hal ini, grpcurl menggunakan variabel lingkungan dan informasi bootstrap untuk terhubung ke Cloud Service Mesh. Kemudian, ia mempelajari layanan helloworld, yang dikonfigurasi dengan Cloud Service Mesh melalui layanan backend grpc-gke-helloworld-service.

Untuk memverifikasi konfigurasi 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-gke:8000" sebagai URI layanan dan helloworld.Greeter/SayHello sebagai nama dan metode layanan yang akan dipanggil. Parameter ke metode SayHello diteruskan menggunakan opsi -d.

    ./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gke:8000 helloworld.Greeter/SayHello

Python

Untuk memverifikasi layanan dengan klien Python gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install python3-pip -y
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-gke:8000

Ruby

Untuk memverifikasi layanan dengan klien Ruby gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install -y ruby-full
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-gke:8000

PHP

Untuk memverifikasi layanan dengan klien PHP gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
pecl install grpc
curl -sS https://getcomposer.org/installer | php
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-gke:8000

Node.js

Untuk memverifikasi layanan dengan klien Node.js gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
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-gke:8000

Anda akan melihat output yang mirip dengan ini, dengan INSTANCE_HOST_NAME adalah nama host instance VM::

Greetings: Hello world, from INSTANCE_HOST_NAME

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

Langkah selanjutnya