లోకస్ట్తో API లోడ్ టెస్టింగ్
లోకస్ట్తో API లోడ్ టెస్టింగ్: పరిచయం
మీరు బహుశా ఇంతకు ముందు ఈ పరిస్థితిలో ఉండవచ్చు: మీరు ఏదైనా చేసే కోడ్ని వ్రాస్తారు, ఉదాహరణకు ఒక ముగింపు స్థానం. మీరు పోస్ట్మ్యాన్ లేదా నిద్రలేమిని ఉపయోగించి మీ ఎండ్పాయింట్ని పరీక్షిస్తారు మరియు ప్రతిదీ బాగానే పని చేస్తుంది. మీరు ఎండ్పాయింట్ను క్లయింట్-సైడ్ డెవలపర్కు పంపుతారు, ఆ తర్వాత అతను వినియోగిస్తాడు API మరియు అప్లికేషన్ను అమలు చేస్తుంది. అయితే, వినియోగదారులు యాప్ను ఉపయోగించినప్పుడు API విఫలమవుతుంది.
ఇది చాలా బాధించే పరిస్థితి కావచ్చు, వ్యాపారానికి ఖర్చుతో కూడుకున్నది కాదు. అందుకే సాఫ్ట్వేర్ డెవలపర్లు సాఫ్ట్వేర్ సిస్టమ్లు ఆశించిన విధంగా పనిచేస్తాయని నిర్ధారించడానికి వివిధ రకాల పరీక్షలను నిర్వహిస్తారు. APIలు భిన్నంగా లేవు. అమలు చేయడానికి ముందు, మీరు కనీసం పనితీరు పరీక్షలు మరియు భద్రతా పరీక్షలు చేయాలి.
పనితీరు పరీక్షలను ఫంక్షనాలిటీ టెస్ట్లు మరియు లోడ్ టెస్ట్లుగా వర్గీకరించవచ్చు. మీరు సాధారణంగా పోస్ట్మ్యాన్ లేదా నిద్రలేమి కోసం ఉపయోగించేవి ఫంక్షనాలిటీ పరీక్షలు. మీ API మీరు ఆశించిన విధంగా పనిచేస్తుందని వారు నిర్ధారిస్తారు. లోడ్ పరీక్షలు, మరోవైపు, వాస్తవ-ప్రపంచ వినియోగం మరియు పీక్ లోడ్తో మీ API ఎలా పని చేస్తుందనే దాని గురించి మరింత ఆందోళన చెందుతుంది మరియు దాని గురించి ఈ కథనం. లోడ్ పరీక్షలను మరింత వివరంగా చూద్దాం.
API లోడ్ టెస్టింగ్ అంటే ఏమిటి?
API లోడ్ టెస్టింగ్ అనేది డెవలపర్లు ఎండ్ పాయింట్లపై సాధారణ మరియు గరిష్ట లోడ్ను అనుకరించడానికి ఉపయోగించే ఒక రకమైన టెస్టింగ్. ఈ రకమైన పరీక్ష డెవలపర్లను అమలు చేయడానికి ముందు API యొక్క వాస్తవ-ప్రపంచ పనితీరును అంచనా వేయడానికి అనుమతిస్తుంది. ఇది సిస్టమ్ యొక్క గరిష్ట ఆపరేటింగ్ కెపాసిటీ, అడ్డంకులు ఏవైనా ఉంటే మరియు పనితీరు క్షీణతను గుర్తించడంలో వారికి సహాయపడుతుంది. API లోడ్ పరీక్షలు సాధారణంగా వర్చువల్ వినియోగదారులను సృష్టించడం ద్వారా మరియు API యొక్క కార్యాచరణను ఏకకాలంలో పరీక్షించడానికి వాటిని ఉపయోగించడం ద్వారా జరుగుతాయి.
API లోడ్ పరీక్షలు ప్రతిస్పందన సమయం, ఉమ్మడి వినియోగదారులు, నిర్గమాంశ రేట్లు, వనరుల వినియోగ స్థాయిలు, వైఫల్యాల మధ్య సగటు సమయం (MTBF), వైఫల్యానికి సగటు సమయం (MTTF) మొదలైన కొలమానాలను కొలుస్తాయి. API ఎంత బాగా పనిచేస్తుందో తెలుసుకోవడానికి ఈ కొలమానాలు అన్నీ ఉపయోగించబడతాయి.
లోడ్ టెస్టింగ్ రకాలు
అనేక రకాల లోడ్ టెస్టింగ్ ఉన్నాయి, ప్రతి దాని వినియోగ సందర్భాలు ఉన్నాయి. వాటిలో కొన్నింటిని పరిశీలిద్దాం.
లోడ్ టెస్టింగ్: ఇది లోడ్ పరీక్ష యొక్క ప్రాథమిక రూపం. సాధారణ లోడ్ మరియు ఊహించిన గరిష్ట లోడ్ కింద సిస్టమ్ (ఈ సందర్భంలో, API) పనితీరును అంచనా వేయడానికి ఇది ఉపయోగించబడుతుంది.
ఒత్తిడి పరీక్ష: ఇది చాలా భారీ లోడ్ కింద సిస్టమ్ పనితీరును అంచనా వేయడానికి ఉపయోగించబడుతుంది. ఈ పరీక్ష యొక్క లక్ష్యం వైఫల్యం తర్వాత సిస్టమ్ కోలుకుంటుంది మరియు అలా చేయడానికి ఎంత సమయం పడుతుంది అని చూడటం. సిస్టమ్ యొక్క సామర్థ్యాలను అధిగమించే వరకు లోడ్ సాధారణంగా నెమ్మదిగా పెరుగుతుంది.
స్పైక్ టెస్టింగ్: ఇది ఒత్తిడి పరీక్షకు కొద్దిగా సారూప్యంగా ఉంటుంది, భారీ లోడ్ అకస్మాత్తుగా వర్తించబడుతుంది తప్ప, నెమ్మదిగా ర్యాంపింగ్ చేయడానికి భిన్నంగా ఉంటుంది. మీ సగటు వినియోగదారులు లేదా సందర్శకుల సంఖ్య అకస్మాత్తుగా పెరిగినప్పుడు లేదా మీ సిస్టమ్పై DDOS దాడి జరిగినప్పుడు ఈ రకమైన పరీక్ష ఏమి జరుగుతుందో సూచిస్తుంది.
సోక్ టెస్టింగ్: ఈ పరీక్ష పైన పేర్కొన్న వాటికి భిన్నంగా ఉంటుంది. ఇది మీ సిస్టమ్ను సాధారణ లోడ్లో 80% (లేదా దాదాపు) కింద ఉంచుతుంది మరియు దానిని 12 నుండి 14 గంటల వరకు ఎక్కువ కాలం పాటు అమలు చేస్తుంది. ఈ రకమైన పరీక్ష కాలక్రమేణా సిస్టమ్ ఎంత విశ్వసనీయంగా ఉందో నిర్ణయిస్తుంది.
లోకస్ట్తో మీ APIలను పరీక్షించడాన్ని లోడ్ చేయండి
డెవలపర్లు తమ APIలను లోడ్ చేయడం కోసం వివిధ రకాల ఎంపికలకు యాక్సెస్ను కలిగి ఉన్నారు. కొన్ని సాధారణ లోడ్ పరీక్ష సాధనాలు గాట్లింగ్, JMeter మరియు లోకస్ట్. మేము ఈ వ్యాసంలో లోకస్ట్పై దృష్టి పెడతాము.
లోకస్ట్ అనేది పైథాన్-ఆధారిత ఓపెన్-సోర్స్ లోడ్ టెస్టింగ్ టూల్, Google, Microsoft మరియు Riot Games వంటి అగ్ర కంపెనీలు తమ APIలను పరీక్షించడానికి ఉపయోగిస్తాయి. ఈ కథనంలో, పరీక్ష APIని ఎలా లోడ్ చేయాలో మేము ప్రదర్శిస్తాము.
ఈ ట్యుటోరియల్ కోసం, నేను ఫ్లాస్క్తో ఒక సాధారణ APIని క్రియేట్ చేస్తాను. మీరు నాతో పాటు అనుసరించవచ్చు లేదా మీ APIని నోడ్తో లేదా మీకు సౌకర్యంగా ఉండే ఏదైనా ఫ్రేమ్వర్క్తో సృష్టించవచ్చు.
అవసరాలు
పైథాన్ 3
సెటప్ & ఇన్స్టాలేషన్
ముందుగా, మీరు మీ PCలో వర్చువల్ వాతావరణాన్ని సెటప్ చేయాలి, తద్వారా మీరు మీ గ్లోబల్ పైథాన్ వాతావరణాన్ని గందరగోళానికి గురిచేయకూడదు. అలా చేయడానికి, కింది ఆదేశాలను అమలు చేయండి. ఈ ఆదేశాలు Windows టెర్మినల్కు వర్తిస్తాయని గమనించండి.
$ mkdir ప్రాజెక్ట్
$ cd /d పాత్\టు\ ప్రాజెక్ట్
$ పైథాన్ -m venv venv
$ venv\Scripts\యాక్టివేట్
మొదట, మేము ఒక సృష్టించాము ప్రాజెక్ట్ డైరెక్టరీ. అప్పుడు మేము మా ప్రస్తుత డైరెక్టరీని మార్చాము ప్రాజెక్ట్. మేము ఆ డైరెక్టరీ లోపల పైథాన్ కోసం వర్చువల్ వాతావరణాన్ని సృష్టించాము మరియు సక్రియం చేసాము.
ఇప్పుడు, మేము ఇన్స్టాల్ చేయడానికి వెళ్తాము జాడీలో(మేము దానిని లోడ్ పరీక్ష చేయవలసిన ముగింపు పాయింట్లను సృష్టించడానికి ఉపయోగిస్తాము) మరియు లోకస్ట్ కూడా.
ఫ్లాస్క్ని ఇన్స్టాల్ చేయడానికి, రన్ చేయండి. మీరు ఇందులో ఉన్నారని నిర్ధారించుకోండి ప్రాజెక్ట్ ఇక్కడ మీరు వర్చువల్ వాతావరణాన్ని సృష్టించారు.
$ పిప్ ఇన్స్టాల్ ఫ్లాస్క్
లోకస్ట్ని ఇన్స్టాల్ చేయడానికి, రన్ చేయండి
$ పిప్ మిడుత ఇన్స్టాల్
అది పూర్తయిన తర్వాత, కింది ఆదేశాలను టైప్ చేయండి. మీరు మీలో ఉన్నారని నిర్ధారించుకోండి ప్రాజెక్ట్ మీరు దీన్ని చేసినప్పుడు డైరెక్టరీ.
$ కాపీ nul __init__.py
$ mkdir యాప్
$ nul యాప్\app.py కాపీ చేయండి
$ nul యాప్ని కాపీ చేయండి\__init__.py
ఈ కమాండ్లు కొన్ని ఫైల్లను సృష్టిస్తాయి, వీటిని మేము ఫ్లాస్క్ని ఉపయోగించి మా ఎండ్ పాయింట్లను సృష్టించడానికి ఉపయోగిస్తాము. మీరు మీ ఫైల్ ఎక్స్ప్లోరర్ని ఉపయోగించి కూడా ఈ ఫైల్లను సృష్టించవచ్చు. అయితే అందులో సరదా ఏముంది? మీరు దాన్ని పూర్తి చేసిన తర్వాత, దిగువ కోడ్ని కాపీ చేయండి app.py
ఫ్లాస్క్ దిగుమతి నుండి ఫ్లాస్క్, jsonify, అభ్యర్థన
యాప్ = ఫ్లాస్క్(__పేరు__)
కార్_మోడల్స్ = [
{ 'బ్రాండ్': 'టెస్లా', 'మోడల్': 'మోడల్ S' }
]
విమానం_మోడల్స్ = [
{ 'బ్రాండ్': 'బోయింగ్', 'మోడల్': '747' }
]
@app.route('/కార్లు')
డెఫ్ గెట్_కార్స్():
రిటర్న్ jsonify(car_models)
@app.route('/విమానాలు')
డెఫ్ గెట్_ప్లేన్స్():
రిటర్న్ jsonify(plane_models)
__పేరు__ == '__ప్రధాన__':
app.run(డీబగ్=ట్రూ)
పై కోడ్ ఒక పద్ధతిని కలిగి ఉంది పొందండి_కార్లు కార్ బ్రాండ్లు మరియు వాటి మోడళ్ల జాబితాను పొందడానికి ఉపయోగిస్తారు, మరియు పొందండి_విమానాలు విమానం బ్రాండ్లు మరియు వాటి నమూనాల జాబితాను పొందడానికి ఉపయోగిస్తారు. మేము ఈ ఎండ్పాయింట్ని లోడ్ చేయాలంటే, మనం app.pyని అమలు చేయాలి. అలా చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి.
$ పైథాన్ మార్గం\to\app.py
మీరు దాన్ని అమలు చేసిన తర్వాత, మీరు ఇలాంటివి చూడాలి:
మీరు టెర్మినల్ నుండి URLని కాపీ చేసి టైప్ చేస్తే కార్లు or విమానాలు / తర్వాత, మీరు అక్కడ డేటాను చూడగలరు. అయినప్పటికీ, బ్రౌజర్తో కాకుండా మిడుతతో ముగింపు బిందువును పరీక్షించడమే మా లక్ష్యం. కాబట్టి అలా చేద్దాం. మీ యొక్క రూట్లో కింది ఆదేశాన్ని అమలు చేయండి ప్రాజెక్ట్ డైరెక్టరీ.
$ nul locust_test.py కాపీ
ఇది మీ రూట్లో 'locust_test.py' ఫైల్ను సృష్టిస్తుంది ప్రాజెక్ట్ డైరెక్టరీ. మీరు దాన్ని పూర్తి చేసిన తర్వాత, ఫైల్ని తెరిచి, దిగువ కోడ్లో అతికించండి. మేము దానిని త్వరలో వివరిస్తాము.
దిగుమతి సమయం
మిడుత దిగుమతి నుండి HttpUser, టాస్క్, మధ్య
తరగతి వినియోగదారు ప్రవర్తన(HttpUser):
వేచి ఉండే సమయం = మధ్య (5, 10)
@పని
డెఫ్ గెట్_కార్స్(సెల్ఫ్):
self.client.get('/cars')
@పని
డెఫ్ గెట్_ప్లేన్స్(సెల్ఫ్):
self.client.get('/planes')
APIని లోడ్ చేయడానికి లోకస్ట్ని ఉపయోగించేందుకు ఇది ఒక ప్రాథమిక ఉదాహరణ. మొదట, మేము ఒక తరగతిని సృష్టిస్తాము వాడుకరి ప్రవర్తన, ఇది ఏదైనా సముచితమైన పేరును ఇవ్వవచ్చు కానీ పొడిగించాలి HttpUser. HttpUser మేము పేర్కొన్న టాస్క్లను అమలు చేయడానికి బహుళ వర్చువల్ వినియోగదారులను ఇన్స్టాంటియేట్ చేయడంలో శ్రద్ధ వహించే తరగతి వాడుకరి ప్రవర్తన తరగతి.
ఒక పద్ధతిని అలంకరించడం ద్వారా ఒక పని నిర్దేశించబడుతుంది @పని డెకరేటర్. అనే ఫంక్షన్ కూడా ఉంది మధ్య () తదుపరి పనిని అమలు చేయడానికి ముందు వేచి ఉండాల్సిన సెకన్ల పరిధిని పేర్కొనడానికి ఇది మమ్మల్ని అనుమతిస్తుంది. మేము మా కోడ్లో దాని కోసం 5 నుండి 10 సెకన్ల పరిధిని కేటాయించినట్లు మీరు చూడవచ్చు.
కోడ్ని అమలు చేయడానికి, మీరు ఇప్పటికీ మీ వర్చువల్ వాతావరణంలో ఉన్నారని నిర్ధారించుకోండి. మీరు సృష్టించినది APIని అందిస్తున్న సర్వర్ ఉపయోగిస్తుంటే, కొత్త టెర్మినల్ను తెరిచి, మీ డైరెక్టరీని మీకి మార్చండి ప్రాజెక్ట్ డైరెక్టరీ, మరియు మీరు సృష్టించిన వర్చువల్ వాతావరణాన్ని సక్రియం చేయండి. మీరు పైన ఉన్న వర్చువల్ పర్యావరణాన్ని సక్రియం చేయడానికి ఆదేశాన్ని కనుగొనవచ్చు. ఇప్పుడు, మీ టెర్మినల్లో దిగువ ఆదేశాన్ని నమోదు చేయండి.
$ లోకస్ట్ -f locust_test.py
మీరు ఇలాంటి ఏదో చూడాలి:
డిఫాల్ట్గా, మిడుత వెబ్ ఇంటర్ఫేస్ http://localhost/8089 వద్ద ఉంది. మీరు వెబ్సైట్ను సందర్శిస్తే, మీరు ఇలాంటి ఇంటర్ఫేస్ని చూడాలి:
ఇంటర్ఫేస్ నుండి, మేము వినియోగదారుల సంఖ్య, స్పాన్ రేట్ (సెకనుకు సృష్టించబడిన వినియోగదారులు) మరియు హోస్ట్ని పేర్కొనవచ్చు. సర్వర్ నడుస్తున్న టెర్మినల్ను తనిఖీ చేయడం ద్వారా మీరు మీ హోస్ట్ చిరునామాను పొందవచ్చు. మా విషయంలో, ఇది పోర్ట్ 5000 వద్ద ఉంది. మీరు క్లిక్ చేసినప్పుడు గుంపులు కొట్టడం ప్రారంభించండి, మీరు దిగువ ఇంటర్ఫేస్తో అందించబడతారు.
ఇది మీకు విఫలమైన అభ్యర్థనల సంఖ్య, అభ్యర్థన కోసం సగటు సమయం, అభ్యర్థన కోసం కనీస సమయం, సెకనుకు అభ్యర్థనలు మొదలైన అనేక ఉపయోగకరమైన కొలమానాలను చూపుతుంది. మీరు చూసిన దానితో మీరు సంతృప్తి చెందిన తర్వాత, మీరు స్టాప్ బటన్పై క్లిక్ చేయవచ్చు.
పాటు గణాంకాలు టాబ్, ఒక ఉంది <span style="font-family: Mandali; ">నిర్వాహక విభాగ నిర్మాణ పటాలు (Charts)</span> మరిన్ని చూపే ట్యాబ్ సమాచారం దిగువ చిత్రం వలె గ్రాఫ్ రూపంలో.
అక్కడ ఒక సెకను గ్రాఫ్కు మొత్తం అభ్యర్థనలు, ప్రతిస్పందన సమయ గ్రాఫ్, మరియు వినియోగదారుల సంఖ్య గ్రాఫ్, అన్నీ కాలానికి వ్యతిరేకంగా పన్నాగం పన్నాయి. గ్రాఫ్లను ఉపయోగించి, నిర్ణీత ప్రతిస్పందన సమయానికి ఎంత మంది వినియోగదారులు ఆమోదయోగ్యంగా ఉన్నారో మీరు నిర్ణయించవచ్చు లేదా వినియోగదారుల సంఖ్య పెరుగుతున్నప్పటికీ స్థిరమైన ప్రతిస్పందన సమయం కోసం మీ చార్ట్లను గమనించవచ్చు మరియు అలాంటి ఇతర అంతర్దృష్టులు. మీరు వీటిని పంచుకోవాలనుకుంటే గణాంకాలు మరొకరితో, మీరు నుండి నివేదికను డౌన్లోడ్ చేసుకోవచ్చు డేటాను డౌన్లోడ్ చేయండి టాబ్.
నిర్ధారించారు...
మీ APIని లోడ్ చేయడం అనేది మీ అభివృద్ధి ప్రక్రియలో కీలకమైన కార్యకలాపం, కాబట్టి ఇది మీ డిజైన్ సైకిల్లో చేర్చబడిందని నిర్ధారించుకోండి. మార్గం ద్వారా, మీరు వినియోగదారుల సంఖ్య మరియు స్పాన్ రేట్ కోసం విలువలను మార్చడం ద్వారా ఇతర లోడ్ పరీక్ష రకాలను కూడా నిర్వహించవచ్చు.
మీరు స్పైక్ పరీక్ష చేయాలనుకుంటే, వినియోగదారుల సంఖ్య కోసం పెద్ద విలువను (2000 అని చెప్పండి) పేర్కొనండి, ఆపై మీ స్పాన్ రేట్కి (ఉదాహరణకు 500) సమానమైన పెద్ద విలువను పేర్కొనండి. దీనర్థం 4 సెకన్లలో, మీరు మొత్తం 2000 మంది వినియోగదారులను సృష్టించి, మీ ఎండ్ పాయింట్లను యాక్సెస్ చేయగలుగుతారు. ఒత్తిడి పరీక్ష సారూప్యంగా ఉంటుంది, కానీ స్పాన్ రేట్ కోసం చాలా తక్కువ విలువతో ఉంటుంది. మీరు చేయగలిగినదంతా తెలుసుకోవడానికి, లోకస్ట్ని తనిఖీ చేయండి డాక్యుమెంటేషన్.