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 mengikuti petunjuk dalam panduan ini, tinjau Persiapan menyiapkan Cloud Service Mesh dengan layanan gRPC tanpa proxy.

Ringkasan

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

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

Mengonfigurasi cluster GKE untuk Cloud Service Mesh

Bagian ini memberikan petunjuk untuk mengaktifkan cluster GKE agar dapat digunakan dengan dan Cloud Service Mesh.

Persyaratan cluster GKE

Cluster GKE harus memenuhi persyaratan berikut:

• Anda harus mengaktifkan dukungan untuk grup endpoint jaringan. Untuk informasi lebih lanjut dan lihat Grup endpoint jaringan mandiri. Fitur NEG mandiri tersedia di Ketersediaan Umum untuk dan Cloud Service Mesh.
• Instance node cluster akun layanan harus memiliki izin untuk mengakses Cloud Service Mesh API. Untuk informasi selengkapnya tentang izin yang diperlukan, lihat Mengaktifkan akun layanan untuk mengakses Cloud Service Mesh API.
• Container harus memiliki akses ke Cloud Service Mesh API, yaitu dilindungi oleh otentikasi OAuth. Untuk informasi selengkapnya, lihat konfigurasi host.

Membuat cluster GKE

Contoh berikut menunjukkan cara membuat cluster GKE bernama grpc-td-cluster dalam 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

Mendapatkan hak istimewa cluster GKE yang diperlukan

Beralihlah ke cluster yang baru saja Anda buat dengan menjalankan perintah berikut. Ini menunjuk 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 deployment GKE spesifikasi lain untuk berfungsi dengan Cloud Service Mesh. Ini terdiri dari mengonfigurasi layanan contoh helloworld GKE dengan anotasi NEG.

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

Opsi "proxyless" hanya mulai berperan ketika aplikasi klien gRPC terhubung ke Cloud Service Mesh, mempelajari layanan helloworld, dan dapat lalu 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 untuk mengekspos layanan melalui NEG. Akan terekspos melalui NEG, setiap spesifikasi harus memiliki anotasi berikut, yang cocok porta yang ingin diekspos.

...
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 selengkapnya informasi dan contoh, lihat Grup endpoint jaringan mandiri.

Pada contoh berikut, Anda men-deploy layanan Kubernetes helloworld yang diekspos pada port 8080. Ini adalah port tempat layanan terlihat di . Layanan gRPC di Pod memproses 50051 targetPort. Ini adalah porta di Pod yang menjadi tujuan pengiriman permintaan. Biasanya, port dan targetPort ditetapkan ke nilai yang sama demi kemudahan, 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 akan serupa dengan ini:

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

Pastikan Pod aplikasi sedang berjalan:

kubectl get pods

Output kubectl get pods akan 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..]

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

Contoh konfigurasi Cloud Service Mesh yang mengikutinya membuat asumsi berikut:

• NEG dan semua resource lainnya dibuat di jaringan default mode otomatis, di zona us-central1-a.
• Saat menggunakan Google Cloud CLI, nama NEG untuk cluster akan 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. Tujuan aturan firewall memungkinkan pemeriksaan health check terhubung ke VM di deployment. Perintah --use-serving-port digunakan oleh health check untuk mendapatkan porta 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, kemudian mengaitkan 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 lalu lintas untuk layanan Anda, berdasarkan nama {i>host<i} dan jalur. Contoh berikut menggunakan helloworld-gke sebagai nama layanan. Klien gRPC menggunakan nama layanan di URI target saat terhubung ke layanan helloworld. Anda juga akan membuat aturan penerusan dan proxy 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 diketahui bahwa port layanan 8080 yang ditampilkan dalam spesifikasi layanan Kubernetes di bagian sebelumnya tidak digunakan oleh Cloud Service Mesh karena helloworld-gke:8000 secara langsung diselesaikan ke endpoint NEG yang memproses targetPort 50051. Biasanya, port dalam aturan host peta URL dan spesifikasi layanan Kubernetes port dan targetPort ditetapkan ke nilai yang sama demi kemudahan, 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 pada traffic di endpoint di NEG untuk layanan yang ditentukan di peta URL.

Memverifikasi konfigurasi

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

Anda juga dapat memeriksa bagian Cloud Service Mesh di Konsol Google Cloud untuk mendapatkan informasi di layanan yang dikonfigurasi helloworld-gke, lalu periksa apakah backend dinyatakan sehat.

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 mengarahkan traffic di jaring dengan benar. Anda membuat Pod klien, lalu membuka shell dan menjalankan perintah verifikasi dari {i>shell<i}.

Menyiapkan variabel lingkungan dan file bootstrap

Aplikasi klien memerlukan file konfigurasi bootstrap. Ubah Spesifikasi deployment aplikasi Kubernetes dengan menambahkan initContainer yang menghasilkan file {i>bootstrap<i} dan volume untuk mentransfer file tersebut. Perbarui yang ada untuk mencari 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.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 Pod shell.

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 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 tentang 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.