Menyiapkan Pod Google Kubernetes Engine menggunakan injeksi Envoy otomatis

Ringkasan

Catatan: Panduan ini hanya mendukung Cloud Service Mesh dengan Google Cloud API dan tidak mendukung Istio API. Untuk mengetahui informasi selengkapnya, lihat Ringkasan Cloud Service Mesh.

Dalam service mesh, kode aplikasi Anda tidak perlu mengetahui konfigurasi jaringan Anda. Sebagai gantinya, aplikasi Anda berkomunikasi melalui bidang data, yang dikonfigurasi oleh bidang kontrol yang menangani jaringan layanan. Dalam panduan ini, Cloud Service Mesh adalah bidang kontrol Anda dan proxy sidecar Envoy adalah bidang data Anda.

Injector sidecar Envoy yang dikelola Google menambahkan proxy sidecar Envoy ke Pod Google Kubernetes Engine Anda. Saat penyuntik sidecar Envoy menambahkan proxy, proxy tersebut juga disiapkan untuk menangani traffic aplikasi dan terhubung ke Cloud Service Mesh untuk konfigurasi.

Panduan ini akan memandu Anda melakukan penyiapan Cloud Service Mesh yang sederhana dengan Google Kubernetes Engine. Langkah-langkah ini memberikan dasar yang dapat Anda perluas ke kasus penggunaan lanjutan, seperti mesh layanan yang diperluas ke beberapa cluster Google Kubernetes Engine dan, mungkin, VM Compute Engine. Anda juga dapat menggunakan petunjuk ini jika Anda mengonfigurasi Cloud Service Mesh dengan VPC Bersama.

Proses penyiapan mencakup:

1. Membuat cluster GKE untuk workload Anda.
2. Menginstal injector sidecar Envoy dan mengaktifkan injeksi.
3. Men-deploy klien contoh dan memverifikasi injeksi.
4. Men-deploy layanan Kubernetes untuk pengujian.
5. Mengonfigurasi Cloud Service Mesh dengan komponen Cloud Load Balancing untuk merutekan traffic ke layanan pengujian.
6. Memverifikasi konfigurasi dengan mengirimkan permintaan dari klien contoh ke layanan pengujian.

Ringkasan komponen yang di-deploy sebagai bagian dari panduan penyiapan ini (klik untuk memperbesar)

Prasyarat

Sebelum mengikuti petunjuk dalam panduan ini, selesaikan tugas prasyarat yang dijelaskan dalam Bersiap untuk melakukan penyiapan di API perutean layanan dengan Envoy dan beban kerja tanpa proxy.

Untuk mengetahui informasi tentang versi Envoy yang didukung, lihat catatan rilis Cloud Service Mesh.

Catatan: Sidecar injector dan proxy yang disuntikkan didasarkan pada sidecar injector Istio. Jangan menginstal injector sidecar Envoy jika Anda telah men-deploy Istio ke cluster GKE karena hal ini dapat menyebabkan konflik dalam perilaku injeksi.

Prasyarat tambahan dengan VPC Bersama

Jika Anda menyiapkan Cloud Service Mesh di lingkungan VPC Bersama, pastikan hal berikut.

• Anda memiliki izin dan peran yang tepat untuk VPC Bersama.
• Anda telah menyiapkan project dan penagihan yang benar.
• Anda telah mengaktifkan penagihan di project.
• Anda telah mengaktifkan Cloud Service Mesh dan GKE API di setiap project, termasuk project host.
• Anda telah menyiapkan akun layanan yang benar untuk setiap project.
• Anda telah membuat jaringan dan subnet VPC.
• Anda telah mengaktifkan VPC Bersama.

Untuk mengetahui informasi selengkapnya, lihat VPC Bersama.

Mengonfigurasi peran IAM

Contoh konfigurasi peran IAM ini mengasumsikan bahwa project host untuk VPC Bersama memiliki dua subnet dan ada dua project layanan di VPC Bersama.

