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 Menyiapkan penyiapan Cloud Service Mesh dengan layanan gRPC tanpa proxy.

Ringkasan

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

1. Menyiapkan cluster GKE Anda.
2. Men-deploy aplikasi server gRPC sebagai layanan Kubernetes. Anotasikan spesifikasi deployment GKE guna 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 berisi 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 di 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 artikel Mengaktifkan akun layanan untuk mengakses Cloud Service Mesh API.
• Container 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.

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 mengarahkan kubectl ke cluster yang benar.

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 digunakan 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 khusus tentang layanan helloworld. Layanan ini bukan layanan gRPC tanpa proxy dan dapat merespons permintaan dari klien gRPC apa pun.

Bagian "proxyless" hanya berperan saat aplikasi klien gRPC terhubung ke Cloud Service Mesh, mempelajari layanan helloworld, dan kemudian dapat mengirim traffic ke Pod yang terkait dengan helloworld, tanpa perlu bergantung pada 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 terekspos 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 akan 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 terekspos pada port 8080. Ini adalah port tempat layanan terlihat di cluster. Layanan gRPC di Pod sedang memproses targetPort 50051. Ini adalah port pada Pod yang dikirimi permintaan. 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 telah dibuat:

kubectl get svc

Output kubectl get svc harus serupa 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 harus serupa dengan ini:

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

Verifikasi bahwa nama NEG sudah benar.

# 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 Google Cloud Load Balancing untuk layanan Anda. Komponen-komponen ini berisi informasi konfigurasi yang memungkinkan klien gRPC tanpa proxy untuk berkomunikasi dengan layanan GKE Anda.

Contoh konfigurasi Cloud Service Mesh berikut menghasilkan 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 di deployment Anda. Perintah --use-serving-port digunakan oleh health check untuk mendapatkan port pemrosesan 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 kaitkan health check dengan layanan backend.

Untuk mengetahui informasi selengkapnya, lihat Membuat health check.

Membuat peta aturan perutean

Di bagian ini, Anda akan membuat peta URL, pencocok jalur, dan aturan host untuk merutekan traffic bagi 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 aturan penerusan dan proxy gRPC target.

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 50051 targetPort. Biasanya, port dalam aturan host peta URL serta spesifikasi layanan Kubernetes port dan targetPort ditetapkan ke nilai yang sama demi kenyamanan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan bahwa port dalam spesifikasi layanan tidak digunakan oleh Cloud Service Mesh.

Cloud Service Mesh kini dikonfigurasi untuk melakukan load balancing terhadap 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, memperoleh 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 responsif.

Verifikasi dengan klien gRPC tanpa proxy

Pada contoh berikut, Anda menggunakan klien gRPC dalam berbagai bahasa 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 Anda dengan menambahkan initContainer yang menghasilkan file bootstrap dan volume untuk mentransfer file. Update container yang ada untuk menemukan file tersebut.

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

Setelah deployment 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.

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

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

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

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

• Pelajari keamanan layanan Cloud Service Mesh.
• Pelajari pengelolaan traffic lanjutan.
• Pelajari cara menyiapkan kemampuan observasi.
• Pelajari cara memecahkan masalah deployment Cloud Service Mesh tanpa proxy.