Prova de càrrega de l'API amb Locust
Proves de càrrega de l'API amb Locust: introducció
Probablement ja heu estat en aquesta situació abans: escriviu codi que fa alguna cosa, un punt final per exemple. Proveu el vostre punt final amb Postman o Insomnia i tot funciona bé. Passeu el punt final al desenvolupador del costat del client, que després consumeix el API i desplega l'aplicació. Però aleshores, l'API falla quan els usuaris utilitzen l'aplicació.
Aquesta pot ser una situació molt molesta, per no parlar de costosa per a un negoci. És per això que els desenvolupadors de programari realitzen diverses proves als sistemes de programari per assegurar-se que funcionen com s'esperava. Les API no són diferents. Abans del desplegament, hauríeu de fer almenys proves de rendiment i proves de seguretat.
Les proves de rendiment es poden agrupar en proves de funcionalitat i proves de càrrega. Les proves de funcionalitat són per a les quals normalment feu servir Postman o Insomni. Asseguren que la vostra API funcioni com espereu. Les proves de càrrega, d'altra banda, es preocupen més pel rendiment de la vostra API amb l'ús real i la càrrega màxima, i d'això tracta aquest article. Vegem les proves de càrrega amb més detall.
Què és la prova de càrrega de l'API?
Les proves de càrrega de l'API són un tipus de proves que utilitzen els desenvolupadors per simular la càrrega normal i màxima als punts finals. Aquest tipus de proves permet als desenvolupadors avaluar el rendiment real d'una API abans de desplegar-la. Els ajuda a identificar la capacitat operativa màxima d'un sistema, els colls d'ampolla si n'hi ha i la degradació del rendiment. Les proves de càrrega de l'API es fan generalment creant usuaris virtuals i després utilitzant-los per provar la funcionalitat de l'API simultàniament.
Les proves de càrrega de l'API mesuren mètriques com el temps de resposta, els usuaris concurrents, les taxes de rendiment, els nivells d'utilització de recursos, el temps mitjà entre errors (MTBF), el temps mitjà fins a la fallada (MTTF), etc. Totes aquestes mètriques es poden utilitzar per determinar el rendiment de l'API.
Tipus de proves de càrrega
Hi ha diversos tipus de proves de càrrega, cadascuna amb els seus casos d'ús. Fem una ullada a alguns d'ells.
Prova de càrrega: Aquesta és la forma bàsica d'una prova de càrrega. S'utilitza per avaluar el rendiment d'un sistema (en aquest cas, una API) amb càrrega normal i càrrega màxima esperada.
Proves d'estrès: S'utilitza per avaluar el rendiment d'un sistema sota una càrrega molt pesada. L'objectiu d'aquesta prova és veure si un sistema es recupera després d'una fallada i quant de temps triga a fer-ho. La càrrega sol augmentar lentament fins que supera les capacitats del sistema.
Prova de pics: Això és una mica similar a les proves d'esforç, excepte que s'aplica una càrrega pesada de sobte, en lloc d'augmentar-la lentament. Aquest tipus de prova representa el que passa quan hi ha un augment sobtat del vostre nombre mitjà d'usuaris o visitants, o quan hi ha un atac DDOS al vostre sistema.
Prova de remull: Aquesta prova és diferent a les altres anteriors. Posa el vostre sistema per sota del 80% (o més o menys) de la càrrega normal i el deixa en funcionament durant un període llarg, per exemple, de 12 a 14 hores. Aquest tipus de prova determina la fiabilitat d'un sistema al llarg del temps.
Carregueu les proves de les vostres API amb Locust
Els desenvolupadors tenen accés a diverses opcions per provar la càrrega de les seves API. Algunes eines de prova de càrrega habituals són Gatling, JMeter i Locust. Ens centrarem en Locust en aquest article.
Locust és una eina de prova de càrrega de codi obert basada en Python utilitzada per empreses principals com Google, Microsoft i Riot Games per provar les seves API. En aquest article, demostrarem com carregar la prova d'una API.
Per a aquest tutorial, crearé una API senzilla amb Flask. Podeu seguir-me amb mi o simplement crear la vostra API amb Node, o qualsevol marc amb el qual us sentiu còmode.
Requisits
3 Python
Configuració i instal·lació
En primer lloc, heu de configurar un entorn virtual al vostre ordinador perquè no malmetre l'entorn global de Python. Per fer-ho, executeu les ordres següents. Tingueu en compte que aquestes ordres s'apliquen a un terminal de Windows.
$ projecte mkdir
$ cd /d camí\al\projecte
$ python -m venv venv
$ venv\Scripts\activate
Primer, vam crear un projecte directori. Després vam canviar el nostre directori actual a projecte. Després vam crear i activar un entorn virtual per a Python dins d'aquest directori.
Ara, passarem a la instal·lació flascó(l'utilitzarem per crear els punts finals per ser provats de càrrega) i llagosta si mateix.
Per instal·lar Flask, executeu. Assegureu-vos que esteu a la projecte on heu creat un entorn virtual.
$ pip instal·lar matràs
Per instal·lar Locust, executeu
$ pip instal·lar llagosta
Un cop fet això, escriviu les ordres següents. Assegureu-vos que esteu al vostre projecte directori quan feu això.
$ còpia nul __init__.py
$ aplicació mkdir
$ copy nul app\app.py
$ copiar l'aplicació nul\__init__.py
Aquesta ordre crea alguns fitxers que farem servir per crear els nostres punts finals amb Flask. Per cert, també podeu crear aquests fitxers mitjançant l'explorador de fitxers. Però quina és la diversió en això? Un cop ho hàgiu fet, copieu el codi següent a app.py
des de la importació de flask Flask, jsonify, sol·licitud
aplicació = Flask (__nom__)
models_cotxes = [
{ 'marca': 'Tesla', 'model': 'Model S' }
]
models_avió = [
{ 'marca': 'Boeing', 'model': '747' }
]
@app.route('/cotxes')
def get_cars():
retornar jsonify(models_cotxes)
@app.route('/planes')
def get_planes():
retornar jsonify(plane_models)
if __name__ == '__main__':
app.run(debug=True)
El codi anterior conté un mètode obtenir_cotxes s'utilitza per obtenir una llista de marques de cotxes i els seus models, i get_planes s'utilitza per obtenir una llista de marques d'avions i els seus models. Perquè puguem provar aquest punt final, hem d'executar app.py. Per fer-ho, executeu l'ordre següent.
$ camí de python\a\app.py
Un cop executat això, hauríeu de veure alguna cosa com això:
Si copieu l'URL des del terminal i escriviu cotxes or plànols després del /, hauríeu de poder veure les dades allà. Tanmateix, el nostre objectiu és provar el punt final amb llagosta, no amb el navegador. Així que fem això. Executeu l'ordre següent a l'arrel del vostre projecte directori.
$ copiar nul locust_test.py
Això crea un fitxer "locust_test.py" a l'arrel del vostre projecte directori. Un cop ho hàgiu fet, obriu el fitxer i enganxeu el codi següent. Ho explicarem en breu.
temps d'importació
des de la importació de llagosta HttpUser, tasca, entre
classe UserBehaviour(HttpUser):
temps_espera = entre (5, 10)
@tasca
def get_cars(self):
self.client.get('/cars')
@tasca
def get_planes(self):
self.client.get('/planes')
Aquest és un exemple bàsic de l'ús de Locust per provar una API de càrrega. Primer, creem una classe Comportament de l'usuari, que es pot donar amb qualsevol nom adequat però que s'ha d'estendre HttpUser. HttpUser és la classe que s'encarrega d'instanciar múltiples usuaris virtuals per dur a terme les tasques que especifiquem al Comportament de l'usuari classe.
Una tasca s'especifica decorant un mètode amb el @tasca decorador. També tenim una funció anomenada entre () que ens permet especificar un interval de segons per esperar abans d'executar la següent tasca. Podeu veure que hem assignat un interval de 5 a 10 segons al nostre codi.
Per executar el codi, assegureu-vos que encara sou al vostre entorn virtual. Si el que heu creat l'està utilitzant el servidor que serveix l'API, obriu un nou terminal, canvieu el vostre directori al vostre projecte directori i activeu l'entorn virtual que heu creat. Podeu trobar l'ordre per activar un entorn virtual més amunt. Ara, introduïu l'ordre següent al vostre terminal.
$ llagosta -f llagosta_test.py
Hauríeu de veure alguna cosa així:
De manera predeterminada, la interfície web de locust es troba a http://localhost/8089. Si visiteu el lloc web, hauríeu de veure una interfície com aquesta:
Des de la interfície, podem especificar el nombre d'usuaris, la taxa de generació (usuaris creats per segon) i l'amfitrió. Podeu obtenir l'adreça del vostre host si comproveu el terminal on s'executa el servidor. En el nostre cas, es troba al port 5000. Quan feu clic a Comença a pulular, se us presentarà la interfície a continuació.
Això us mostra diverses mètriques útils, com ara el nombre de sol·licituds fallides, el temps mitjà d'una sol·licitud, el temps mínim per a una sol·licitud, les sol·licituds per segon, etc. Quan estigueu satisfet amb el que veieu, podeu fer clic al botó d'aturar.
A més de la Estadística pestanya, hi ha una Gràfics pestanya que mostra més informació en forma de gràfic, com la imatge següent.
Hi ha un gràfic de sol·licituds totals per segon, gràfic del temps de resposta, i gràfic del nombre d'usuaris, tot tramat contra el temps. Amb els gràfics, podeu determinar quants usuaris són acceptables per a un temps de resposta fix, o podeu observar els vostres gràfics amb un temps de resposta constant malgrat un nombre creixent d'usuaris, i altres coneixements com aquest. Si les voleu compartir Estadístiques amb una altra persona, podeu descarregar un informe des del Descarregar dades Tab.
Concloure...
La prova de càrrega de la vostra API és una activitat crucial en el vostre procés de desenvolupament, així que assegureu-vos que s'incorpori al vostre cicle de disseny. Per cert, també podeu realitzar altres tipus de proves de càrrega variant els valors del nombre d'usuaris i la taxa de generació.
Si voleu fer una prova d'espiga, especifiqueu un valor gran (per exemple 2000) per al nombre d'usuaris, i després un valor igual de gran per a la vostra taxa de generació (500 per exemple). Això vol dir que, en 4 segons, tindríeu creats els 2000 usuaris i accedireu als vostres punts finals. Una prova d'estrès serà similar, però amb un valor molt inferior per a la taxa de generació. Per saber tot el que pots fer, fes una ullada a Locust documentació.