1. Di Cloud Shell, buat folder kerja (WORKDIR) tempat Anda membuat file yang terkait dengan bagian ini:

   mkdir -p ~/td-shared-vpc
   cd ~/td-shared-vpc
   export WORKDIR=$(pwd)
   

2. Konfigurasi izin IAM di project host sehingga project layanan dapat menggunakan resource di VPC bersama.

   Pada langkah ini, Anda mengonfigurasi izin IAM sehingga subnet-1 dapat diakses oleh project layanan 1 dan subnet-2 dapat diakses oleh project layanan 2. Anda menetapkan peran IAM Compute Network User (roles/compute.networkUser) ke akun layanan default Compute Engine dan akun layanan API Google Cloud di setiap project layanan untuk setiap subnet.

   1. Untuk project layanan 1, konfigurasikan izin IAM untuk subnet-1:

      export SUBNET_1_ETAG=$(gcloud beta compute networks subnets get-iam-policy subnet-1 --project ${HOST_PROJECT} --region ${REGION_1} --format=json | jq -r '.etag')
      
      cat > subnet-1-policy.yaml <<EOF
      bindings:
      - members:
        - serviceAccount:${SVC_PROJECT_1_API_SA}
        - serviceAccount:${SVC_PROJECT_1_GKE_SA}
        role: roles/compute.networkUser
      etag: ${SUBNET_1_ETAG}
      EOF
      
      gcloud beta compute networks subnets set-iam-policy subnet-1 \
      subnet-1-policy.yaml \
          --project ${HOST_PROJECT} \
          --region ${REGION_1}
      

   2. Untuk project layanan 2, konfigurasi izin IAM untuk subnet-2:

      export SUBNET_2_ETAG=$(gcloud beta compute networks subnets get-iam-policy subnet-2 --project ${HOST_PROJECT} --region ${REGION_2} --format=json | jq -r '.etag')
      
      cat > subnet-2-policy.yaml <<EOF
      bindings:
      - members:
        - serviceAccount:${SVC_PROJECT_2_API_SA}
        - serviceAccount:${SVC_PROJECT_2_GKE_SA}
        role: roles/compute.networkUser
      etag: ${SUBNET_2_ETAG}
      EOF
      
      gcloud beta compute networks subnets set-iam-policy subnet-2 \
      subnet-2-policy.yaml \
          --project ${HOST_PROJECT} \
          --region ${REGION_2}
      

3. Untuk setiap project layanan, Anda harus memberikan peran IAM Pengguna Agen Layanan Host Kubernetes Engine (roles/container.hostServiceAgentUser) ke akun layanan GKE di project host:

   gcloud projects add-iam-policy-binding ${HOST_PROJECT} \
       --member serviceAccount:${SVC_PROJECT_1_GKE_SA} \
       --role roles/container.hostServiceAgentUser
   
   gcloud projects add-iam-policy-binding ${HOST_PROJECT} \
       --member serviceAccount:${SVC_PROJECT_2_GKE_SA} \
       --role roles/container.hostServiceAgentUser
   

   Peran ini memungkinkan akun layanan GKE project layanan menggunakan akun layanan GKE project host untuk mengonfigurasi resource jaringan bersama.

4. Untuk setiap project layanan, berikan akun layanan default Compute Engine peran IAM Compute Network Viewer (roles/compute.networkViewer) di project host.

   gcloud projects add-iam-policy-binding ${SVC_PROJECT_1} \
       --member serviceAccount:${SVC_PROJECT_1_COMPUTE_SA} \
       --role roles/compute.networkViewer
   
   gcloud projects add-iam-policy-binding ${SVC_PROJECT_2} \
       --member serviceAccount:${SVC_PROJECT_2_COMPUTE_SA} \
       --role roles/compute.networkViewer
   

   Saat proxy sidecar Envoy terhubung ke layanan xDS (Traffic Director API), proxy menggunakan akun layanan host virtual machine (VM) Compute Engine atau instance node GKE. Akun layanan harus memiliki izin IAM tingkat project compute.globalForwardingRules.get. Peran Compute Network Viewer sudah cukup untuk langkah ini.

