Menyiapkan mesh layanan gRPC tanpa proxy

Panduan ini menunjukkan cara mengonfigurasi mesh layanan gRPC tanpa proxy.

Konfigurasi didukung untuk pelanggan Pratinjau, tetapi kami tidak merekomendasikannya untuk pengguna Cloud Service Mesh baru. Untuk informasi selengkapnya, lihat Ringkasan Cloud Service Mesh.

Sebelum memulai

Jangan membuat mesh layanan gRPC tanpa proxy dalam namespace tempat Envoy injeksi otomatis file bantuan diaktifkan. Untuk menentukan apakah injeksi file bantuan aktifkan, jalankan perintah berikut:

kubectl get namespace default --show-labels

Jika injeksi otomatis file bantuan diaktifkan, jalankan perintah ini untuk menghapus label:

kubectl label namespace default istio-injection-

Men-deploy layanan gRPC

Di bagian ini, Anda akan men-deploy layanan contoh helloworld gRPC. Tujuan Layanan contoh helloworld adalah aplikasi server gRPC yang menampilkan sebagai respons terhadap permintaan klien gRPC. Layanan helloworld mengekspos dan layanan gRPC pada port 8080 di cluster.

  1. Dalam file grpc-td-helloworld.yaml, simpan hal berikut:

    apiVersion: v1
kind: Service
metadata:
  name: helloworld
  namespace: default
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
  namespace: default
spec:
  selector:
    matchLabels:
      run: app1
  replicas: 2
  template:
    metadata:
      labels:
        run: app1
      annotations:
        sidecar.istio.io/inject: "false"
    spec:
      containers:
      - image: grpc/java-example-hostname:1.37.0
        name: app1
        ports:
        - protocol: TCP
          containerPort: 50051

  2. Terapkan file grpc-td-helloworld.yaml:

    kubectl apply -f grpc-td-helloworld.yaml

  3. Pastikan layanan helloworld baru telah dibuat:

    kubectl get svc -n default

    Outputnya mirip dengan hal berikut ini:

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

  4. Pastikan Pod aplikasi sedang berjalan:

    kubectl get pods -n default

  5. Pod output akan terlihat seperti berikut:

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

Mengonfigurasi mesh layanan gRPC

Di bagian ini, Anda akan mengonfigurasi mesh layanan gRPC sederhana.

  1. Dalam file td-grpc-mesh.yaml, simpan manifes mesh berikut:

    kind: TDMesh
apiVersion: net.gke.io/v1alpha1
metadata:
  name: td-grpc-mesh
  namespace: default
spec:
  gatewayClassName: gke-td
  allowedRoutes:
    namespaces:
      from: All
    kinds:
    - group: net.gke.io
      kind: TDGRPCRoute

  2. Terapkan manifes mesh ke gke-1:

    kubectl apply -f td-grpc-mesh.yaml

    Contoh TDMesh hanya mengizinkan resource TDGRPCRoute untuk dilampirkan ke dalamnya. Manifes menentukan jenis rute yang diizinkan.

  3. Pastikan mesh td-grpc-mesh baru telah dibuat:

    kubectl describe tdmesh td-grpc-mesh -n default

    Outputnya mirip dengan hal berikut ini:

    ...
Status:
  Conditions:
    Last Transition Time:  2022-04-14T22:22:09Z
    Message:
    Reason:                MeshReady
    Status:                True
    Type:                  Ready
    Last Transition Time:  2022-04-14T22:21:41Z
    Message:
    Reason:                Scheduled
    Status:                True
    Type:                  Scheduled
Events:
  Type    Reason  Age   From                Message
  ----    ------  ----  ----                -------
  Normal  ADD     79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
  Normal  UPDATE  79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
  Normal  SYNC    50s   mc-mesh-controller  SYNC on default/td-grpc-mesh was a success

  4. Dalam file helloworld-route.yaml, simpan manifes berikut:

    kind: TDGRPCRoute
apiVersion: net.gke.io/v1alpha1
metadata:
  name: helloworld-route
  namespace: default
spec:
  parentRefs:
  - name: td-grpc-mesh
    namespace: default
    group: net.gke.io
    kind: TDMesh
  hostnames:
  - helloworld
  rules:
  - backendRefs:
    - name: helloworld
      port: 8080
      namespace: default

  5. Terapkan manifes helloworld-route.yaml ke gke-1:

    kubectl apply -f helloworld-route.yaml

  6. Pastikan resource helloworld-route GRPCRoute baru telah dibuat:

    kubectl get tdgrpcroute -n default

Memverifikasi konfigurasi

Setelah proses konfigurasi selesai, pastikan Anda dapat mencapai Server gRPC helloworld menggunakan klien gRPC tanpa proxy. Klien ini terhubung ke Cloud Service Mesh, memperoleh informasi tentang layanan helloworld, dan menggunakan informasi ini untuk mengirim traffic ke backend layanan.

Pada contoh berikut, Anda menggunakan alat grpcurl untuk memverifikasi bahwa Cloud Service Mesh mengarahkan traffic dengan benar di mesh. Anda membuat klien Pod, lalu buka shell dan jalankan perintah verifikasi dari shell.

Menyiapkan variabel lingkungan dan file bootstrap

  1. Dalam file grpc-client.yaml, simpan manifes Pod berikut:

    apiVersion: v1
kind: Pod
metadata:
  name: static-sleeper
  namespace: default
  annotations:
    sidecar.istio.io/inject: "false"
spec:
  containers:
  - image: curlimages/curl:7.82.0
    imagePullPolicy: IfNotPresent
    name: sleeper
    command:
    - sleep
    - 365d
    env:
    - name: GRPC_XDS_BOOTSTRAP
      value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
    volumeMounts:
    - name: grpc-td-conf
      mountPath: /tmp/grpc-xds/
  initContainers:
  - args:
    - --config-mesh-experimental
    - "gketd-td-grpc-mesh"
    - --output
    - "/tmp/bootstrap/td-grpc-bootstrap.json"
    image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
    imagePullPolicy: IfNotPresent
    name: grpc-td-init
    volumeMounts:
    - name: grpc-td-conf
      mountPath: /tmp/bootstrap/
  volumes:
  - name: grpc-td-conf
    emptyDir:
      medium: Memory

  2. Terapkan manifes Pod di gke-1:

    kubectl apply -f grpc-client.yaml

  3. Setelah Pod siap, buka shell ke Pod klien:

    kubectl exec -it static-sleeper -- /bin/sh

Anda dapat menggunakan alat grpcurl sebagai klien gRPC tanpa proxy. Alat grpcurl menggunakan variabel lingkungan dan informasi {i>bootstrap<i} untuk terhubung ke dan Cloud Service Mesh. Alat ini kemudian mempelajari layanan helloworld, yang yang dikonfigurasi dengan Cloud Service Mesh.

Untuk memverifikasi konfigurasi Anda menggunakan alat grpcurl:

  1. Download dan instal alat grpcurl:

    cd /home/curl_user
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 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 helloworld.Greeter/SayHello

    Output-nya serupa dengan berikut ini, dengan INSTANCE_HOST_NAME sebagai nama host Pod:

    Greetings: Hello world, from INSTANCE_HOST_NAME

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

Langkah selanjutnya