Pengujian beban terdistribusi menggunakan Google Kubernetes Engine

Last reviewed 2022-04-22 UTC

---

Tutorial ini menjelaskan cara menggunakan Google Kubernetes Engine (GKE) untuk men-deploy framework pengujian beban terdistribusi yang menggunakan beberapa container untuk membuat traffic untuk API berbasis REST sederhana. Tutorial ini menguji beban aplikasi web yang di-deploy ke App Engine yang mengekspos endpoint bergaya REST untuk merespon permintaan POST HTTP yang masuk.

Anda dapat menggunakan pola yang sama ini untuk membuat framework pengujian beban untuk berbagai skenario dan aplikasi, seperti sistem fitur pesan, sistem pengelolaan aliran data, dan sistem database.

Tujuan

• Menentukan variabel lingkungan guna mengontrol konfigurasi deployment.
• Membuat cluster GKE.
• Melakukan pengujian beban.
• Secara opsional meningkatkan jumlah pengguna atau memperluas pola ke kasus pengguna lain.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• App Engine
• Artifact Registry
• Cloud Build
• Cloud Storage
• Google Kubernetes Engine

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Aktifkan API App Engine, Artifact Registry, Cloud Build, Compute Engine, Resource Manager, Google Kubernetes Engine, and Identity and Access Management.

   Mengaktifkan API

5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

6. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

7. Aktifkan API App Engine, Artifact Registry, Cloud Build, Compute Engine, Resource Manager, Google Kubernetes Engine, and Identity and Access Management.

   Mengaktifkan API

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

8. Berikan peran ke Akun Google Anda. Jalankan perintah berikut satu kali untuk setiap peran IAM berikut: roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/appengine.appAdmin, roles/appengine.appCreator, roles/artifactregistry.admin, roles/resourcemanager.projectIamAdmin, roles/compute.instanceAdmin.v1, roles/iam.serviceAccountUser, roles/cloudbuild.builds.builder, roles/iam.serviceAccountAdmin

   gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE

   • Ganti PROJECT_ID dengan project ID Anda.
   • Ganti EMAIL_ADDRESS dengan alamat email Anda.
   • Ganti ROLE dengan setiap peran individual.

Contoh workload

Diagram berikut menunjukkan contoh workload saat permintaan beralih dari klien ke aplikasi.

Untuk membuat model interaksi ini, Anda dapat menggunakan Locust, alat pengujian beban berbasis Python terdistribusi yang dapat mendistribusikan permintaan di beberapa jalur target. Sebagai contoh, Locust dapat mendistribusikan permintaan ke jalur target /login dan /metrics Workload dimodelkan sebagai serangkaian tugas di Locust.

Arsitektur

Arsitektur ini melibatkan dua komponen utama:

• Image container Docker Locust.
• Orkestrasi container dan mekanisme pengelolaan.

Image container Docker Locust berisi software Locust. Dockerfile, yang Anda dapatkan saat meng-clone repositori GitHub yang menyertai tutorial ini, menggunakan gambar dasar Python dan menyertakan skrip untuk memulai layanan Locust dan menyetujui tugas. Untuk memperkirakan klien di dunia nyata, setiap tugas Locust diberi bobot. Sebagai contoh example, pendaftaran terjadi sekali per seribu total permintaan klien.

GKE menyediakan orkestrasi dan pengelolaan container. Dengan GKE, Anda dapat menentukan jumlah node container yang menyediakan dasar untuk framework pengujian beban. Anda juga dapat mengatur pekerja pengujian beban ke dalam Pod, dan menentukan berapa banyak Pod yang Anda inginkan agar GKE tetap berjalan.

Untuk men-deploy tugas pengujian beban, Anda dapat melakukan hal berikut:

1. Men-deploy master pengujian beban.
2. Men-deploy sekelompok pekerja pengujian beban. Dengan pekerja pengujian beban ini, Anda dapat membuat traffic dalam jumlah yang besar untuk tujuan pengujian.

Diagram berikut menunjukkan arsitektur yang mendemonstrasikan pengujian beban menggunakan contoh aplikasi. Pod master menayangkan antarmuka web yang digunakan untuk mengoperasikan dan memantau pengujian beban. Pod pekerja menghasilkan traffic permintaan REST untuk aplikasi yang sedang diuji, dan mengirimkan metrik ke master.