Mengonfigurasi informasi project

Jika Anda belum membuat Google Cloud Project atau menginstal Google Cloud CLI, ikuti petunjuk ini. Jika Anda belum menginstal kubectl, ikuti petunjuk ini.

# The project that contains your GKE cluster.
export CLUSTER_PROJECT_ID=YOUR_CLUSTER_PROJECT_ID_HERE
# The name of your GKE cluster.
export CLUSTER=YOUR_CLUSTER_NAME
# The channel of your GKE cluster. Eg: rapid, regular, stable. This channel
# should correspond to the channel for your GKE cluster. If your GKE cluster
# does not have a specified channel, please use unspecified in this field.
export CHANNEL=YOUR_CLUSTER_CHANNEL
# The location of your GKE cluster, Eg: us-central1 for regional GKE cluster,
# us-central1-a for zonal GKE cluster
export LOCATION=ZONE

# The network name of the traffic director load balancing API.
export MESH_NAME=default
# The project that holds the mesh resources.
export MESH_PROJECT_NUMBER=YOUR_MESH_PROJECT_NUMBER_HERE

export TARGET=projects/${MESH_PROJECT_NUMBER}/global/networks/${MESH_NAME}

gcloud config set project ${CLUSTER_PROJECT_ID}

Jika Anda menggunakan API perutean layanan baru, untuk resource mesh, gunakan petunjuk berikut untuk menyetel MESH_NAME, MESH_PROJECT_NUMBER, dan TARGET:

# The mesh name of the traffic director load balancing API.
export MESH_NAME=YOUR_MESH_NAME
# The project that holds the mesh resources.
export MESH_PROJECT_NUMBER=YOUR_MESH_PROJECT_NUMBER_HERE

export TARGET=projects/${MESH_PROJECT_NUMBER}/locations/global/meshes/${MESH_NAME}

Untuk resource gateway, gunakan petunjuk berikut untuk menetapkan SCOPE_NAME, SCOPE_PROJECT_NUMBER, dan TARGET:

# The gateway scope name of the traffic director load balancing API.
export SCOPE_NAME=YOUR_SCOPE_NAME
# The project that holds the gateway resources.
export SCOPE_PROJECT_NUMBER=YOUR_GATEWAY_PROJECT_NUMBER_HERE

export TARGET=projects/${SCOPE_PROJECT_NUMBER}/locations/global/gatewayScopes/${SCOPE_NAME}

Dalam sebagian besar skenario, CLUSTER_PROJECT_ID dan MESH_PROJECT_NUMBER mengacu pada project yang sama. Namun, jika Anda menyiapkan project yang berbeda, seperti saat menggunakan VPC Bersama, maka CLUSTER_PROJECT_ID merujuk ke ID project yang berisi cluster GKE Anda, dan MESH_PROJECT_NUMBER merujuk ke nomor project yang berisi resource. Pastikan Anda telah mengonfigurasi izin yang sesuai untuk mengizinkan envoy yang disuntikkan mengambil konfigurasi dari

Aktifkan Mesh Config API

Aktifkan API berikut untuk mulai menggunakan injector sidecar yang dikelola Google.

gcloud services enable --project=${CLUSTER_PROJECT_ID} meshconfig.googleapis.com

Membuat cluster GKE untuk workload Anda

Cluster GKE harus memenuhi persyaratan berikut untuk mendukung Cloud Service Mesh:

• Dukungan grup endpoint jaringan harus diaktifkan. Untuk mengetahui informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri.
• Akun layanan untuk node/pod GKE Anda harus memiliki izin untuk mengakses Traffic Director API. Untuk mengetahui informasi selengkapnya tentang izin yang diperlukan, lihat Mengizinkan akun layanan untuk mengakses Traffic Director API.

Membuat cluster GKE

Buat cluster GKE di zona pilihan Anda, misalnya, us-central1-a.

gcloud container clusters create YOUR_CLUSTER_NAME \
  --zone ZONE \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --enable-ip-alias

