Pengujian beban terdistribusi menggunakan Google Kubernetes Engine

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.

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.

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.

   

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.