Catatan: Menghasilkan traffic dalam jumlah berlebihan ke sistem eksternal dapat menyerupai serangan denial-of-service. Pastikan untuk meninjau Persyaratan Layanan Google Cloud dan Kebijakan Penggunaan yang Dapat Diterima untuk Google Cloud.

Tentang master pengujian beban

Master Locust adalah titik entri untuk menyetujui tugas pengujian beban. Konfigurasi master Locust menentukan beberapa elemen, termasuk port default yang digunakan oleh container:

• 8089 untuk antarmuka web
• 5557 dan 5558 untuk berkomunikasi dengan pekerja

Informasi ini nantinya digunakan untuk mengkonfigurasi pekerja Locust.

Anda dapat men-deploy Layanan untuk memastikan bahwa port yang diperlukan dapat diakses oleh Pod lain dalam cluster melalui hostname:port Port tersebut juga dapat direferensikan melalui nama port deskriptif.

Layanan ini mengizinkan pekerja Locust dengan mudah menemukan dan berkomunikasi secara andal dengan master, meskipun master gagal dan diganti dengan Pod baru oleh Deployment.

Layanan kedua di-deploy dengan anotasi yang diperlukan untuk membuat Load Balancer Jaringan passthrough internal yang membuat Layanan aplikasi web Locust dapat diakses oleh klien di luar cluster Anda yang menggunakan jaringan VPC yang sama dan berada di region Google Cloud yang sama dengan cluster Anda.

After Anda men-deploy master Locust master, Anda dapat membuka antarmuka web menggunakan alamat IP pribadi yang disediakan oleh Load Balancer Jaringan passthrough internal. Setelah Anda men-deploy pekerja Locust, Anda dapat memulai simulasi dan melihat statistik gabungan melalui antarmuka web Locust.

Tentang pekerja pengujian beban

Pekerja Locust workers menyetujui tugas pengujian beban. Anda menggunakan satu Deployment untuk membuat beberapa Pod. Penyebaran pod terjadi di seluruh cluster Kubernetes. Setiap Pod menggunakan variabel lingkungan untuk mengontrol informasi konfigurasi, seperti nama host sistem yang sedang diuji dan nama host dari master Locust.

Diagram berikut menunjukkan hubungan antara master Locust dan pekerja Locust.

Melakukan inisialisasi variabel umum

Anda harus menentukan beberapa variabel yang mengontrol tempat elemen infrastruktur yang di-deploy.

1. Buka Cloud Shell:

   Buka Cloud Shell

   Anda menjalankan semua perintah terminal dalam tutorial ini dari Cloud Shell.

2. Tetapkan variabel lingkungan yang memerlukan penyesuaian:

   export GKE_CLUSTER=GKE_CLUSTER
   export AR_REPO=AR_REPO
   export REGION=REGION
   export ZONE=ZONE
   export SAMPLE_APP_LOCATION=SAMPLE_APP_LOCATION
   

   Ganti kode berikut:

   • GKE_CLUSTER : nama dari cluster GKE Anda.
   • AR_REPO: nama repositori Artifact Registry Anda
   • REGION : region tempat cluster GKE dan repositori Artifact Registry Anda akan dibuat
   • ZONE : zona di region Anda tempat instance Compute Engine Anda akan dibuat
   • SAMPLE_APP_LOCATION : lokasi (regional) tempat contoh aplikasi App Engine Anda akan di-deploy

   Perintahnya akan terlihat seperti contoh berikut:

   export GKE_CLUSTER=gke-lt-cluster
   export AR_REPO=dist-lt-repo
   export REGION=us-central1
   export ZONE=us-central1-b
   export SAMPLE_APP_LOCATION=us-central
   

3. Tetapkan variabel lingkungan tambahan berikut:

   export GKE_NODE_TYPE=e2-standard-4
   export GKE_SCOPE="https://www.googleapis.com/auth/cloud-platform"
   export PROJECT=$(gcloud config get-value project)
   export SAMPLE_APP_TARGET=${PROJECT}.appspot.com
   

4. Tetapkan zona default sehingga Anda tidak perlu untuk menentukan nilai ini dalam perintah berikutnya:

   gcloud config set compute/zone ${ZONE}
   

Membuat cluster GKE

1. Buat akun layanan dengan izin minimum yang diperlukan oleh cluster:

   gcloud iam service-accounts create dist-lt-svc-acc
   gcloud projects add-iam-policy-binding  ${PROJECT} --member=serviceAccount:dist-lt-svc-acc@${PROJECT}.iam.gserviceaccount.com --role=roles/artifactregistry.reader
   gcloud projects add-iam-policy-binding  ${PROJECT} --member=serviceAccount:dist-lt-svc-acc@${PROJECT}.iam.gserviceaccount.com --role=roles/container.nodeServiceAccount
   

