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 informasi selengkapnya, lihat ringkasan Cloud Service Mesh.

Dalam mesh layanan, 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.

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

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

Proses penyiapan melibatkan:

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 mengirim permintaan dari klien contoh ke layanan pengujian.

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

Prasyarat

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

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

Catatan: Injektor sidecar dan proxy yang dimasukkan didasarkan pada injektor sidecar Istio. Jangan instal 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 benar 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 VPC dan subnet.
• 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. Konfigurasikan izin IAM di project host agar 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 Compute Network User IAM (roles/compute.networkUser) ke akun layanan default compute Compute Engine dan akun layanan Google Cloud API 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, konfigurasikan 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 Kubernetes Engine Host Service Agent User (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 akan menggunakan akun layanan host virtual machine (VM) Compute Engine atau instance node GKE. Akun layanan harus memiliki izin IAM level project compute.globalForwardingRules.get. Peran Compute Network Viewer sudah cukup untuk langkah ini.

Mengonfigurasi informasi project

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

# The project that contains your GKE cluster.
export CLUSTER_PROJECT_ID=YOUR_CLUSTER_PROJECT_NUMBER_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 match the channel of your GKE cluster.
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_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, gunakan petunjuk berikut untuk menetapkan 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_PROJECT_NUMBER_HERE

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

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

Mengaktifkan Mesh Config API

Aktifkan API berikut untuk memulai dengan 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 Mengaktifkan 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

Menerapkan konfigurasi untuk Mutating Webhook

Bagian berikut memberikan petunjuk untuk menerapkan MutatingWebhookConfiguration ke cluster. Saat pod dibuat, pengontrol penerimaan dalam cluster akan dipanggil. Pengontrol penerimaan, berkomunikasi dengan penginjek sidecar yang dikelola untuk menambahkan penampung Envoy ke pod.

Terapkan konfigurasi webhook yang mengubah 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. Injektor sidecar memasukkan penampung sidecar ke pod yang dibuat di bawah 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

Tindakan 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 penampung. Penampung pertama adalah klien berdasarkan image Busybox dan penampung kedua adalah proxy Envoy yang dimasukkan oleh injector sidecar. Anda bisa mendapatkan informasi selengkapnya tentang pod dengan menjalankan perintah berikut:

kubectl describe pods -l run=client

Tindakan 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

Injektor sidecar terkelola akan menggunakan image Cloud Service Mesh Proxy sebagai proxy. Cloud Service Mesh Proxy adalah penampung sidecar yang bertanggung jawab untuk memulai proxy envoy untuk instance yang mengaktifkan mesh. Image proxy menggunakan image envoy OSS bersama dengan agen proxy yang bertanggung jawab untuk memulai envoy, menyediakan konfigurasi bootstrap, dan memeriksa status envoy. Versi image Cloud Service Mesh Proxy sesuai dengan versi OSS Envoy. Anda dapat melacak image proxy yang tersedia di sini: https://gcr.io/gke-release/asm/csm-mesh-proxy

Cloud Service Mesh Mesh Proxy yang dimasukkan bervariasi berdasarkan saluran yang dipilih pengguna untuk cluster GKE. Versi Envoy diupdate secara berkala berdasarkan rilis Envoy OSS saat ini dan diuji dengan rilis GKE tertentu untuk memastikan kompatibilitas.

Versi Proxy Cloud Service Mesh

Tabel berikut menunjukkan pemetaan versi Cloud Service Mesh Proxy ke saluran cluster GKE saat ini:

Saluran	Versi Proxy Cloud Service Mesh
Cepat	1.29.9-gke.3
Reguler	1.28.7-gke.3
Stabil	1.27.7-gke.3

Upgrade Proxy Cloud Service Mesh

Sebaiknya upgrade ke versi terbaru. Meskipun mesh layanan tidak masalah jika bidang kontrol dan proxy berada di versi yang berbeda, sebaiknya perbarui proxy agar dikonfigurasi dengan versi Cloud Service Mesh yang baru.

Injektor sidecar terkelola menangani versi Envoy yang selalu memasukkan versi Envoy terbaru yang memenuhi syarat oleh Google. Jika versi Cloud Service Mesh Proxy lebih baru dari 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 menyeluruh atas 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 dan pilih nama (dengan mengganti NEG-NAME dalam contoh di bawah) sehingga Anda dapat menemukannya dengan mudah nanti. Anda memerlukan nama tersebut saat melampirkan NEG ke layanan backend Cloud Service Mesh. Untuk mengetahui informasi selengkapnya tentang menganotasi NEG, lihat Penamaan NEG.

Catatan: Paket trafficdirector_service_sample.yaml yang disertakan 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 injector sidecar diaktifkan di namespace default, proxy sidecar juga dimasukkan ke pod layanan pengujian saat dibuat. Injektor sidecar hanya mengonfigurasi intersepsi untuk traffic keluar, sehingga proxy sidecar 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 telah 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 memberi nama 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. Tindakan 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 Menggunakan aturan penerusan untuk Cloud Service Mesh, Menggunakan proxy target untuk Cloud Service Mesh, dan Menggunakan peta URL.

Membuat aturan firewall dan health check

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 Kebijakan firewall

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.
   • Targets: Pilih All instances in the network.
   • 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 health check 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 ConfigMap Cloud Service Mesh.

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, yang merupakan 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 mengonfigurasi Cloud Service Mesh dengan proxy TCP target, Anda harus menggunakan mode 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 terpasang akan melakukan hal berikut:

1. Mencegah 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 melampirkan proxy tersebut 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 Routing rule maps

3. Klik Buat Aturan Pemilihan Rute.

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. Secara opsional, 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 cocok dengan 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 dalam 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 contoh 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 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 memverifikasi konfigurasi:

• Klien contoh mengirimkan permintaan yang menentukan nama host service-test.
• Klien contoh memiliki proxy sidecar Envoy yang dimasukkan oleh penginjeksi sidecar 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 Injector Sidecar Terkelola

Tutorial ini memandu Anda memigrasikan aplikasi dari penginjeksi sidecar Cloud Service Mesh lama di GKE (dengan penginjeksi sidecar dalam cluster) ke aplikasi yang menggunakan penginjeksi sidecar terkelola.

Menonaktifkan injeksi sidecar dalam cluster

Perintah berikut menonaktifkan injector sidecar dalam cluster lama untuk namespace default

kubectl label namespace default istio-injection-

Membersihkan injektor sidecar dalam cluster

Download dan ekstrak injector sidecar 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 selanjutnya

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