API-belastningstesting med Locust
API-belastningstesting med Locust: Intro
Du har sikkert vært i denne situasjonen før: du skriver kode som gjør noe, for eksempel et endepunkt. Du tester endepunktet ditt med Postman eller Insomnia, og alt fungerer bra. Du sender endepunktet videre til utvikleren på klientsiden, som deretter bruker API og distribuerer applikasjonen. Men så mislykkes APIen når brukerne bruker appen.
Dette kan være en super irriterende situasjon å være i, for ikke å snakke om kostbart for en bedrift. Det er grunnen til at programvareutviklere utfører en rekke tester på programvaresystemer for å sikre at de fungerer som forventet. APIer er ikke annerledes. Før distribusjon bør du i det minste gjøre ytelsestester og sikkerhetstester.
Ytelsestester kan grupperes i funksjonalitetstester og belastningstester. Funksjonalitetstester er det du vanligvis bruker Postman eller Insomnia til. De sikrer at API-en din fungerer som du forventer. Belastningstester er derimot mer opptatt av hvordan API-en din presterer med bruk i den virkelige verden og toppbelastning, og det er det denne artikkelen handler om. La oss se på belastningstester mer detaljert.
Hva er API-belastningstesting?
API-belastningstesting er en type testing utviklere bruker for å simulere normal og toppbelastning på endepunkter. Denne typen testing lar utviklere evaluere den virkelige ytelsen til en API før den distribueres. Det hjelper dem med å identifisere den maksimale driftskapasiteten til et system, eventuelle flaskehalser og ytelsesforringelse. API-belastningstester gjøres vanligvis ved å opprette virtuelle brukere og deretter bruke dem til å teste ut API-funksjonaliteten samtidig.
API-belastningstester måler beregninger som responstid, samtidige brukere, gjennomstrømningshastigheter, ressursutnyttelsesnivåer, gjennomsnittlig tid mellom feil (MTBF), gjennomsnittlig tid til feil (MTTF) og så videre. Alle disse beregningene kan brukes til å bestemme hvor godt API-en gjør det.
Typer belastningstesting
Det finnes flere typer lasttesting, hver med sine brukstilfeller. La oss ta en titt på noen av dem.
Lasttesting: Dette er den grunnleggende formen for en lasttest. Den brukes til å evaluere ytelsen til et system (i dette tilfellet en API) under normal belastning og forventet toppbelastning.
Stresstesting: Dette brukes til å evaluere ytelsen til et system under svært tung belastning. Målet med denne testen er å se om et system gjenoppretter seg etter feil, og hvor lang tid det tar å gjøre det. Lasten økes vanligvis sakte til den overstiger systemets evner.
Piggtesting: Dette ligner litt på stresstesting, bortsett fra at tung belastning påføres plutselig, i motsetning til å sakte øke den. Denne typen tester representerer hva som skjer når det er en plutselig økning i gjennomsnittlig antall brukere eller besøkende, eller når det er et DDOS-angrep på systemet ditt.
Bløtleggingstesting: Denne testen er ulik de andre ovenfor. Det setter systemet ditt under 80 % (eller omtrent) av normal belastning og lar det kjøre i en lengre periode, for eksempel 12 til 14 timer. Denne typen tester bestemmer hvor pålitelig et system er over tid.
Last testing av API-ene dine med Locust
Utviklere har tilgang til en rekke alternativer for belastningsteste API-ene deres. Noen vanlige verktøy for lasttesting er Gatling, JMeter og Locust. Vi vil fokusere på Locust i denne artikkelen.
Locust er et python-basert åpen kildekode-lasttestverktøy som brukes av toppselskaper som Google, Microsoft og Riot Games for å teste API-ene deres. I denne artikkelen vil vi demonstrere hvordan du laster tester et API.
For denne opplæringen skal jeg lage en enkel API med Flask. Du kan følge med meg eller bare lage din API med Node, eller hvilket rammeverk du er komfortabel med.
Krav
Python 3
Oppsett og installasjon
Først må du sette opp et virtuelt miljø på PC-en din slik at du ikke ødelegger det globale Python-miljøet ditt. For å gjøre det, kjør følgende kommandoer. Merk at disse kommandoene gjelder for en Windows-terminal.
$ mkdir-prosjektet
$ cd /d bane\til\prosjekt
$ python -m venv venv
$ venv\Scripts\activate
Først opprettet vi en prosjekt katalog. Så endret vi vår nåværende katalog til prosjekt. Vi opprettet og aktiverte deretter et virtuelt miljø for Python i den katalogen.
Nå går vi videre til installasjonen Kolbe(vi vil bruke den til å lage endepunktene som skal lastetestes) og Locust selv.
For å installere Flask, kjør. Sørg for at du er i prosjekt hvor du opprettet et virtuelt miljø.
$ pip installasjonskolbe
For å installere Locust, kjør
$ pip installere gresshoppe
Når det er gjort, skriv inn følgende kommandoer. Sørg for at du er i din prosjekt katalog når du gjør dette.
$ kopi nul __init__.py
$ mkdir app
$ copy nul app\app.py
$ copy nul app\__init__.py
Denne kommandoen lager noen filer som vi vil bruke til å lage endepunktene våre ved å bruke Flask. Du kan også lage disse filene ved å bruke filutforskeren forresten. Men hva er det morsomme med det? Når du har gjort det, kopierer du koden nedenfor til app.py
fra flask import Flask, jsonify, request
app = kolbe (__ navn__)
bilmodeller = [
{ 'brand': 'Tesla', 'model': 'Model S' }
]
flymodeller = [
{ 'brand': 'Boeing', 'model': '747' }
]
@app.route('/biler')
def get_cars():
returner jsonify(bilmodeller)
@app.route('/planes')
def get_planes():
return jsonify(plane_modeller)
hvis __name__ == '__main__':
app.run(debug=True)
Koden ovenfor inneholder en metode få_biler brukes til å få en liste over bilmerker og deres modeller, og get_planes brukes til å få en liste over flymerker og deres modeller. For at vi skal laste teste dette endepunktet, må vi kjøre app.py. For å gjøre det, kjør kommandoen nedenfor.
$ python-bane\to\app.py
Når du har kjørt det, bør du se noe slikt:
Hvis du kopierer URL-en fra terminalen og skriver biler or fly etter /, bør du kunne se dataene der. Målet vårt er imidlertid å teste endepunktet med gresshoppe, ikke med nettleseren. Så la oss gjøre det. Kjør følgende kommando i roten av din prosjekt katalogen.
$ kopi nul locust_test.py
Dette oppretter en 'locust_test.py'-fil i roten til din prosjekt katalog. Når du har gjort det, åpner du filen og limer inn koden nedenfor. Vi vil forklare det snart.
importtid
fra gresshoppe import HttpUser, oppgave, mellom
klasse Brukeratferd(HttpBruker):
ventetid = mellom(5, 10)
@oppgave
def get_cars(selv):
self.client.get('/cars')
@oppgave
def get_planes(selv):
self.client.get('/planes')
Dette er et grunnleggende eksempel på bruk av Locust for å lastetest en API. Først lager vi en klasse Brukeratferd, som kan gis et hvilket som helst passende navn, men som må utvides HttpBruker. HttpBruker er klassen som tar seg av å instansiere flere virtuelle brukere til å utføre oppgavene vi spesifiserer i Brukeratferd klasse.
En oppgave spesifiseres ved å dekorere en metode med @oppgave dekoratør. Vi har også en funksjon som heter mellom() som lar oss spesifisere en rekke sekunder å vente på før vi utfører neste oppgave. Du kan se at vi har tildelt et område på 5 til 10 sekunder for det i koden vår.
For å kjøre koden, sørg for at du fortsatt er i ditt virtuelle miljø. Hvis den du opprettet blir brukt av serveren som betjener API, åpne en ny terminal, endre katalogen din til din prosjekt katalogen, og aktiver det virtuelle miljøet du opprettet. Du finner kommandoen for å aktivere et virtuelt miljø ovenfor. Skriv inn kommandoen nedenfor i terminalen din.
$ locust -f locust_test.py
Du bør se noe slikt:
Som standard er locusts nettgrensesnitt plassert på http://localhost/8089. Hvis du besøker nettstedet, bør du se et grensesnitt som dette:
Fra grensesnittet kan vi spesifisere antall brukere, spawn rate (brukere opprettet per sekund) og vert. Du kan få adressen til verten din ved å sjekke terminalen der serveren kjører. I vårt tilfelle er det på port 5000. Når du klikker videre Begynn å sverme, du vil bli presentert med grensesnittet nedenfor.
Dette viser deg ulike nyttige beregninger som antall mislykkede forespørsler, gjennomsnittlig tid for en forespørsel, minimumstiden for en forespørsel, forespørsler per sekund, og så videre. Når du er fornøyd med det du ser, kan du klikke på stoppknappen.
I tillegg til Statistikk fanen, det er en Topplisten fane som viser mer informasjon i form av en graf, som bildet nedenfor.
Det er en grafen for totalt antall forespørsler per sekund, responstid graf, og antall brukere graf, alt plottet mot tiden. Ved å bruke grafene kan du bestemme hvor mange brukere som er akseptable for en fast responstid, eller du kan observere diagrammene dine for en konstant responstid til tross for et økende antall brukere, og annen slik innsikt. Hvis du vil dele disse stats med noen andre kan du laste ned en rapport fra Last ned data fanen.
Å konkludere...
Belastningstesting av API-en din er en avgjørende aktivitet i utviklingsprosessen din, så sørg for at den er integrert i designsyklusen din. Du kan forresten også utføre andre belastningstesttyper ved å variere verdiene for antall brukere og spawn rate.
Hvis du vil gjøre en spiketest, spesifiser en stor verdi (f.eks. 2000) for antall brukere, og deretter en like stor verdi for spawnhastigheten din (for eksempel 500). Dette betyr at på 4 sekunder vil du ha alle 2000 brukere opprettet og få tilgang til endepunktene dine. En stresstest vil være lik, men med en mye lavere verdi for spawn rate. For å finne ut alt du kan gjøre, sjekk ut Locust dokumentasjon.