2. Buat cluster GKE:

   gcloud container clusters create ${GKE_CLUSTER} \
   --service-account=dist-lt-svc-acc@${PROJECT}.iam.gserviceaccount.com \
   --region ${REGION} \
   --machine-type ${GKE_NODE_TYPE} \
   --enable-autoscaling \
   --num-nodes 3 \
   --min-nodes 3 \
   --max-nodes 10 \
   --scopes "${GKE_SCOPE}"
   

3. Hubungkan ke cluster GKE

   gcloud container clusters get-credentials ${GKE_CLUSTER} \
      --region ${REGION} \
      --project ${PROJECT}
   

Menyiapkan lingkungan

1. Clone repositori contoh dari GitHub:

   git clone https://github.com/GoogleCloudPlatform/distributed-load-testing-using-kubernetes
   

2. Ubah direktori kerja Anda ke repositori yang di-clone:

   cd distributed-load-testing-using-kubernetes
   

Membangun image container

1. Buat repositori Artifact Registry:

   gcloud artifacts repositories create ${AR_REPO} \
       --repository-format=docker  \
       --location=${REGION} \
       --description="Distributed load testing with GKE and Locust"

2. Membangun image container dan simpan di repositori Artifact Registry Anda:

   export LOCUST_IMAGE_NAME=locust-tasks
   export LOCUST_IMAGE_TAG=latest
   gcloud builds submit \
       --tag ${REGION}-docker.pkg.dev/${PROJECT}/${AR_REPO}/${LOCUST_IMAGE_NAME}:${LOCUST_IMAGE_TAG} \
       docker-image
   

   Image Docker Locust yang menyertainya menyematkan tugas pengujian yang memanggil endpoint /login dan /metrics dalam aplikasi contoh. Dalam contoh kumpulan tugas pengujian ini, rasio masing-masing permintaan yang dikirimkan kedua endpoint ini adalah 1 dari 999.

   
   class MetricsTaskSet(TaskSet):
       _deviceid = None
   
       def on_start(self):
           self._deviceid = str(uuid.uuid4())
   
       @task(1)
       def login(self):
           self.client.post(
               '/login', {"deviceid": self._deviceid})
   
       @task(999)
       def post_metrics(self):
           self.client.post(
               "/metrics", {"deviceid": self._deviceid, "timestamp": datetime.now()})
   
   class MetricsLocust(FastHttpUser):
       tasks = {MetricsTaskSet}
   

3. Verifikasi image Docker berada di repositori Artifact Registry Anda:

   gcloud artifacts docker images list ${REGION}-docker.pkg.dev/${PROJECT}/${AR_REPO} | \
       grep ${LOCUST_IMAGE_NAME}
   

   Outputnya mirip dengan hal berikut ini:

   Listing items under project PROJECT, location REGION, repository AR_REPO
   
   REGION-docker.pkg.dev/PROJECT/AR_REPO/locust-tasks  sha256:796d4be067eae7c82d41824791289045789182958913e57c0ef40e8d5ddcf283  2022-04-13T01:55:02  2022-04-13T01:55:02
   

Men-deploy aplikasi contoh

1. Membuat dan men-deploy sample-webapp sebagai App Engine:

   gcloud app create --region=${SAMPLE_APP_LOCATION}
   gcloud app deploy sample-webapp/app.yaml \
   --project=${PROJECT}
   