Mengarahkan kubectl ke cluster yang baru dibuat

Ubah konteks saat ini untuk kubectl ke cluster yang baru dibuat dengan mengeluarkan perintah berikut:

gcloud container clusters get-credentials traffic-director-cluster \
    --zone ZONE

Terapkan konfigurasi untuk Mutating Webhook

Bagian berikut memberikan petunjuk untuk menerapkan MutatingWebhookConfiguration ke cluster. Saat pod dibuat, pengontrol penerimaan dalam cluster dipanggil. Pengontrol penerimaan berkomunikasi dengan injector sidecar terkelola untuk menambahkan container Envoy ke pod.

Terapkan konfigurasi webhook mutating berikut ke cluster Anda.

cat <<EOF | kubectl apply -f -
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
  labels:
    app: sidecar-injector
  name: td-mutating-webhook
webhooks:
- admissionReviewVersions:
  - v1beta1
  - v1
  clientConfig:
    url: https://meshconfig.googleapis.com/v1internal/projects/${CLUSTER_PROJECT_ID}/locations/${LOCATION}/clusters/${CLUSTER}/channels/${CHANNEL}/targets/${TARGET}:tdInject
  failurePolicy: Fail
  matchPolicy: Exact
  name: namespace.sidecar-injector.csm.io
  namespaceSelector:
    matchExpressions:
    - key: td-injection
      operator: Exists
  reinvocationPolicy: Never
  rules:
  - apiGroups:
    - ""
    apiVersions:
    - v1
    operations:
    - CREATE
    resources:
    - pods
    scope: '*'
  sideEffects: None
  timeoutSeconds: 30
EOF

Mengaktifkan injeksi sidecar

Perintah berikut mengaktifkan injeksi untuk namespace default. Injector sidecar menyuntikkan container sidecar ke pod yang dibuat di namespace ini:

kubectl label namespace default td-injection=enabled

Anda dapat memverifikasi bahwa namespace default diaktifkan dengan benar dengan menjalankan perintah berikut:

kubectl get namespace -L td-injection

Perintah ini akan menampilkan:

NAME              STATUS   AGE     TD-INJECTION
default           Active   7d16h   enabled

Jika Anda mengonfigurasi keamanan layanan untuk Cloud Service Mesh dengan Envoy, kembali ke bagian Menyiapkan layanan pengujian dalam panduan penyiapan tersebut.

Men-deploy klien contoh dan memverifikasi injeksi

Bagian ini menunjukkan cara men-deploy pod contoh yang menjalankan Busybox, yang menyediakan antarmuka sederhana untuk menjangkau layanan pengujian. Dalam deployment sebenarnya, Anda akan men-deploy aplikasi klien Anda sendiri.

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: busybox
spec:
  replicas: 1
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - name: busybox
        image: busybox
        command:
        - sh
        - -c
        - while true; do sleep 1; done
EOF

Pod Busybox terdiri dari dua container. Penampung pertama adalah klien berdasarkan image Busybox dan penampung kedua adalah proxy Envoy yang disuntikkan oleh injector sidecar. Anda bisa mendapatkan informasi selengkapnya tentang pod dengan menjalankan perintah berikut:

kubectl describe pods -l run=client

Perintah ini akan menampilkan:

…
Init Containers:
# Istio-init sets up traffic interception for the pod.
  Istio-init:
…
Containers:
# busybox is the client container that runs application code.
  busybox:
…
# Envoy is the container that runs the injected Envoy proxy.
  envoy:
…

Proxy Cloud Service Mesh

Injector sidecar terkelola akan menggunakan image Proxy Cloud Service Mesh sebagai proxy. Proxy Cloud Service Mesh adalah container pendamping yang bertanggung jawab untuk memulai proxy envoy untuk instance yang mendukung mesh. Image proxy menggunakan image OSS Envoy bersama dengan agen proxy yang bertanggung jawab untuk memulai Envoy, menyediakan konfigurasi bootstrap, dan melakukan pemeriksaan kondisi Envoy. Versi image Proxy Cloud Service Mesh selaras dengan versi OSS Envoy. Anda dapat melacak image proxy yang tersedia di sini: https://gcr.io/gke-release/csm/csm-mesh-proxy. Sebaiknya gunakan versi proxy terbaru.

