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 Traffic Director.

Sebelum mengikuti petunjuk dalam panduan ini, tinjau Menyiapkan Traffic Director dengan layanan gRPC tanpa proxy.

Ringkasan

Menyiapkan Traffic Director dengan GKE dan layanan gRPC tanpa proxy melibatkan hal berikut:

  1. Menyiapkan cluster GKE Anda.
  2. Men-deploy aplikasi server gRPC sebagai layanan Kubernetes. Anotasikan spesifikasi deployment GKE untuk otomatis membuat grup endpoint jaringan (NEG) untuk layanan.
  3. Mengonfigurasi Traffic Director 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 Traffic Director

Bagian ini berisi petunjuk cara mengaktifkan cluster GKE agar dapat digunakan dengan Traffic Director.

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 di Ketersediaan Umum untuk Traffic Director.
  • Akun layanan instance node cluster harus memiliki izin untuk mengakses Traffic Director API. Untuk informasi selengkapnya tentang izin yang diperlukan, lihat Mengaktifkan akun layanan untuk mengakses Traffic Director API.
  • Container harus memiliki akses ke Traffic Director 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 Google Cloud Console, 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 workload Anda.

  4. Sesuaikan template jika perlu. Kolom berikut diperlukan:

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

  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 Machine type. Untuk mengetahui informasi harga jenis mesin, lihat halaman harga Compute Engine.

  11. Di bagian Networking, tambahkan Tag jaringan allow-health-checks.

  12. Di menu sebelah kiri, klik Keamanan node.

  13. Di bagian Cakupan akses, pilih Izinkan akses penuh ke semua API Cloud.

  14. Klik Create.

Setelah membuat cluster di Konsol Google Cloud, Anda perlu mengonfigurasi kubectl agar dapat 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

Memperoleh hak istimewa cluster GKE yang diperlukan

Beralihlah ke cluster yang baru saja Anda buat dengan menjalankan 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 bekerja sama dengan Traffic Director. Langkah ini terdiri dari mengonfigurasi layanan contoh helloworld GKE dengan anotasi NEG.

Layanan contoh helloworld adalah aplikasi server gRPC yang menampilkan pesan sederhana sebagai respons terhadap permintaan klien gRPC. Perlu diketahui bahwa tidak ada hal khusus pada layanan helloworld. Ini bukan layanan gRPC tanpa proxy dan dapat merespons permintaan dari klien gRPC apa pun.

Bagian "proxyless" hanya berfungsi saat aplikasi klien gRPC terhubung ke Traffic Director, 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 Traffic Director adalah mengekspos layanan melalui NEG. Agar diekspos melalui NEG, setiap spesifikasi harus memiliki anotasi berikut, yang cocok dengan port yang ingin Anda ekspos.

...
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 port dan alamat IP Pod. Untuk mengetahui informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri.

Pada contoh berikut, Anda men-deploy layanan Kubernetes helloworld yang ditampilkan pada port 8080. Ini adalah port tempat layanan terlihat di cluster. Layanan gRPC di Pod sedang diproses di targetPort 50051. Ini adalah port pada Pod yang dikirimi permintaan. Biasanya, port dan targetPort ditetapkan ke nilai yang sama demi kenyamanan, tetapi contoh ini menggunakan nilai yang berbeda guna 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 telah dibuat:

kubectl get svc

Output kubectl get svc akan mirip dengan ini:

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

Pastikan bahwa Pod aplikasi sedang berjalan:

kubectl get pods

Output kubectl get pods akan mirip dengan 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 melihat NEG bernama example-grpc-server.
Buka halaman Grup Endpoint Jaringan

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 Traffic Director 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.

Contoh konfigurasi Traffic Director di bawah ini membuat asumsi berikut:

  • NEG dan semua resource lainnya dibuat dalam 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 untuk 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 yang 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. Membuat 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 dalam URI target saat terhubung ke layanan helloworld. Anda juga membuat proxy dan aturan penerusan gRPC target.

Untuk mengetahui 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. Perlu diperhatikan bahwa port layanan 8080 yang ditampilkan dalam spesifikasi layanan Kubernetes di atas tidak digunakan oleh Traffic Director karena helloworld-gke:8000 langsung di-resolve ke endpoint NEG yang memproses di targetPort 50051. Biasanya, port dalam aturan host peta URL serta spesifikasi layanan Kubernetes port dan targetPort, semuanya ditetapkan ke nilai yang sama demi kenyamanan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan bahwa port dalam spesifikasi layanan tidak digunakan oleh Traffic Director.

gcloud

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

Traffic Director kini dikonfigurasi untuk melakukan load balancing terhadap traffic di seluruh endpoint di NEG untuk layanan yang ditentukan di peta URL.

Memverifikasi konfigurasi

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

Anda juga dapat memeriksa bagian Traffic Director di Google Cloud Console untuk mengetahui informasi tentang layanan helloworld-gke yang dikonfigurasi, dan memeriksa apakah backend dilaporkan responsif.

Verifikasi dengan klien gRPC tanpa proxy

Pada contoh berikut, Anda menggunakan klien gRPC dalam bahasa yang berbeda atau alat grpcurl untuk memverifikasi bahwa Traffic Director mengarahkan 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 Anda dengan menambahkan initContainer yang menghasilkan file bootstrap dan volume untuk mentransfer file tersebut. 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.11.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

Update 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.11.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

Jika deployment di atas sudah siap, buka shell untuk 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 versi terbaru gRPC Java, dengan patch terbaru dan bangun 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 serta "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 bangun 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 serta "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 versi terbaru gRPC C++,dengan patch terbaru, dan buat 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 port dan URI 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 Traffic Director. Kemudian, kode ini akan mempelajari layanan helloworld, yang dikonfigurasi dengan Traffic Director melalui layanan backend grpc-gke-helloworld-service.

Untuk memverifikasi konfigurasi Anda 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 serta 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 gRPC PHP, 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 memastikan bahwa klien gRPC tanpa proxy berhasil terhubung ke Traffic Director, 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