API Load Testing Gamit ang Locust
Pagsubok sa Pag-load ng API Gamit ang Locust: Intro
Malamang na naranasan mo na ang sitwasyong ito dati: sumulat ka ng code na gumagawa ng isang bagay, isang endpoint halimbawa. Sinusubukan mo ang iyong endpoint gamit ang Postman o Insomnia, at lahat ay gumagana nang maayos. Ipapasa mo ang endpoint sa client-side developer, na pagkatapos ay kumonsumo ng API at i-deploy ang application. Ngunit pagkatapos, nabigo ang API kapag ginamit ng mga user ang app.
Ito ay maaaring maging isang sobrang nakakainis na sitwasyon, hindi banggitin ang magastos para sa isang negosyo. Ito ang dahilan kung bakit nagsasagawa ang mga developer ng software ng iba't ibang pagsubok sa mga software system upang matiyak na gumaganap sila gaya ng inaasahan. Ang mga API ay hindi naiiba. Bago i-deploy, dapat kang gumawa ng hindi bababa sa mga pagsubok sa pagganap at mga pagsubok sa seguridad.
Ang mga pagsubok sa pagganap ay maaaring igrupo sa mga pagsubok sa paggana at mga pagsubok sa pagkarga. Ang mga pagsusuri sa functionality ay ang karaniwan mong ginagamit na Postman o Insomnia. Tinitiyak nila na gumagana ang iyong API gaya ng iyong inaasahan. Ang mga pagsubok sa pag-load, sa kabilang banda, ay mas nababahala sa kung paano gumaganap ang iyong API sa paggamit ng totoong mundo at peak load, at iyon ang tungkol sa artikulong ito. Tingnan natin ang mga pagsubok sa pagkarga nang mas detalyado.
Ano ang Pagsubok sa Pag-load ng API?
Ang API load testing ay isang uri ng pagsubok na ginagamit ng mga developer para gayahin ang normal at peak load sa mga endpoint. Ang ganitong uri ng pagsubok ay nagbibigay-daan sa mga developer na suriin ang totoong pagganap ng isang API bago ito i-deploy. Nakakatulong ito sa kanila na matukoy ang maximum na kapasidad ng pagpapatakbo ng isang system, mga bottleneck kung mayroon, at pagkasira ng performance. Ang mga pagsubok sa pag-load ng API ay karaniwang ginagawa sa pamamagitan ng paglikha ng mga virtual na user at pagkatapos ay ginagamit ang mga ito upang subukan ang functionality ng API nang sabay-sabay.
Sinusukat ng mga pagsubok sa pag-load ng API ang mga sukatan tulad ng oras ng pagtugon, kasabay na mga user, mga rate ng throughput, mga antas ng paggamit ng mapagkukunan, Mean Time Between Failure(MTBF), Mean Time To Failure(MTTF), at iba pa. Magagamit ang lahat ng sukatang ito upang matukoy kung gaano kahusay ang takbo ng API.
Mga Uri ng Pagsubok sa Pag-load
Mayroong ilang mga uri ng pagsubok sa pagkarga, bawat isa ay may mga kaso ng paggamit nito. Tingnan natin ang ilan sa kanila.
Pagsubok sa Pag-load: Ito ang pangunahing anyo ng pagsubok sa pagkarga. Ginagamit ito upang suriin ang pagganap ng isang system (sa kasong ito, isang API) sa ilalim ng normal na pag-load at inaasahang peak load.
Pagsusuri ng Stress: Ito ay ginagamit upang suriin ang pagganap ng isang sistema sa ilalim ng napakabigat na pagkarga. Ang layunin ng pagsubok na ito ay upang makita kung ang isang system ay bumabawi pagkatapos ng pagkabigo, at kung gaano katagal ang kinakailangan upang gawin ito. Ang load ay karaniwang dahan-dahang pinapataas hanggang sa lumampas ito sa mga kakayahan ng system.
Pagsubok sa Spike: Ito ay medyo katulad ng stress testing, maliban sa mabigat na pagkarga ay inilapat nang biglaan, kumpara sa dahan-dahang pag-rampa nito. Kinakatawan ng ganitong uri ng pagsubok kung ano ang nangyayari kapag may biglaang pagtaas sa iyong average na bilang ng mga user o bisita, o kapag may DDOS attack sa iyong system.
Pagsubok sa Pagbabad: Ang pagsusulit na ito ay hindi katulad ng iba sa itaas. Inilalagay nito ang iyong system sa ilalim ng 80%(o tungkol doon) ng normal na pagkarga at hinahayaan itong tumakbo nang mahabang panahon, sabihin nating 12 hanggang 14 na oras. Tinutukoy ng ganitong uri ng pagsubok kung gaano maaasahan ang isang system sa paglipas ng panahon.
I-load ang Pagsubok sa Iyong Mga API Gamit ang Locust
May access ang mga developer sa iba't ibang opsyon para sa pagsubok ng pag-load sa kanilang mga API. Ang ilang karaniwang mga tool sa pagsubok sa pagkarga ay ang Gatling, JMeter, at Locust. Pagtutuunan natin ng pansin ang Locust sa artikulong ito.
Ang Locust ay isang python-based na open-source load testing tool na ginagamit ng mga nangungunang kumpanya gaya ng Google, Microsoft, at Riot Games upang subukan ang kanilang mga API. Sa artikulong ito, ipapakita namin kung paano mag-load ng pagsubok ng API.
Para sa tutorial na ito, gagawa ako ng simpleng API na may Flask. Maaari kang sumunod sa akin o lumikha lamang ng iyong API gamit ang Node, o anumang balangkas na komportable ka.
Kinakailangan
Python 3
Pag-setup at Pag-install
Una, kailangan mong mag-set up ng isang virtual na kapaligiran sa iyong PC upang hindi mo magulo ang iyong pandaigdigang kapaligiran sa Python. Upang gawin iyon, patakbuhin ang mga sumusunod na command. Tandaan na ang mga command na ito ay nalalapat sa isang Windows terminal.
$ mkdir proyekto
$ cd /d path\to\project
$ python -m venv venv
$ venv\Scripts\activate
Una, lumikha kami ng isang proyekto direktoryo. Pagkatapos ay binago namin ang aming kasalukuyang direktoryo sa proyekto. Lumikha at nag-activate kami ng virtual na kapaligiran para sa Python sa loob ng direktoryo na iyon.
Ngayon, magpapatuloy tayo sa pag-install Prasko(gagamitin namin ito upang lumikha ng mga endpoint na susuriin sa pag-load) at balang mismo.
Upang i-install ang Flask, tumakbo. Tiyaking ikaw ay nasa proyekto kung saan lumikha ka ng isang virtual na kapaligiran.
$ pip install flask
Upang i-install ang Locust, tumakbo
$ pip install balang
Kapag tapos na iyon, i-type ang mga sumusunod na command. Siguraduhin na ikaw ay nasa iyong proyekto direktoryo kapag ginawa mo ito.
$ copy nul __init__.py
$ mkdir app
$ copy nul app\app.py
$ copy nul app\__init__.py
Ang mga utos na ito ay lumilikha ng ilang mga file na gagamitin namin upang gawin ang aming mga endpoint gamit ang Flask. Maaari mo ring gawin ang mga file na ito gamit ang iyong file explorer sa pamamagitan ng paraan. Pero ano ang saya dun? Kapag nagawa mo na iyon, kopyahin ang code sa ibaba sa app.py
mula sa flask import Flask, jsonify, request
app = Prasko(__pangalan__)
car_models = [
{ 'brand': 'Tesla', 'model': 'Model S' }
]
plane_models = [
{ 'brand': 'Boeing', 'model': '747' }
]
@app.route('/cars')
def get_cars():
ibalik ang jsonify(car_models)
@app.route('/planes')
def get_planes():
ibalik ang jsonify(plane_models)
kung __name__ == '__ main__':
app.run(debug=True)
Ang code sa itaas ay naglalaman ng isang paraan get_cars ginamit upang makakuha ng isang listahan ng mga tatak ng kotse at ang kanilang mga modelo, at makakuha ng_eroplano ginamit upang makakuha ng isang listahan ng mga tatak ng eroplano at ang kanilang mga modelo. Para mai-load namin ang pagsubok sa endpoint na ito, kailangan naming patakbuhin ang app.py. Upang gawin iyon, patakbuhin ang utos sa ibaba.
$ python path\to\app.py
Sa sandaling patakbuhin mo iyon, dapat mong makita ang isang bagay tulad nito:
Kung kopyahin mo ang URL mula sa terminal at i-type kotse or eroplano pagkatapos ng /, dapat mong makita ang data doon. Gayunpaman, ang aming layunin ay subukan ang endpoint sa balang, hindi sa browser. Kaya gawin natin iyan. Patakbuhin ang sumusunod na utos sa ugat ng iyong proyekto direktoryo.
$ copy nul locust_test.py
Lumilikha ito ng 'locust_test.py' na file sa ugat ng iyong proyekto direktoryo. Kapag nagawa mo na iyon, buksan ang file at i-paste ang code sa ibaba. Ipapaliwanag namin ito sa lalong madaling panahon.
oras ng pag-import
mula sa pag-import ng balang HttpUser, gawain, sa pagitan
class UserBehaviour(HttpUser):
wait_time = sa pagitan ng(5, 10)
@gawain
def get_cars(self):
self.client.get('/cars')
@gawain
def get_planes(self):
self.client.get('/planes')
Ito ay isang pangunahing halimbawa ng paggamit ng Locust upang i-load ang pagsubok ng isang API. Una, gumawa kami ng isang klase UserBehaviour, na maaaring bigyan ng anumang naaangkop na pangalan ngunit dapat pahabain HttpUser. HttpUser ay ang klase na nangangasiwa sa pag-instantiate ng maraming virtual na user upang isagawa ang mga gawaing tinukoy namin sa UserBehaviour klase.
Ang isang gawain ay tinukoy sa pamamagitan ng pagdekorasyon ng isang paraan gamit ang @gawain dekorador. Mayroon din kaming function na tinatawag sa pagitan ng() na nagbibigay-daan sa amin na tumukoy ng hanay ng mga segundong hihintayin bago isagawa ang susunod na gawain. Makikita mo na nagtalaga kami ng hanay na 5 hanggang 10 segundo para doon sa aming code.
Upang patakbuhin ang code, tiyaking nasa iyong virtual na kapaligiran ka pa rin. Kung ang ginawa mo ay ginagamit ng server na naghahatid ng API, magbukas ng bagong terminal, palitan ang iyong direktoryo sa iyong proyekto direktoryo, at i-activate ang virtual na kapaligiran na iyong nilikha. Maaari mong mahanap ang command para sa pag-activate ng isang virtual na kapaligiran sa itaas. Ngayon, ipasok ang command sa ibaba sa iyong terminal.
$ locust -f locust_test.py
Dapat mong makita ang isang bagay tulad nito:
Bilang default, ang web interface ng balang ay matatagpuan sa http://localhost/8089. Kung bibisita ka sa website, dapat kang makakita ng interface na tulad nito:
Mula sa interface, maaari naming tukuyin ang bilang ng mga user, rate ng spawn(mga user na nilikha bawat segundo), at Host. Makukuha mo ang address ng iyong host sa pamamagitan ng pagsuri sa terminal kung saan tumatakbo ang server. Sa aming kaso, ito ay nasa port 5000. Kapag nag-click ka sa Simulan ang pagkukumpulan, ipapakita sa iyo ang interface sa ibaba.
Ipinapakita nito sa iyo ang iba't ibang mga kapaki-pakinabang na sukatan tulad ng bilang ng mga nabigong kahilingan, average na oras para sa isang kahilingan, ang minimum na oras para sa isang kahilingan, mga kahilingan sa bawat segundo, at iba pa. Kapag nasiyahan ka na sa iyong nakikita, maaari mong i-click ang stop button.
Bukod sa Istatistika tab, mayroong isang chart tab na nagpapakita ng higit pa impormasyon sa anyo ng isang graph, tulad ng larawan sa ibaba.
May ay isang kabuuang mga kahilingan sa bawat segundong graph, graph ng oras ng pagtugon, at graph ng bilang ng mga gumagamit, lahat ay nagplano laban sa oras. Gamit ang mga graph, matutukoy mo kung gaano karaming mga user ang katanggap-tanggap para sa isang nakapirming oras ng pagtugon, o maaari mong obserbahan ang iyong mga chart para sa patuloy na oras ng pagtugon sa kabila ng dumaraming bilang ng mga user, at iba pang mga insight na tulad niyan. Kung gusto mong ibahagi ang mga ito stats sa ibang tao, maaari kang mag-download ng ulat mula sa I-download ang Data Tab.
Sa pangkalahatan...
Ang pag-load ng pagsubok sa iyong API ay isang mahalagang aktibidad sa iyong proseso ng pag-develop, kaya siguraduhing kasama ito sa iyong ikot ng disenyo. Sa pamamagitan ng paraan, maaari ka ring magsagawa ng iba pang mga uri ng pagsubok sa pag-load sa pamamagitan ng pag-iiba-iba ng mga halaga para sa bilang ng mga user at rate ng spawn.
Kung gusto mong gumawa ng spike test, tumukoy ng malaking halaga (sabihin 2000) para sa bilang ng mga user, at pagkatapos ay isang pantay na malaking halaga para sa iyong spawn rate(500 halimbawa). Nangangahulugan ito na sa loob ng 4 na segundo, gagawin mo ang lahat ng 2000 user at maa-access ang iyong mga endpoint. Magiging katulad ang isang stress test, ngunit may mas mababang halaga para sa spawn rate. Upang malaman ang lahat ng maaari mong gawin, tingnan ang Locust dokumentasyon.