Upgrade Proxy Cloud Service Mesh

Sebaiknya upgrade ke versi terbaru. Meskipun mesh layanan berfungsi dengan baik saat control plane dan proxy berada di versi yang berbeda, sebaiknya Anda memperbarui proxy agar dikonfigurasi dengan versi Cloud Service Mesh yang baru.

Injector Managed Sidecar menangani versi Envoy yang selalu menyuntikkan versi Envoy terbaru yang memenuhi syarat dari Google. Jika versi Proxy Cloud Service Mesh lebih baru daripada versi proxy, mulai ulang proxy untuk layanan Anda.

kubectl rollout restart deployment -n YOUR_NAMESPACE_HERE

Men-deploy layanan Kubernetes untuk pengujian

Bagian berikut memberikan petunjuk untuk menyiapkan layanan pengujian yang akan Anda gunakan nanti dalam panduan ini untuk memberikan verifikasi end-to-end penyiapan Anda.

Mengonfigurasi layanan GKE dengan NEG

Layanan GKE harus diekspos melalui grup endpoint jaringan (NEG) agar Anda dapat mengonfigurasinya sebagai backend layanan backend Cloud Service Mesh. Tambahkan anotasi NEG ke spesifikasi layanan Kubernetes Anda dan pilih nama (dengan mengganti NEG-NAME dalam contoh di bawah) agar Anda dapat menemukannya dengan mudah nanti. Anda memerlukan nama saat melampirkan NEG ke layanan backend Cloud Service Mesh. Untuk mengetahui informasi selengkapnya tentang memberi anotasi pada NEG, lihat Penamaan NEG.

Catatan: Paket trafficdirector_service_sample.yaml yang disediakan dengan panduan penyiapan ini menggunakan nama NEG service-test-neg.

...
metadata:
  annotations:
    cloud.google.com/neg: '{"exposed_ports": {"80":{"name": "service-test-neg"}}}'
spec:
  ports:
  - port: 80
    name: service-test
    protocol: TCP
    targetPort: 8000

Anotasi ini membuat NEG mandiri yang berisi endpoint yang sesuai dengan alamat IP dan port pod layanan. Untuk mengetahui informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri.

Contoh layanan berikut menyertakan anotasi NEG. Layanan ini menayangkan nama host melalui HTTP di port 80. Gunakan perintah berikut untuk mendapatkan layanan dan men-deploy-nya ke cluster GKE Anda.

wget -q -O - \
https://storage.googleapis.com/traffic-director/demo/trafficdirector_service_sample.yaml \
| kubectl apply -f -

Pastikan layanan baru dibuat dan pod aplikasi berjalan:

kubectl get svc

Outputnya akan mirip dengan berikut ini:

NAME             TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service-test     ClusterIP   10.71.9.71   none          80/TCP    41m
[..skip..]

Pastikan pod aplikasi yang terkait dengan layanan ini sedang berjalan:

kubectl get pods

Tindakan ini akan menampilkan:

NAME                        READY     STATUS    RESTARTS   AGE
app1-6db459dcb9-zvfg2       2/2       Running   0          6m
busybox-5dcf86f4c7-jvvdd    2/2       Running   0          10m
[..skip..]

Catatan: Karena injektor sidecar diaktifkan di namespace default, proxy sidecar juga dimasukkan ke pod layanan pengujian saat dibuat. Injector file bantuan hanya mengonfigurasi pencegatan untuk traffic keluar, sehingga proxy file bantuan layanan pengujian tidak terlibat dalam menangani traffic masuk dari klien contoh.

Menyimpan nama NEG

Temukan NEG yang dibuat dari contoh di atas dan catat namanya untuk konfigurasi Cloud Service Mesh di bagian berikutnya.

gcloud compute network-endpoint-groups list

Tindakan ini akan menampilkan hal berikut:

