Menyiapkan Pod Google Kubernetes Engine menggunakan injeksi Envoy manual
Panduan ini menunjukkan cara mengonfigurasi host Pod Kubernetes atau Kubernetes Engine, serta komponen load balancing yang diperlukan Cloud Service Mesh.
Sebelum mengikuti petunjuk dalam panduan ini, tinjau Menyiapkan penyiapan Cloud Service Mesh dan pastikan Anda telah menyelesaikan prasyarat.
Anda dapat mengonfigurasi Cloud Service Mesh menggunakan load balancing SDK Compute Engine atau REST API. Lihat referensi API load balancing dan gcloud.
Mengonfigurasi cluster GKE/Kubernetes untuk Cloud Service Mesh
Bagian ini menjelaskan langkah-langkah yang diperlukan untuk mengaktifkan cluster GKE/Kubernetes agar berfungsi dengan Cloud Service Mesh.
Membuat cluster GKE
Cluster GKE harus memenuhi persyaratan berikut:
- Dukungan grup endpoint jaringan harus diaktifkan. 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 tentang izin yang diperlukan, lihat Mengaktifkan akun layanan untuk mengakses Cloud Service Mesh API.
- Untuk mengetahui informasi tentang cara mengaktifkan Cloud Service Mesh API, baca artikel Mengaktifkan 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.
Contoh berikut menunjukkan cara membuat cluster GKE
bernama traffic-director-cluster
di zona us-central1-a
.
Konsol
Untuk membuat cluster menggunakan konsol Google Cloud, lakukan langkah-langkah berikut:
Buka menu Kubernetes Engine di Konsol Google Cloud.
Klik Buat kluster.
Lengkapi kolom berikut:
- Nama: Masukkan
traffic-director-cluster
. - Jenis lokasi:
Zonal
. - Zona:
us-central1-a
.
- Nama: Masukkan
Dari panel navigasi, di bagian Node Pools, klik default-pool.
Kolom Size menunjukkan jumlah node yang akan dibuat dalam cluster. Anda harus memiliki kuota resource yang tersedia untuk node dan resource-nya (seperti rute firewall).
Dari panel navigasi, di bagian default-pool, klik Nodes.
Kolom Machine type menunjukkan jenis mesin Compute Engine yang akan digunakan untuk instance tersebut. Setiap jenis mesin ditagih secara berbeda. Untuk informasi harga jenis mesin, lihat halaman harga Compute Engine.
Dari panel navigasi, di bagian default-pool, klik Keamanan.
Pada bagian Cakupan akses, klik Izinkan akses penuh ke semua Cloud API.
Sesuaikan cluster Anda seperlunya.
Klik Create.
Setelah membuat cluster di konsol Google Cloud, Anda perlu mengonfigurasi
kubectl
agar dapat berinteraksi dengan cluster. Untuk mempelajari lebih lanjut, lihat
Membuat entri kubeconfig
.
gcloud
gcloud container clusters create traffic-director-cluster \ --zone us-central1-a \ --scopes=https://www.googleapis.com/auth/cloud-platform \ --enable-ip-alias
Memperoleh hak istimewa cluster GKE yang diperlukan
Untuk GKE, beralihlah ke cluster(2) yang baru saja Anda buat dengan menjalankan perintah berikut. Perintah ini akan mengarahkan kubectl ke cluster yang benar.
gcloud container clusters get-credentials traffic-director-cluster \ --zone us-central1-a
Mengonfigurasi layanan GKE/Kubernetes
Bagian ini menunjukkan cara menyiapkan spesifikasi deployment Kubernetes agar berfungsi dengan Cloud Service Mesh. Cara ini terdiri dari mengonfigurasi layanan dengan NEG serta memasukkan proxy file bantuan ke Pod yang memerlukan akses ke layanan yang dikelola oleh Cloud Service Mesh.
Konfigurasikan aturan firewall
Untuk memastikan Pod backend sudah berjalan, Anda harus mengonfigurasi aturan firewall yang mengizinkan rentang alamat IP health checker.
Konsol
- Buka halaman Firewall policies di Konsol Google Cloud.
Buka halaman Kebijakan firewall - Klik Create firewall rules.
- 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.
- Priority: Masukkan angka untuk prioritas. Angka yang lebih rendah memiliki prioritas yang lebih tinggi. Pastikan aturan firewall memiliki prioritas lebih tinggi daripada aturan lain yang mungkin menolak traffic masuk.
- Arah traffic: Pilih ingress.
- Tindakan pada kecocokan: Pilih izinkan.
- Target: 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.
- Nama: Berikan nama untuk aturan. Untuk contoh ini, gunakan
gcloud
Gunakan perintah
gcloud
berikut untuk membuat aturan firewall bernamafw-allow-health-checks
yang mengizinkan koneksi masuk ke instance di jaringan Anda dengan tagallow-health-checks
. Ganti NETWORK_NAME dengan nama jaringan Anda.gcloud compute firewall-rules create fw-allow-health-checks \ --network NETWORK_NAME \ --action ALLOW \ --direction INGRESS \ --source-ranges 35.191.0.0/16,130.211.0.0/22 \ --rules tcp
Untuk mengetahui informasi selengkapnya, lihat mengonfigurasi aturan firewal untuk health check.
Mengonfigurasi layanan GKE / Kubernetes 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, lalu
pilih nama (dengan mengganti NEG-NAME
pada contoh di bawah) sehingga Anda dapat
menemukannya dengan mudah nanti. Anda memerlukan nama tersebut saat melampirkan NEG ke layanan backend Cloud Service Mesh. Untuk informasi lebih lanjut tentang cara menganotasi NEG, lihat Penamaan NEG.
... metadata: annotations: cloud.google.com/neg: '{"exposed_ports": {"80":{"name": "NEG-NAME"}}}' spec: ports: - port: 80 name: service-test protocol: TCP targetPort: 8000
Untuk setiap layanan, NEG mandiri akan dibuat, yang berisi endpoint yang merupakan alamat IP dan port pod. Untuk mengetahui informasi dan contoh selengkapnya, lihat Grup endpoint jaringan mandiri.
Untuk tujuan demonstrasi, Anda dapat men-deploy layanan contoh yang melayani nama host-nya melalui HTTP di port 80:
wget -q -O - \ https://storage.googleapis.com/traffic-director/demo/trafficdirector_service_sample.yaml \ | kubectl apply -f -
Pastikan nama host layanan yang baru telah dibuat dan Pod aplikasi sedang berjalan:
kubectl get svc
Tindakan ini akan menampilkan:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service-test ClusterIP 10.71.9.71 none 80/TCP 41m [..skip..]
kubectl get pods
Tindakan ini akan menampilkan:
NAME READY STATUS RESTARTS AGE app1-6db459dcb9-zvfg2 1/1 Running 0 6m [..skip..]
Menyimpan nama NEG
Temukan NEG yang dibuat dari contoh di atas dan catat nama NEG tersebut.
Konsol
Untuk melihat daftar grup endpoint jaringan, buka halaman Grup Endpoint Jaringan
di Konsol Google Cloud.
Buka halaman Network Endpoint Groups
gcloud
gcloud compute network-endpoint-groups list
Hasil dari kueri tersebut adalah sebagai berikut:
NAME LOCATION ENDPOINT_TYPE SIZE NEG-NAME us-central1-a GCE_VM_IP_PORT 1
Simpan nama NEG dalam variabel NEG_NAME
, misalnya:
NEG_NAME=$(gcloud compute network-endpoint-groups list \ | grep service-test | awk '{print $1}')
Mengonfigurasi komponen load balancing Google Cloud untuk Cloud Service Mesh
Petunjuk di bagian ini memastikan bahwa layanan GKE dapat diakses di load balancing VIP layanan oleh Cloud Service Mesh, menggunakan konfigurasi load balancing yang mirip dengan produk Google Cloud Load Balancing lainnya.
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 Backend Services.
- Aturan rute. Hal ini termasuk membuat aturan penerusan dan peta URL. Untuk mengetahui informasi selengkapnya, baca Menggunakan aturan penerusan dan Menggunakan peta URL.
Contoh konfigurasi Cloud Service Mesh berikut menghasilkan asumsi berikut:
- NEG dan semua resource lainnya dibuat dalam jaringan
default
, dengan mode otomatis, di zonaus-central1-a
. - Nama NEG untuk cluster disimpan dalam variabel
${NEG_NAME}
.
Membuat health check
Membuat health check.
Konsol
- Buka halaman Health check di Konsol Google Cloud.
Buka halaman Health check - Klik Create Health Check.
- Untuk nama, masukkan
td-gke-health-check
. - Untuk protokol, pilih HTTP.
- Klik Create.
gcloud
gcloud compute health-checks create http td-gke-health-check \ --use-serving-port
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
Buka halaman Cloud Service Mesh di Konsol Google Cloud.
Pada tab Services, klik Create Service.
Klik Lanjutkan.
Untuk nama layanan, masukkan
td-gke-service
.Di bagian Backend type, pilih Network endpoint groups.
Pilih grup endpoint jaringan yang Anda buat.
Setel Maximum RPS ke
5
.Klik Selesai.
Di bagian Health check, pilih
td-gke-health-check
, yang merupakan health check yang Anda buat.Klik Lanjutkan.
gcloud
Membuat layanan backend dan mengaitkan 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
Tambahkan NEG backend ke layanan backend.
gcloud compute backend-services add-backend td-gke-service \ --global \ --network-endpoint-group ${NEG_NAME} \ --network-endpoint-group-zone us-central1-a \ --balancing-mode RATE \ --max-rate-per-endpoint 5
Membuat peta aturan perutean
Gunakan petunjuk ini untuk membuat aturan rute, aturan penerusan, dan alamat IP internal untuk konfigurasi Cloud Service Mesh Anda.
Traffic yang dikirim ke alamat IP internal dicegat oleh proxy Envoy dan dikirim ke layanan yang sesuai sesuai dengan aturan host dan jalur.
Aturan penerusan dibuat sebagai aturan penerusan global dengan load-balancing-scheme
yang ditetapkan ke INTERNAL_SELF_MANAGED
.
Anda dapat menetapkan alamat aturan penerusan ke 0.0.0.0
. Jika Anda melakukannya, traffic akan dirutekan berdasarkan nama host HTTP dan informasi jalur yang dikonfigurasi di peta URL, terlepas dari alamat IP sebenarnya yang ditetapkan oleh nama host.
Dalam hal ini, URL (nama host dan jalur URL) layanan Anda, seperti yang dikonfigurasi
dalam aturan host, harus unik dalam konfigurasi mesh layanan Anda. Artinya, Anda tidak dapat memiliki dua layanan berbeda, dengan kumpulan backend berbeda,
yang menggunakan kombinasi nama host dan jalur yang sama.
Atau, Anda dapat mengaktifkan pemilihan rute berdasarkan VIP tujuan layanan yang sebenarnya. Jika Anda mengonfigurasi VIP layanan sebagai parameter address
dari aturan penerusan, hanya permintaan yang ditujukan ke alamat IP ini yang dirutekan berdasarkan parameter HTTP yang ditentukan dalam peta URL.
Konsol
Di konsol, proxy target digabungkan dengan aturan penerusan. Saat Anda membuat aturan penerusan, Google Cloud 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).
Buka halaman Cloud Service Mesh di Konsol Google Cloud.
Klik Peta aturan pemilihan rute
Klik Create Routing Rule.
Masukkan
td-gke-url-map
sebagai Nama peta URL.Klik Tambahkan aturan penerusan.
Untuk nama aturan penerusan, masukkan
td-gke-forwarding-rule
.Pilih jaringan Anda.
Pilih Internal IP.
Klik Simpan.
Anda juga dapat menambahkan aturan host dan jalur kustom atau membiarkan aturan jalur sebagai default.
Tetapkan host ke
service-test
.Klik Simpan.
gcloud
Membuat peta URL yang menggunakan layanan backend.
gcloud compute url-maps create td-gke-url-map \ --default-service td-gke-service
Buat pencocok jalur peta URL dan aturan host untuk mengarahkan 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 (/*
).service-test
juga merupakan nama yang dikonfigurasi dari layanan Kubernetes yang digunakan dalam contoh konfigurasi di atas.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
Membuat proxy HTTP target.
gcloud compute target-http-proxies create td-gke-proxy \ --url-map td-gke-url-map
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 dikonfigurasi untuk melakukan load balancing pada traffic untuk layanan yang ditentukan dalam peta URL di seluruh backend dalam grup endpoint jaringan.
Bergantung pada cara microservice didistribusikan di jaringan Anda, Anda mungkin perlu menambahkan lebih banyak aturan penerusan atau lebih banyak aturan host dan jalur ke peta URL.
Memverifikasi konfigurasi dengan men-deploy klien contoh untuk pengujian
Bagian ini menunjukkan cara menjangkau backend Cloud Service Mesh dari aplikasi klien.
Untuk mendemonstrasikan fungsi, Anda dapat men-deploy contoh Pod yang menjalankan Listenbox. Pod memiliki akses ke service-test
yang telah dibuat di bagian sebelumnya dan menerima traffic yang di-load balanced oleh Cloud Service Mesh.
Memasukkan proxy file bantuan ke Pod GKE / Kubernetes
Untuk mengakses layanan yang dikelola oleh Cloud Service Mesh, Pod harus menginstal proxy file bantuan yang kompatibel dengan xDS API.
Dalam contoh ini, Anda men-deploy klien sibuk dengan sidecar Istio-proxy dan init container yang ditambahkan ke deployment menggunakan spesifikasi referensi.
Jika Anda menggunakan API lama, ganti variabel PROJECT_NUMBER dan NETWORK_NAME dengan nomor project dan nama jaringan Anda:
wget -q -O - https://storage.googleapis.com/traffic-director/demo/trafficdirector_client_sample_xdsv3.yaml sed -i "s/PROJECT_NUMBER/PROJECT_NUMBER/g" trafficdirector_client_sample_xdsv3.yaml sed -i "s/NETWORK_NAME/NETWORK_NAME/g" trafficdirector_client_sample_xdsv3.yaml kubectl apply -f trafficdirector_client_sample_xdsv3.yaml
Jika Anda menggunakan API pemilihan rute layanan baru, yang saat ini masih dalam pratinjau, ganti variabel PROJECT_NUMBER dan MESH_NAME dengan nomor project dan nama Mesh
:
wget -q -O - https://storage.googleapis.com/traffic-director/demo/trafficdirector_client_new_api_sample_xdsv3.yaml sed -i "s/PROJECT_NUMBER/PROJECT_NUMBER/g" trafficdirector_client_new_api_sample_xdsv3.yaml sed -i "s/MESH_NAME/MESH_NAME/g" trafficdirector_client_new_api_sample_xdsv3.yaml kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
Pod indikator ramai ini memiliki dua container yang sedang berjalan. Penampung pertama adalah klien berdasarkan image Livelybox dan penampung kedua adalah proxy Envoy yang dimasukkan sebagai file bantuan. Anda dapat memperoleh informasi selengkapnya tentang Pod dengan menjalankan perintah berikut:
kubectl describe pods -l run=client
Menjangkau layanan backend
Setelah dikonfigurasi, aplikasi di Pod yang memiliki proxy file bantuan yang dimasukkan dapat mengakses layanan yang dikelola oleh layanan Cloud Service Mesh. Untuk memverifikasi konfigurasi, Anda dapat mengakses shell di salah satu penampung.
Jika menggunakan konfigurasi demo yang diberikan dalam panduan ini, Anda dapat menjalankan perintah verifikasi berikut untuk memastikan bahwa nama host Pod yang melakukan penayangan ditampilkan.
# Get name of the Pod with 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. TEST_CMD="wget -q -O - service-test; echo" # Execute the test command on the Pod . kubectl exec -it $BUSYBOX_POD -c busybox -- /bin/sh -c "$TEST_CMD"
Memahami intersepsi traffic oleh proxy file bantuan
Perlu diperhatikan bahwa dalam contoh ini, saat klien Lively membuat permintaan ke layanan backend, setiap permintaan akan di-proxy-kan oleh proxy file bantuan.
Aplikasi demonstrasi ini menggunakan proxy Envoy. Oleh karena itu, klien akan melihat 'server: envoy' di header respons server.
Untuk mengonfirmasi hal ini, gunakan perintah berikut:
# Get the name of the Pod with Busybox. BUSYBOX_POD=$(kubectl get po -l run=client -o=jsonpath='{.items[0].metadata.name}') # Command to send a request to service-test and output server response headers. TEST_CMD="wget -S --spider service-test; echo" # Execute the test command on the Pod . kubectl exec -it $BUSYBOX_POD -c busybox -- /bin/sh -c "$TEST_CMD"
Dalam contoh ini, Anda membuat aturan penerusan menggunakan alamat VIP 0.0.0.0.
Ini berarti Cloud Service Mesh meneruskan permintaan ke backend hanya berdasarkan header Host
. Dalam hal ini, alamat IP tujuan dapat berupa alamat apa pun, asalkan header host permintaan cocok dengan host yang ditentukan dalam peta URL service-test
.
Untuk mengonfirmasi, jalankan perintah pengujian berikut:
# Get name of the Pod with Busybox. BUSYBOX_POD=$(kubectl get po -l run=client -o=jsonpath='{.items[0].metadata.name}') # Command to send a request to service-test setting the Host header and using a random IP address. TEST_CMD="wget -q --header 'Host: service-test' -O - 1.2.3.4; echo" # Execute the test command on the Pod . kubectl exec -it $BUSYBOX_POD -c busybox -- /bin/sh -c "$TEST_CMD"
Langkah selanjutnya
- Pelajari pengelolaan traffic lanjutan.
- Pelajari cara memecahkan masalah deployment Cloud Service Mesh.
- Pelajari cara menyiapkan kemampuan observasi dengan Envoy.