2. Saat diminta, ketik y untuk melanjutkan deployment.

   Outputnya mirip dengan hal berikut ini:

   File upload done.
   Updating service [default]...done.
   Setting traffic split for service [default]...done.
   Deployed service [default] to [https://PROJECT.appspot.com]
   

   Contoh aplikasi App Engine mengimplementasikan endpoint /login dan /metrics:

   @app.route('/login',  methods=['GET', 'POST'])
   def login():
       deviceid = request.values.get('deviceid')
       return '/login - device: {}\n'.format(deviceid)
   
   @app.route('/metrics',  methods=['GET', 'POST'])
   def metrics():
       deviceid = request.values.get('deviceid')
       timestamp = request.values.get('timestamp')
   
       return '/metrics - device: {}, timestamp: {}\n'.format(deviceid, timestamp)

Men-deploy Pod pekerja dan master Locust

1. Ganti nilai variabel lingkungan untuk target host, project, dan image parameters dalam file locust-master-controller.yaml dan locust-worker-controller.yaml, lalu buat Deployment master dan pekerja Locust:

   envsubst < kubernetes-config/locust-master-controller.yaml.tpl | kubectl apply -f -
   envsubst < kubernetes-config/locust-worker-controller.yaml.tpl | kubectl apply -f -
   envsubst < kubernetes-config/locust-master-service.yaml.tpl | kubectl apply -f -
   

2. Verifikasi Deployment Locust:

   kubectl get pods -o wide
   

   Outputnya akan terlihat seperti berikut:

   NAME                             READY   STATUS    RESTARTS   AGE   IP           NODE
   locust-master-87f8ffd56-pxmsk    1/1     Running   0          1m    10.32.2.6    gke-gke-load-test-default-pool-96a3f394
   locust-worker-58879b475c-279q9   1/1     Running   0          1m    10.32.1.5    gke-gke-load-test-default-pool-96a3f394
   locust-worker-58879b475c-9frbw   1/1     Running   0          1m    10.32.2.8    gke-gke-load-test-default-pool-96a3f394
   locust-worker-58879b475c-dppmz   1/1     Running   0          1m    10.32.2.7    gke-gke-load-test-default-pool-96a3f394
   locust-worker-58879b475c-g8tzf   1/1     Running   0          1m    10.32.0.11   gke-gke-load-test-default-pool-96a3f394
   locust-worker-58879b475c-qcscq   1/1     Running   0          1m    10.32.1.4    gke-gke-load-test-default-pool-96a3f394
   

3. Verifikasi Layanan:

   kubectl get services
   

   Outputnya akan terlihat seperti berikut:

   NAME                TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
   kubernetes          ClusterIP      10.87.240.1     <none>        443/TCP             12m
   locust-master       ClusterIP      10.87.245.22    <none>        5557/TCP,5558/TCP    1m
   locust-master-web   LoadBalancer   10.87.246.225   <pending>     8089:31454/TCP       1m
   

4. Jalankan watch loop saat alamat IP pribadi Load Balancer Jaringan passthrough internal (alamat IP eksternal GKE) disediakan untuk Layanan aplikasi web master Locust:

   kubectl get svc locust-master-web --watch
   

5. Tekan Ctrl+C untuk keluar dari watch loop setelah alamatEXTERNAL-IPdisediakan.

Menghubungkan ke front end web Locust

Gunakan antarmuka web master Locust untuk menyetujui muatan tugas pengujian terhadap sistem yang sedang diuji.

1. Dapatkan alamat IP load balancer internal dari layanan host web:

   export INTERNAL_LB_IP=$(kubectl get svc locust-master-web  \
                                  -o jsonpath="{.status.loadBalancer.ingress[0].ip}") && \
                                  echo $INTERNAL_LB_IP
   

2. Bergantung pada konfigurasi jaringan Anda, ada dua cara untuk terhubung ke aplikasi web Locust melalui alamat IP yang disediakan:

   • Pemilihan rute jaringan. Jika jaringan Anda dikonfigurasi untuk mengizinkan perutean dari workstation ke jaringan VPC project, Anda dapat langsung mengakses alamat IP Load Balancer Jaringan passthrough internal dari workstation Anda.

   • Proxy & tunnel SSH. Jika tidak ada rute jaringan antara workstation dan jaringan VPC, Anda dapat mengarahkan traffic ke alamat IP Load Balancer Jaringan passthrough internal dengan membuat instance Compute Engine menggunakan proxy nginx dan tunnel SSH antara workstation Anda dan instance.

Pemilihan rute jaringan

Jika ada rute untuk traffic jaringan antara workstation Anda dan jaringan VPC project Google Cloud, buka browser, lalu buka antarmuka web master Locust. Ganti [INTERNAL_LB_IP] di URL berikut dengan alamat IP yang Anda amati di langkah sebelumnya: http://[INTERNAL_LB_IP]:8089.

Proxy & tunnel SSH

1. Tetapkan variabel lingkungan dengan nama instance.

   export PROXY_VM=locust-nginx-proxy
   

2. Mulai instance dengan container Docker ngnix yang dikonfigurasi untuk mengirim proxy port aplikasi web Locust 8089 pada Load Balancer Jaringan passthrough internal:

   gcloud compute instances create-with-container ${PROXY_VM} \
      --zone ${ZONE} \
      --container-image gcr.io/cloud-marketplace/google/nginx1:latest \
      --container-mount-host-path=host-path=/tmp/server.conf,mount-path=/etc/nginx/conf.d/default.conf \
      --metadata=startup-script="#! /bin/bash
        cat <<EOF  > /tmp/server.conf
        server {
            listen 8089;
            location / {
                proxy_pass http://${INTERNAL_LB_IP}:8089;
            }
        }
   EOF"
   

3. Buka tunnel SSH dari Cloud Shell ke instance proxy:

   gcloud compute ssh --zone ${ZONE} ${PROXY_VM} \
                    -- -N -L 8089:localhost:8089
   

4. Klik ikon Pratinjau Web (), lalu pilih Ubah Port dari opsi yang tercantum.

5. Pada dialog Change Preview Port, masukkan 8089 di kolom Port Number, lalu pilih Change and Preview.

   Tab browser akan segera terbuka dengan antarmuka web Locust.

Menjalankan uji muat dasar pada aplikasi sampel Anda

1. Setelah membuka frontend Locust di browser, Anda akan melihat dialog yang dapat digunakan untuk memulai pengujian beban baru.

   

2. Tentukan total Jumlah pengguna (puncak konkurensi) sebagai 10 dan Kecepatan kemunculan (pengguna yang dimulai/detik) sebagai 5 pengguna per detik.

3. Klik Start swarming untuk memulai simulasi.

   Setelah permintaan mulai berdatangan, statistik akan mulai menggabungkan metrik simulasi, seperti jumlah permintaan dan permintaan per detik, seperti yang ditunjukkan pada gambar berikut:

   

4. Lihat layanan yang di-deploy dan metrik lainnya dari Google Cloud Console.

   

   Catatan: Setelah pengujian unit, dasbor App Engine mungkin memerlukan waktu beberapa menit untuk menampilkan metrik.

5. Setelah Anda mengamati perilaku aplikasi yang sedang diuji, klik Stop untuk menghentikan pengujian.

Meningkatkan skala jumlah pengguna (opsional)

Jika Anda ingin menguji peningkatan beban pada aplikasi, Anda dapat menambahkan pengguna yang disimulasikan. Sebelum dapat menambahkan pengguna yang disimulasikan, Anda harus memastikan bahwa tersedia resource yang cukup untuk mendukung peningkatan beban. Dengan Google Cloud, Anda dapat menambahkan Pod pekerja Locust ke Deployment tanpa men-deploy ulang Pod yang ada, selama Anda memiliki resource VM pokok untuk mendukung peningkatan jumlah Pod. Cluster GKE awal dimulai dengan 3 node dan dapat melakukan penskalaan otomatis hingga 10 node.

• Skalakan kumpulan Pod pekerja Locust menjadi 20.

  kubectl scale deployment/locust-worker --replicas=20
  

  Butuh waktu beberapa menit untuk men-deploy dan memulai Pod baru.

Jika melihat pesan error Pod Unschedulable, Anda harus menambahkan lebih banyak node ke cluster. Untuk mengetahui detailnya, lihat mengubah ukuran cluster GKE.

Setelah Pod dimulai, kembali ke antarmuka web master Locust, lalu mulai ulang pengujian beban.

Memperluas pola

Untuk memperluas pola ini, Anda dapat membuat tugas Locust baru atau bahkan beralih ke framework pengujian beban yang berbeda.

Anda dapat menyesuaikan metrik yang dikumpulkan. Misalnya, Anda mungkin ingin mengukur permintaan per detik, atau memantau latensi respons seiring meningkatnya beban, atau memeriksa tingkat kegagalan respons dan jenis error.

Sebagai informasi, lihat dokumentasi Cloud Monitoring.

Pembersihan

Setelah menyelesaikan tutorial, Anda dapat membersihkan resource yang dibuat sehingga Anda tidak akan ditagih di masa mendatang.

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

Untuk menghapus project:

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus cluster GKE

Jika Anda tidak ingin menghapus seluruh project, jalankan perintah berikut untuk menghapus cluster GKE:

   gcloud container clusters delete ${GKE_CLUSTER} --region ${REGION}
   

Langkah selanjutnya

• Membuat Aplikasi Web yang Skalabel dan Tangguh.
• Tinjau dokumentasi GKE secara lebih mendetail.
• Baca tutorial lainnya di GKE.
• Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.