NAME                       LOCATION            ENDPOINT_TYPE       SIZE
service-test-neg           ZONE     GCE_VM_IP_PORT      1

Simpan nama NEG dalam variabel NEG_NAME:

NEG_NAME=$(gcloud compute network-endpoint-groups list \
| grep service-test | awk '{print $1}')

Catatan: Jika Anda memberi nama NEG, seperti yang dibahas dalam Mengonfigurasi layanan GKE dengan NEG Anda akan melihat bahwa nama NEG cocok dengan nama yang Anda berikan dalam spesifikasi layanan Kubernetes. Jika Anda tidak menamai NEG, nama akan dibuat secara otomatis untuk Anda.

Mengonfigurasi Cloud Service Mesh dengan komponen Cloud Load Balancing

Bagian ini mengonfigurasi Cloud Service Mesh menggunakan resource load balancing Compute Engine. Hal ini memungkinkan proxy sidecar klien contoh menerima konfigurasi dari Cloud Service Mesh. Permintaan keluar dari klien contoh ditangani oleh proxy sidecar dan dirutekan ke layanan pengujian.

Anda harus mengonfigurasi komponen berikut:

• Health check. Untuk mengetahui informasi selengkapnya tentang health check, baca Konsep Health Check dan Membuat Health Check.
• Layanan backend. Untuk mengetahui informasi selengkapnya tentang layanan backend, baca Layanan Backend.
• Peta aturan perutean. Hal ini mencakup pembuatan aturan penerusan, proxy HTTP target, dan peta URL. Untuk mengetahui informasi selengkapnya, baca artikel Menggunakan aturan penerusan untuk Cloud Service Mesh, Menggunakan proxy target untuk Cloud Service Mesh, dan Menggunakan peta URL.

Membuat aturan health check dan firewall

Gunakan petunjuk berikut untuk membuat health check dan aturan firewall yang diperlukan untuk pemeriksaan health check. Untuk mengetahui informasi selengkapnya, lihat Aturan firewall untuk health check.

Konsol

1. Buka halaman Health checks di konsol Google Cloud .
   Buka halaman Health checks
2. Klik Create Health Check.
3. Untuk nama, masukkan td-gke-health-check.
4. Untuk protokol, pilih HTTP.

5. Klik Create.

6. Buka halaman Firewall policies di konsol Google Cloud .
   Buka halaman Firewall policies

7. Klik Create firewall rules.

8. Di halaman Create a firewall rule, berikan informasi berikut:

   • Nama: Berikan nama untuk aturan. Untuk contoh ini, gunakan fw-allow-health-checks.
   • Network: Pilih jaringan VPC.
   • Prioritas: Masukkan angka untuk prioritas. Angka yang lebih rendah memiliki prioritas yang lebih tinggi. Pastikan aturan firewall memiliki prioritas yang lebih tinggi daripada aturan lain yang mungkin menolak traffic masuk.
   • Direction of traffic: Pilih Ingress.
   • Action on match: Pilih Allow.
   • Target: Pilih Semua instance di jaringan.
   • Filter sumber: Pilih jenis rentang IP yang benar.
   • Rentang IP sumber: 35.191.0.0/16,130.211.0.0/22
   • Filter tujuan: Pilih jenis IP.
   • Protocols and ports: Klik Specified ports and protocols, lalu centang tcp. TCP adalah protokol dasar untuk semua protokol health check.
   • Klik Create.

gcloud

1. Buat health check.

   gcloud compute health-checks create http td-gke-health-check \
     --use-serving-port
   

2. Buat aturan firewall untuk mengizinkan rentang alamat IP health checker.

   gcloud compute firewall-rules create fw-allow-health-checks \
     --action ALLOW \
     --direction INGRESS \
     --source-ranges 35.191.0.0/16,130.211.0.0/22 \
     --rules tcp
   

Membuat layanan backend

Buat layanan backend global dengan skema load balancing INTERNAL_SELF_MANAGED. Di konsol Google Cloud , skema load balancing ditetapkan secara implisit. Tambahkan pemeriksaan kesehatan ke layanan backend.

