Halaman ini diterjemahkan oleh Cloud Translation API.

Pengujian beban terdistribusi menggunakan Google Kubernetes Engine

Last reviewed 2024-08-13 UTC

Dokumen 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. Dokumen ini menguji beban aplikasi web yang di-deploy ke App Engine yang mengekspos endpoint bergaya REST untuk merespons 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 akan 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

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the App Engine, Artifact Registry, Cloud Build, Compute Engine, Resource Manager, Google Kubernetes Engine, and Identity and Access Management APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the App Engine, Artifact Registry, Cloud Build, Compute Engine, Resource Manager, Google Kubernetes Engine, and Identity and Access Management APIs.

Enable the APIs

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.

Grant roles to your user account. Run the following command once for each of the following IAM roles: 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:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

Contoh workload

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

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 dokumen ini, menggunakan image dasar Python dan menyertakan skrip untuk memulai layanan Locust dan menjalankan 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:

Men-deploy pengujian beban utama, yang disebut sebagai master oleh Locust.
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.

Pod utama menayangkan antarmuka web yang digunakan untuk mengoperasikan dan memantau pengujian beban. Pod pekerja menghasilkan traffic permintaan REST untuk aplikasi yang sedang diuji.

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 Network Load Balancer 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.

Setelah men-deploy master Locust, Anda dapat membuka antarmuka web menggunakan alamat IP internal 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.

Master Locust berada di bagian atas hierarki dengan beberapa pekerja di bawahnya.

Melakukan inisialisasi variabel umum

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

Buka Cloud Shell:

Buka Cloud Shell

Anda menjalankan semua perintah terminal dalam dokumen ini dari Cloud Shell.
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 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
```

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

Tetapkan zona default sehingga Anda tidak perlu menentukan nilai ini dalam perintah berikutnya:
```
gcloud config set compute/zone ${ZONE}
```

Membuat cluster GKE

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}. --role=roles/artifactregistry.reader
gcloud projects add-iam-policy-binding  ${PROJECT} --member=serviceAccount:dist-lt-svc-acc@${PROJECT}. --role=roles/container.nodeServiceAccount

Buat cluster GKE:

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

Hubungkan ke cluster GKE

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

Menyiapkan lingkungan

Clone repositori contoh dari GitHub:

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

Ubah direktori kerja Anda ke repositori yang di-clone:
```
cd distributed-load-testing-using-kubernetes
```

Membangun image container

Buat repositori Artifact Registry:

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

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}

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 yang 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

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}

Saat diminta, ketik y untuk melanjutkan deployment.

Outputnya mirip dengan yang 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

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 -

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

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

Jalankan watch loop saat alamat IP internal Load Balancer Jaringan passthrough internal (alamat IP eksternal GKE) disediakan untuk Layanan aplikasi web master Locust:
```
kubectl get svc locust-master-web --watch
```
Tekan Ctrl+C untuk keluar dari watch loop setelah alamatIP EKSTERNALdisediakan.

Menghubungkan ke frontend web Locust

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

Catat 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

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. Untuk membuka antarmuka Locust, buka URL berikut:

http://INTERNAL_LB_IP:8089

Ganti INTERNAL_LB_IP dengan URL dan alamat IP yang Anda catat di langkah sebelumnya.

Proxy & tunnel SSH

Tetapkan variabel lingkungan dengan nama instance.
```
export PROXY_VM=locust-nginx-proxy
```

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"

Buka tunnel SSH dari Cloud Shell ke instance proxy:

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

Klik ikon Pratinjau Web (), lalu pilih Ubah Port dari opsi yang tercantum.
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

Setelah membuka frontend Locust di browser, Anda akan melihat dialog yang dapat digunakan untuk memulai pengujian beban baru.
Tentukan total Jumlah pengguna (puncak konkurensi) sebagai 10 dan Kecepatan kemunculan (pengguna yang dimulai/detik) sebagai 5 pengguna per detik.
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:
Lihat layanan yang di-deploy dan metrik lainnya dari Google Cloud Console.

Catatan: Setelah pengujian swarm, dasbor App Engine mungkin memerlukan waktu beberapa menit untuk menampilkan metrik.
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 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.

Untuk mengetahui informasinya, lihat dokumentasi Cloud Monitoring.

Pembersihan

Agar tidak dikenai biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam dokumen ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

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 beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the 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 berikutnya

Membuat Aplikasi Web yang Skalabel dan Tangguh.
Tinjau dokumentasi GKE secara lebih mendetail.
Coba tutorial di GKE.
Untuk mengetahui lebih banyak tentang arsitektur referensi, diagram, dan praktik terbaik lainnya, jelajahi Pusat Arsitektur Cloud.