Konsol

1. Buka halaman Cloud Service Mesh di konsol Google Cloud .

   Buka halaman Cloud Service Mesh

2. Di tab Services, klik Create Service.

3. Klik Lanjutkan.

4. Untuk nama layanan, masukkan td-gke-service.

5. Pilih Network, yang Anda konfigurasi di Cloud Service Mesh ConfigMap.

6. Di bagian Backend type, pilih Network endpoint groups.

7. Pilih grup endpoint jaringan yang Anda buat.

8. Tetapkan Maximum RPS ke 5.

9. Tetapkan Balancing mode ke Rate.

10. Klik Done.

11. Di bagian Health check, pilih td-gke-health-check, yaitu health check yang Anda buat.

12. Klik Lanjutkan.

gcloud

1. Buat layanan backend dan kaitkan health check dengan layanan backend.

   gcloud compute backend-services create td-gke-service \
    --global \
    --health-checks td-gke-health-check \
    --load-balancing-scheme INTERNAL_SELF_MANAGED
   

2. Tambahkan NEG yang dibuat sebelumnya sebagai backend ke layanan backend. Jika Anda mengonfigurasi Cloud Service Mesh dengan proxy TCP target, Anda harus menggunakan mode load balancing UTILIZATION. Jika Anda menggunakan proxy target HTTP atau HTTPS, Anda dapat menggunakan mode RATE.

   gcloud compute backend-services add-backend td-gke-service \
    --global \
    --network-endpoint-group ${NEG_NAME} \
    --network-endpoint-group-zone ZONE \
    --balancing-mode [RATE | UTILIZATION] \
    --max-rate-per-endpoint 5
   

Membuat peta aturan perutean

Peta aturan perutean menentukan cara Cloud Service Mesh merutekan traffic di mesh Anda. Sebagai bagian dari peta aturan perutean, Anda mengonfigurasi alamat IP virtual (VIP) dan serangkaian aturan pengelolaan traffic terkait, seperti perutean berbasis host. Saat aplikasi mengirim permintaan ke VIP, proxy sidecar Envoy yang terlampir akan melakukan hal berikut:

1. Mencegat permintaan.
2. Mengevaluasinya sesuai dengan aturan pengelolaan traffic di peta URL.
3. Memilih layanan backend berdasarkan nama host dalam permintaan.
4. Memilih backend atau endpoint yang terkait dengan layanan backend yang dipilih.
5. Mengirim traffic ke backend atau endpoint tersebut.

Konsol

Di konsol, proxy target digabungkan dengan aturan penerusan. Saat Anda membuat aturan penerusan, Google Cloud akan otomatis membuat proxy HTTP target dan melampirkannya ke peta URL.

Aturan rute terdiri dari aturan penerusan serta aturan host dan jalur (juga dikenal sebagai peta URL).

1. Buka halaman Cloud Service Mesh di konsol Google Cloud .

   Buka halaman Cloud Service Mesh

2. Klik Peta aturan perutean

3. Klik Buat Aturan Perutean.

4. Masukkan td-gke-url-map sebagai Nama peta URL.

5. Klik Tambahkan aturan penerusan.

6. Untuk nama aturan penerusan, masukkan td-gke-forwarding-rule.

7. Pilih jaringan Anda.

8. Pilih Internal IP Anda.

9. Klik Simpan.

10. Jika perlu, tambahkan aturan host dan jalur kustom atau biarkan aturan jalur sebagai default.

11. Tetapkan host ke service-test.

12. Klik Simpan.

gcloud

1. Buat peta URL yang menggunakan td-gke-service sebagai layanan backend default.

   gcloud compute url-maps create td-gke-url-map \
      --default-service td-gke-service
   

2. Buat pencocok jalur peta URL dan aturan host untuk merutekan traffic untuk layanan Anda berdasarkan nama host dan jalur. Contoh ini menggunakan service-test sebagai nama layanan dan pencocok jalur default yang mencocokkan semua permintaan jalur untuk host ini (/*).

   gcloud compute url-maps add-path-matcher td-gke-url-map \
      --default-service td-gke-service \
      --path-matcher-name td-gke-path-matcher
   
   gcloud compute url-maps add-host-rule td-gke-url-map \
      --hosts service-test \
      --path-matcher-name td-gke-path-matcher
   

3. Buat proxy HTTP target.

   gcloud compute target-http-proxies create td-gke-proxy \
      --url-map td-gke-url-map
   

4. Membuat aturan penerusan.

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

Pada tahap ini, Cloud Service Mesh mengonfigurasi proxy sidecar Anda untuk merutekan permintaan yang menentukan nama host service-test ke backend td-gke-service. Dalam hal ini, backend tersebut adalah endpoint di grup endpoint jaringan yang terkait dengan layanan pengujian Kubernetes yang Anda deploy sebelumnya.

Catatan: Karena Anda mengonfigurasi layanan default (td-gke-service) untuk peta URL, setiap permintaan keluar yang ditangani oleh proxy sidecar akan dirutekan ke backend yang terkait dengan layanan default ini.

Memverifikasi konfigurasi

Bagian ini menunjukkan cara memverifikasi bahwa traffic yang dikirim dari klien Busybox sampel dirutekan ke layanan Kubernetes service-test Anda. Untuk mengirim permintaan pengujian, Anda dapat mengakses shell di salah satu penampung dan menjalankan perintah verifikasi berikut. Pod service-test harus menampilkan nama host dari pod penayangan.

# Get the name of the pod running Busybox.
BUSYBOX_POD=$(kubectl get po -l run=client -o=jsonpath='{.items[0].metadata.name}')

# Command to execute that tests connectivity to the service service-test at
# the VIP 10.0.0.1. Because 0.0.0.0 is configured in the forwarding rule, this
# can be any VIP.
TEST_CMD="wget -q -O - 10.0.0.1; echo"

# Execute the test command on the pod.
kubectl exec -it $BUSYBOX_POD -c busybox -- /bin/sh -c "$TEST_CMD"

Berikut cara konfigurasi diverifikasi:

• Klien contoh mengirim permintaan yang menentukan nama host service-test.
• Contoh klien memiliki proxy file bantuan Envoy yang disuntikkan oleh penyuntik file bantuan Envoy.
• Proxy sidecar mencegat permintaan.
• Dengan menggunakan peta URL, Envoy mencocokkan nama host service-test dengan layanan Cloud Service Mesh td-gke-service.
• Envoy memilih endpoint dari grup endpoint jaringan yang terkait dengan td-gke-service.
• Envoy mengirim permintaan ke pod yang terkait dengan layanan Kubernetes service-test.

Cara Bermigrasi ke Managed Sidecar Injector

Tutorial ini memandu Anda memigrasikan aplikasi dari injector sidecar Traffic Director lama di GKE (dengan injector sidecar dalam cluster) ke aplikasi yang menggunakan injector sidecar terkelola.

Menonaktifkan injeksi sidecar dalam cluster

Perintah berikut akan menonaktifkan injector sidecar dalam cluster lama untuk namespace default

kubectl label namespace default istio-injection-

Membersihkan injector sidecar dalam cluster

Download dan ekstrak injector file bantuan Envoy lama.

wget https://storage.googleapis.com/traffic-director/td-sidecar-injector-xdsv3.tgz
tar -xzvf td-sidecar-injector-xdsv3.tgz
cd td-sidecar-injector-xdsv3

Menghapus resource injector sidecar dalam cluster

kubectl delete -f specs/

Langkah berikutnya

• Pelajari pengelolaan traffic lanjutan
• Pelajari keamanan layanan Cloud Service Mesh.
• Pelajari cara menyiapkan kemampuan observasi dengan Envoy.
• Pelajari cara memecahkan masalah deployment Cloud Service Mesh.
• Pelajari opsi untuk penyiapan Pod Google Kubernetes Engine dengan injeksi Envoy otomatis.