വെട്ടുക്കിളി ഉപയോഗിച്ചുള്ള API ലോഡ് ടെസ്റ്റിംഗ്

വെട്ടുക്കിളി ഉപയോഗിച്ചുള്ള API ലോഡ് ടെസ്റ്റിംഗ്

വെട്ടുക്കിളി ഉപയോഗിച്ചുള്ള API ലോഡ് ടെസ്റ്റിംഗ്: ആമുഖം

നിങ്ങൾ മുമ്പ് ഈ അവസ്ഥയിൽ ആയിരിക്കാം: നിങ്ങൾ എന്തെങ്കിലും ചെയ്യുന്ന കോഡ് എഴുതുന്നു, ഉദാഹരണത്തിന് ഒരു എൻഡ് പോയിന്റ്. പോസ്റ്റ്മാൻ അല്ലെങ്കിൽ ഇൻസോമ്നിയ ഉപയോഗിച്ച് നിങ്ങളുടെ എൻഡ് പോയിന്റ് പരിശോധിക്കുന്നു, എല്ലാം നന്നായി പ്രവർത്തിക്കുന്നു. നിങ്ങൾ അവസാന പോയിന്റ് ക്ലയന്റ് സൈഡ് ഡെവലപ്പർക്ക് കൈമാറുന്നു, തുടർന്ന് അത് ഉപഭോഗം ചെയ്യുന്നു എപിഐ ആപ്ലിക്കേഷൻ വിന്യസിക്കുകയും ചെയ്യുന്നു. എന്നാൽ, ഉപയോക്താക്കൾ ആപ്പ് ഉപയോഗിക്കുമ്പോൾ API പരാജയപ്പെടുന്നു.

ഇത് വളരെ അലോസരപ്പെടുത്തുന്ന ഒരു സാഹചര്യമായിരിക്കും, ഒരു ബിസിനസ്സിന് ചെലവേറിയതായി പറയേണ്ടതില്ല. അതുകൊണ്ടാണ് സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്പർമാർ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നത് ഉറപ്പാക്കാൻ സോഫ്റ്റ്‌വെയർ സിസ്റ്റങ്ങളിൽ പലതരം പരിശോധനകൾ നടത്തുന്നത്. API-കൾ വ്യത്യസ്തമല്ല. വിന്യാസത്തിന് മുമ്പ്, നിങ്ങൾ കുറഞ്ഞത് പ്രകടന പരിശോധനകളും സുരക്ഷാ പരിശോധനകളും നടത്തണം.

പ്രകടന പരിശോധനകളെ പ്രവർത്തനക്ഷമത പരിശോധനകൾ, ലോഡ് ടെസ്റ്റുകൾ എന്നിങ്ങനെ തരംതിരിക്കാം. നിങ്ങൾ സാധാരണയായി പോസ്റ്റ്മാൻ അല്ലെങ്കിൽ ഇൻസോമ്നിയ ഉപയോഗിക്കുന്നത് പ്രവർത്തനക്ഷമത പരിശോധനകളാണ്. നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതുപോലെ നിങ്ങളുടെ API പ്രവർത്തിക്കുന്നുവെന്ന് അവർ ഉറപ്പാക്കുന്നു. മറുവശത്ത്, യഥാർത്ഥ ലോക ഉപയോഗത്തിലും പീക്ക് ലോഡിലും നിങ്ങളുടെ API എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെ കുറിച്ച് ലോഡ് ടെസ്റ്റുകൾ കൂടുതൽ ശ്രദ്ധാലുക്കളാണ്, അതിനെക്കുറിച്ചാണ് ഈ ലേഖനം. ലോഡ് ടെസ്റ്റുകൾ കൂടുതൽ വിശദമായി നോക്കാം.

എന്താണ് API ലോഡ് ടെസ്റ്റിംഗ്?

എ‌പി‌ഐ ലോഡ് ടെസ്റ്റിംഗ് ഡെവലപ്പർമാർ എൻ‌ഡ്‌പോയിന്റുകളിൽ സാധാരണവും പീക്ക് ലോഡും അനുകരിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു തരം ടെസ്റ്റിംഗ് ആണ്. ഒരു API വിന്യസിക്കുന്നതിന് മുമ്പ് അതിന്റെ യഥാർത്ഥ-ലോക പ്രകടനം വിലയിരുത്താൻ ഇത്തരത്തിലുള്ള പരിശോധന ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു. ഒരു സിസ്റ്റത്തിന്റെ പരമാവധി പ്രവർത്തന ശേഷി, തടസ്സങ്ങൾ ഉണ്ടെങ്കിൽ, പ്രകടന നിലവാരത്തകർച്ച എന്നിവ തിരിച്ചറിയാൻ ഇത് അവരെ സഹായിക്കുന്നു. എപിഐ ലോഡ് ടെസ്റ്റുകൾ സാധാരണയായി വെർച്വൽ ഉപയോക്താക്കളെ സൃഷ്ടിച്ച്, തുടർന്ന് എപിഐയുടെ പ്രവർത്തനക്ഷമത പരിശോധിക്കുന്നതിന് അവരെ ഉപയോഗിച്ചാണ് സാധാരണയായി ചെയ്യുന്നത്. 

API ലോഡ് ടെസ്റ്റുകൾ പ്രതികരണ സമയം, ഒരേസമയം ഉപയോഗിക്കുന്ന ഉപയോക്താക്കൾ, ത്രൂപുട്ട് നിരക്കുകൾ, വിഭവ വിനിയോഗ നിലകൾ, പരാജയത്തിന് ഇടയിലുള്ള ശരാശരി സമയം (MTBF), പരാജയപ്പെടാനുള്ള ശരാശരി സമയം (MTTF) എന്നിങ്ങനെയുള്ള അളവുകൾ അളക്കുന്നു. API എത്ര നന്നായി പ്രവർത്തിക്കുന്നുവെന്ന് നിർണ്ണയിക്കാൻ ഈ അളവുകളെല്ലാം ഉപയോഗിക്കാനാകും.

ലോഡ് പരിശോധനയുടെ തരങ്ങൾ

നിരവധി തരം ലോഡ് ടെസ്റ്റിംഗ് ഉണ്ട്, ഓരോന്നിനും അതിന്റെ ഉപയോഗ കേസുകൾ ഉണ്ട്. അവയിൽ ചിലത് നോക്കാം.

ലോഡ് ടെസ്റ്റിംഗ്: ഇത് ഒരു ലോഡ് ടെസ്റ്റിന്റെ അടിസ്ഥാന രൂപമാണ്. സാധാരണ ലോഡിലും പ്രതീക്ഷിക്കുന്ന പീക്ക് ലോഡിലും ഒരു സിസ്റ്റത്തിന്റെ (ഈ സാഹചര്യത്തിൽ, ഒരു API) പ്രകടനം വിലയിരുത്താൻ ഇത് ഉപയോഗിക്കുന്നു.

സമ്മർദ്ദ പരിശോധന: വളരെ കനത്ത ലോഡിന് കീഴിലുള്ള ഒരു സിസ്റ്റത്തിന്റെ പ്രകടനം വിലയിരുത്താൻ ഇത് ഉപയോഗിക്കുന്നു. ഈ പരിശോധനയുടെ ലക്ഷ്യം പരാജയത്തിന് ശേഷം ഒരു സിസ്റ്റം വീണ്ടെടുക്കുന്നുണ്ടോ എന്നും അത് ചെയ്യാൻ എത്ര സമയമെടുക്കുമെന്നും കാണുക എന്നതാണ്. സിസ്റ്റത്തിന്റെ കഴിവുകൾ കവിയുന്നത് വരെ ലോഡ് സാധാരണയായി സാവധാനത്തിൽ വർദ്ധിപ്പിക്കും.

സ്പൈക്ക് ടെസ്റ്റിംഗ്: ഇത് സ്ട്രെസ് ടെസ്റ്റിംഗിനോട് അൽപ്പം സാമ്യമുള്ളതാണ്, സാവധാനത്തിൽ റാംപിംഗ് ചെയ്യുന്നതിന് വിപരീതമായി കനത്ത ഭാരം പെട്ടെന്ന് പ്രയോഗിക്കപ്പെടുമെന്നതൊഴിച്ചാൽ. നിങ്ങളുടെ ശരാശരി ഉപയോക്താക്കളുടെയോ സന്ദർശകരുടെയോ എണ്ണത്തിൽ പെട്ടെന്നുള്ള വർദ്ധനവ് ഉണ്ടാകുമ്പോഴോ നിങ്ങളുടെ സിസ്റ്റത്തിൽ ഒരു DDOS ആക്രമണം ഉണ്ടാകുമ്പോഴോ എന്താണ് സംഭവിക്കുന്നതെന്ന് ഇത്തരത്തിലുള്ള പരിശോധന പ്രതിനിധീകരിക്കുന്നു.

സോക്ക് ടെസ്റ്റിംഗ്: ഈ പരിശോധന മുകളിൽ പറഞ്ഞതിൽ നിന്ന് വ്യത്യസ്തമാണ്. ഇത് നിങ്ങളുടെ സിസ്റ്റത്തെ സാധാരണ ലോഡിന്റെ 80% (അല്ലെങ്കിൽ ഏകദേശം) താഴെയാക്കുകയും 12 മുതൽ 14 മണിക്കൂർ വരെ ദീർഘനേരം പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. ഒരു സിസ്റ്റം കാലക്രമേണ എത്രത്തോളം വിശ്വസനീയമാണെന്ന് ഇത്തരത്തിലുള്ള പരിശോധന നിർണ്ണയിക്കുന്നു.

വെട്ടുക്കിളി ഉപയോഗിച്ച് നിങ്ങളുടെ API-കൾ പരിശോധിക്കുന്നത് ലോഡ് ചെയ്യുക

ഡെവലപ്പർമാർക്ക് അവരുടെ API-കൾ ലോഡ് ടെസ്റ്റ് ചെയ്യുന്നതിനുള്ള വിവിധ ഓപ്ഷനുകളിലേക്ക് ആക്‌സസ് ഉണ്ട്. Gatling, JMeter, Locust എന്നിവയാണ് ചില സാധാരണ ലോഡ് ടെസ്റ്റിംഗ് ടൂളുകൾ. ഈ ലേഖനത്തിൽ ഞങ്ങൾ വെട്ടുക്കിളിയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

ഗൂഗിൾ, മൈക്രോസോഫ്റ്റ്, റയറ്റ് ഗെയിമുകൾ എന്നിവ പോലുള്ള മുൻനിര കമ്പനികൾ അവരുടെ എപിഐകൾ പരിശോധിക്കാൻ ഉപയോഗിക്കുന്ന പൈത്തൺ അടിസ്ഥാനമാക്കിയുള്ള ഓപ്പൺ സോഴ്‌സ് ലോഡ് ടെസ്റ്റിംഗ് ടൂളാണ് വെട്ടുക്കിളി. ഈ ലേഖനത്തിൽ, ഒരു API എങ്ങനെ ലോഡുചെയ്യാമെന്ന് ഞങ്ങൾ കാണിക്കും. 

ഈ ട്യൂട്ടോറിയലിനായി, ഞാൻ ഫ്ലാസ്ക് ഉപയോഗിച്ച് ഒരു ലളിതമായ API സൃഷ്ടിക്കും. നിങ്ങൾക്ക് എന്നോടൊപ്പം പിന്തുടരാം അല്ലെങ്കിൽ നോഡ് ഉപയോഗിച്ച് നിങ്ങളുടെ API സൃഷ്‌ടിക്കാം, അല്ലെങ്കിൽ നിങ്ങൾക്ക് സൗകര്യപ്രദമായ ഏത് ചട്ടക്കൂടും.

ആവശ്യകതകൾ

പൈത്തൺ 3

സജ്ജീകരണവും ഇൻസ്റ്റാളേഷനും

ആദ്യം, നിങ്ങളുടെ പിസിയിൽ ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സജ്ജീകരിക്കേണ്ടതുണ്ട്, അതുവഴി നിങ്ങളുടെ ഗ്ലോബൽ പൈത്തൺ പരിതസ്ഥിതിയെ കുഴപ്പത്തിലാക്കരുത്. അത് ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക. ഈ കമാൻഡുകൾ ഒരു വിൻഡോസ് ടെർമിനലിന് ബാധകമാണെന്ന കാര്യം ശ്രദ്ധിക്കുക.

$ mkdir പദ്ധതി

$ cd /d പാത്ത്\ ടു\\ പദ്ധതി

$ പൈത്തൺ -എം വെൻവ് വെൻവ്

$ venv\scripts\activate

 

ആദ്യം, ഞങ്ങൾ ഒരു സൃഷ്ടിച്ചു പദ്ധതി ഡയറക്ടറി. തുടർന്ന് ഞങ്ങളുടെ നിലവിലെ ഡയറക്‌ടറി ഇതിലേക്ക് മാറ്റി പദ്ധതി. ആ ഡയറക്‌ടറിക്കുള്ളിൽ പൈത്തണിനായി ഞങ്ങൾ ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സൃഷ്‌ടിക്കുകയും സജീവമാക്കുകയും ചെയ്‌തു. 

ഇപ്പോൾ, ഞങ്ങൾ ഇൻസ്റ്റാളേഷനിലേക്ക് പോകും ഫ്ലാസ്ക്(ലോഡ് ടെസ്റ്റ് ചെയ്യേണ്ട അവസാന പോയിന്റുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഇത് ഉപയോഗിക്കും) കൂടാതെ വെട്ടുക്കിളി സ്വയം. 

 

ഫ്ലാസ്ക് ഇൻസ്റ്റാൾ ചെയ്യാൻ, റൺ ചെയ്യുക. നിങ്ങൾ ഉള്ളിലാണെന്ന് ഉറപ്പാക്കുക പദ്ധതി അവിടെ നിങ്ങൾ ഒരു വെർച്വൽ പരിസ്ഥിതി സൃഷ്ടിച്ചു.

$ പിപ്പ് ഇൻസ്റ്റാൾ ഫ്ലാസ്ക്

 

Locust ഇൻസ്റ്റാൾ ചെയ്യാൻ, റൺ ചെയ്യുക

$ പിപ്പ് വെട്ടുക്കിളി ഇൻസ്റ്റാൾ ചെയ്യുക

 

അത് ചെയ്തുകഴിഞ്ഞാൽ, ഇനിപ്പറയുന്ന കമാൻഡുകൾ ടൈപ്പ് ചെയ്യുക. നിങ്ങൾ നിങ്ങളുടേതാണെന്ന് ഉറപ്പാക്കുക പദ്ധതി നിങ്ങൾ ഇത് ചെയ്യുമ്പോൾ ഡയറക്ടറി.

$ nul __init__.py പകർത്തുക

$ mkdir ആപ്പ്

$ nul app\app.py പകർത്തുക

$ nul ആപ്പ് പകർത്തുക\__init__.py

 

ഈ കമാൻഡുകൾ ഫ്ലാസ്ക് ഉപയോഗിച്ച് ഞങ്ങളുടെ എൻഡ് പോയിന്റുകൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന ചില ഫയലുകൾ സൃഷ്ടിക്കുന്നു. നിങ്ങളുടെ ഫയൽ എക്സ്പ്ലോറർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ ഫയലുകൾ സൃഷ്ടിക്കാനും കഴിയും. എന്നാൽ അതിൽ എന്താണ് രസം? നിങ്ങൾ അത് ചെയ്തുകഴിഞ്ഞാൽ, ചുവടെയുള്ള കോഡ് ഇതിലേക്ക് പകർത്തുക app.py

ഫ്ലാസ്ക് ഇറക്കുമതിയിൽ നിന്ന് ഫ്ലാസ്ക്, jsonify, അഭ്യർത്ഥന

ആപ്പ് = ഫ്ലാസ്ക്(__പേര്__)

കാർ_മോഡലുകൾ = [

  { 'ബ്രാൻഡ്': 'ടെസ്‌ല', 'മോഡൽ': 'മോഡൽ എസ്' }

]

 

plane_models = [

  { 'ബ്രാൻഡ്': 'ബോയിംഗ്', 'മോഡൽ': '747' }

]

 

@app.route('/കാറുകൾ')

def get_cars():

  റിട്ടേൺ jsonify(car_models)

@app.route('/planes')

def get_planes():

  റിട്ടേൺ jsonify(plane_models)

__പേര്__ == '__പ്രധാന__' ആണെങ്കിൽ:

    app.run(ഡീബഗ്=ട്രൂ)  

 

മുകളിലെ കോഡിൽ ഒരു രീതി അടങ്ങിയിരിക്കുന്നു കാറുകൾ നേടുക കാർ ബ്രാൻഡുകളുടെയും അവയുടെ മോഡലുകളുടെയും ഒരു ലിസ്റ്റ് ലഭിക്കാൻ ഉപയോഗിക്കുന്നു, കൂടാതെ വിമാനങ്ങൾ വിമാന ബ്രാൻഡുകളുടെയും അവയുടെ മോഡലുകളുടെയും ഒരു ലിസ്റ്റ് ലഭിക്കാൻ ഉപയോഗിക്കുന്നു. ഈ എൻഡ്‌പോയിന്റ് ടെസ്റ്റ് ലോഡ് ചെയ്യുന്നതിന്, ഞങ്ങൾ app.py റൺ ചെയ്യേണ്ടതുണ്ട്. അത് ചെയ്യുന്നതിന് താഴെയുള്ള കമാൻഡ് പ്രവർത്തിപ്പിക്കുക.

$ python path\to\app.py

നിങ്ങൾ അത് പ്രവർത്തിപ്പിച്ചുകഴിഞ്ഞാൽ, ഇതുപോലുള്ള ഒന്ന് നിങ്ങൾ കാണും:

API ലോഡ് ടെസ്റ്റിംഗ് 1

നിങ്ങൾ ടെർമിനലിൽ നിന്ന് URL പകർത്തി ടൈപ്പ് ചെയ്യുകയാണെങ്കിൽ കാറുകൾ or പദ്ധതികൾ / എന്നതിന് ശേഷം, നിങ്ങൾക്ക് അവിടെയുള്ള ഡാറ്റ കാണാൻ കഴിയും. എന്നിരുന്നാലും, ബ്രൗസർ ഉപയോഗിച്ചല്ല, വെട്ടുക്കിളി ഉപയോഗിച്ച് എൻഡ്‌പോയിന്റ് പരീക്ഷിക്കുക എന്നതാണ് ഞങ്ങളുടെ ലക്ഷ്യം. അതുകൊണ്ട് നമുക്ക് അത് ചെയ്യാം. നിങ്ങളുടെ റൂട്ടിൽ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക പദ്ധതി ഡയറക്ടറി.

 

$ nul locust_test.py പകർത്തുക

 

ഇത് നിങ്ങളുടെ റൂട്ടിൽ ഒരു 'locust_test.py' ഫയൽ സൃഷ്ടിക്കുന്നു പദ്ധതി ഡയറക്ടറി. നിങ്ങൾ അത് ചെയ്തുകഴിഞ്ഞാൽ, ഫയൽ തുറന്ന് താഴെയുള്ള കോഡിൽ ഒട്ടിക്കുക. ഞങ്ങൾ അത് ഉടൻ വിശദീകരിക്കും.

 

ഇറക്കുമതി സമയം

വെട്ടുക്കിളി ഇറക്കുമതിയിൽ നിന്ന് HttpUser, ടാസ്ക്, ഇടയിൽ

 

ക്ലാസ് യൂസർ ബിഹേവിയർ(HttpUser):

    കാത്തിരിക്കുക_സമയം = ഇടയിൽ (5, 10)

 

    @ടാസ്ക്

    def get_cars(self):

        self.client.get('/cars')

    

    @ടാസ്ക്

    def get_planes(self):

        self.client.get('/planes')

 

ഒരു API ടെസ്റ്റ് ലോഡ് ചെയ്യാൻ വെട്ടുക്കിളി ഉപയോഗിക്കുന്നതിന്റെ അടിസ്ഥാന ഉദാഹരണമാണിത്. ആദ്യം, ഞങ്ങൾ ഒരു ക്ലാസ് ഉണ്ടാക്കുന്നു ഉപയോക്തൃ പെരുമാറ്റം, ഏത് ഉചിതമായ പേരും നൽകാമെങ്കിലും അത് നീട്ടണം HttpUser. HttpUser ഞങ്ങൾ വ്യക്തമാക്കുന്ന ടാസ്‌ക്കുകൾ നടപ്പിലാക്കുന്നതിനായി ഒന്നിലധികം വെർച്വൽ ഉപയോക്താക്കളെ തൽക്ഷണം ചെയ്യാൻ ശ്രദ്ധിക്കുന്ന ക്ലാസ് ആണ് ഉപയോക്തൃ പെരുമാറ്റം ക്ലാസ്. 

ഉപയോഗിച്ച് ഒരു രീതി അലങ്കരിക്കുന്നതിലൂടെ ഒരു ടാസ്ക് വ്യക്തമാക്കുന്നു @ടാസ്ക് അലങ്കാരപ്പണിക്കാരൻ. എന്നൊരു ഫംഗ്ഷനും നമുക്കുണ്ട് ഇടയിൽ () അടുത്ത ടാസ്‌ക് നിർവ്വഹിക്കുന്നതിന് മുമ്പ് കാത്തിരിക്കേണ്ട സെക്കൻഡുകളുടെ ഒരു ശ്രേണി വ്യക്തമാക്കാൻ ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു. ഞങ്ങളുടെ കോഡിൽ അതിനായി 5 മുതൽ 10 സെക്കൻഡ് വരെയുള്ള ശ്രേണി ഞങ്ങൾ നൽകിയതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും. 

കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾ ഇപ്പോഴും വെർച്വൽ പരിതസ്ഥിതിയിലാണെന്ന് ഉറപ്പാക്കുക. നിങ്ങൾ സൃഷ്ടിച്ചത് എപിഐ സേവിക്കുന്ന സെർവർ ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, ഒരു പുതിയ ടെർമിനൽ തുറക്കുക, നിങ്ങളുടെ ഡയറക്ടറി നിങ്ങളുടേതായി മാറ്റുക പദ്ധതി ഡയറക്ടറി, നിങ്ങൾ സൃഷ്ടിച്ച വെർച്വൽ എൻവയോൺമെന്റ് സജീവമാക്കുക. മുകളിൽ ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സജീവമാക്കുന്നതിനുള്ള കമാൻഡ് നിങ്ങൾക്ക് കണ്ടെത്താം. ഇപ്പോൾ, നിങ്ങളുടെ ടെർമിനലിൽ താഴെയുള്ള കമാൻഡ് നൽകുക.

 

$ വെട്ടുക്കിളി -f locust_test.py

 

നിങ്ങൾ ഇതുപോലുള്ള എന്തെങ്കിലും കാണും:

API ലോഡ് ടെസ്റ്റിംഗ് 2

സ്ഥിരസ്ഥിതിയായി, വെട്ടുക്കിളിയുടെ വെബ് ഇന്റർഫേസ് http://localhost/8089-ൽ സ്ഥിതി ചെയ്യുന്നു. നിങ്ങൾ വെബ്സൈറ്റ് സന്ദർശിക്കുകയാണെങ്കിൽ, ഇതുപോലുള്ള ഒരു ഇന്റർഫേസ് നിങ്ങൾ കാണും:

API ലോഡ് ടെസ്റ്റിംഗ് 3

ഇന്റർഫേസിൽ നിന്ന്, ഉപയോക്താക്കളുടെ എണ്ണം, സ്പോൺ നിരക്ക് (സെക്കൻഡിൽ സൃഷ്‌ടിച്ച ഉപയോക്താക്കൾ), ഹോസ്റ്റ് എന്നിവ വ്യക്തമാക്കാം. സെർവർ പ്രവർത്തിക്കുന്ന ടെർമിനൽ പരിശോധിച്ച് നിങ്ങളുടെ ഹോസ്റ്റിന്റെ വിലാസം നിങ്ങൾക്ക് ലഭിക്കും. ഞങ്ങളുടെ കാര്യത്തിൽ, അത് പോർട്ട് 5000 ആണ്. നിങ്ങൾ ക്ലിക്ക് ചെയ്യുമ്പോൾ കൂട്ടം കൂടാൻ തുടങ്ങുക, ചുവടെയുള്ള ഇന്റർഫേസ് നിങ്ങൾക്ക് നൽകും.

API ലോഡ് ടെസ്റ്റിംഗ് 4

പരാജയപ്പെട്ട അഭ്യർത്ഥനകളുടെ എണ്ണം, ഒരു അഭ്യർത്ഥനയുടെ ശരാശരി സമയം, ഒരു അഭ്യർത്ഥനയ്ക്കുള്ള ഏറ്റവും കുറഞ്ഞ സമയം, സെക്കൻഡിലെ അഭ്യർത്ഥനകൾ എന്നിങ്ങനെയുള്ള വിവിധ ഉപയോഗപ്രദമായ അളവുകൾ ഇത് കാണിക്കുന്നു. നിങ്ങൾ കാണുന്നതിൽ നിങ്ങൾ തൃപ്തനായാൽ, നിങ്ങൾക്ക് സ്റ്റോപ്പ് ബട്ടണിൽ ക്ലിക്ക് ചെയ്യാം. 


കൂടാതെ സ്ഥിതിവിവരക്കണക്കുകൾ ടാബ്, ഒരു ഉണ്ട് ചാർട്ടുകൾ കൂടുതൽ കാണിക്കുന്ന ടാബ് വിവരം ചുവടെയുള്ള ചിത്രം പോലെ ഒരു ഗ്രാഫിന്റെ രൂപത്തിൽ.

ഒരു ഉണ്ട് ഒരു സെക്കന്റ് ഗ്രാഫിലെ മൊത്തം അഭ്യർത്ഥനകൾ, പ്രതികരണ സമയ ഗ്രാഫ്, ഒപ്പം ഉപയോക്താക്കളുടെ എണ്ണം ഗ്രാഫ്, എല്ലാം സമയത്തിനെതിരെ ഗൂഢാലോചന നടത്തി. ഗ്രാഫുകൾ ഉപയോഗിച്ച്, ഒരു നിശ്ചിത പ്രതികരണ സമയത്തിന് എത്ര ഉപയോക്താക്കൾ സ്വീകാര്യരാണെന്ന് നിങ്ങൾക്ക് നിർണ്ണയിക്കാനാകും, അല്ലെങ്കിൽ ഉപയോക്താക്കളുടെ എണ്ണം കൂടുന്നുണ്ടെങ്കിലും സ്ഥിരമായ പ്രതികരണ സമയത്തിനായി നിങ്ങളുടെ ചാർട്ടുകൾ നിരീക്ഷിക്കാനും അതുപോലുള്ള മറ്റ് സ്ഥിതിവിവരക്കണക്കുകൾ നടത്താനും കഴിയും. നിങ്ങൾക്ക് ഇവ പങ്കിടണമെങ്കിൽ സ്ഥിതിവിവരക്കണക്കുകൾ മറ്റൊരാൾക്കൊപ്പം, നിങ്ങൾക്ക് ഒരു റിപ്പോർട്ട് ഡൗൺലോഡ് ചെയ്യാം ഡാറ്റ ഡൗൺലോഡുചെയ്യുക ടാബ്.

ഉപസംഹരിക്കാൻ...

നിങ്ങളുടെ ഡെവലപ്‌മെന്റ് പ്രക്രിയയിലെ ഒരു നിർണായക പ്രവർത്തനമാണ് നിങ്ങളുടെ API ലോഡിംഗ് ടെസ്റ്റിംഗ്, അതിനാൽ ഇത് നിങ്ങളുടെ ഡിസൈൻ സൈക്കിളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. വഴിയിൽ, ഉപയോക്താക്കളുടെ എണ്ണത്തിനും സ്‌പോൺ റേറ്റിനുമുള്ള മൂല്യങ്ങൾ വ്യത്യാസപ്പെടുത്തി നിങ്ങൾക്ക് മറ്റ് ലോഡ് ടെസ്റ്റ് തരങ്ങളും നടത്താം. 

നിങ്ങൾക്ക് ഒരു സ്പൈക്ക് ടെസ്റ്റ് നടത്തണമെങ്കിൽ, ഉപയോക്താക്കളുടെ എണ്ണത്തിന് ഒരു വലിയ മൂല്യം (ഉദാഹരണത്തിന് 2000) വ്യക്തമാക്കുക, തുടർന്ന് നിങ്ങളുടെ സ്‌പോൺ റേറ്റിന് തുല്യമായ വലിയ മൂല്യം നൽകുക. ഇതിനർത്ഥം, 500 സെക്കൻഡിനുള്ളിൽ, എല്ലാ 4 ഉപയോക്താക്കളെയും സൃഷ്‌ടിക്കുകയും നിങ്ങളുടെ എൻഡ് പോയിന്റുകൾ ആക്‌സസ് ചെയ്യുകയും ചെയ്യും. ഒരു സ്ട്രെസ് ടെസ്റ്റ് സമാനമായിരിക്കും, എന്നാൽ സ്പോൺ റേറ്റിന് വളരെ കുറഞ്ഞ മൂല്യം. നിങ്ങൾക്ക് ചെയ്യാനാകുന്നതെല്ലാം കണ്ടെത്താൻ, വെട്ടുക്കിളി പരിശോധിക്കുക ഡോക്യുമെന്റേഷൻ

TOR സെൻസർഷിപ്പ് മറികടക്കുന്നു

TOR ഉപയോഗിച്ച് ഇൻ്റർനെറ്റ് സെൻസർഷിപ്പ് മറികടക്കുന്നു

TOR ആമുഖത്തിലൂടെ ഇൻ്റർനെറ്റ് സെൻസർഷിപ്പ് മറികടക്കുന്നു, വിവരങ്ങളിലേക്കുള്ള ആക്‌സസ് കൂടുതൽ നിയന്ത്രിക്കപ്പെടുന്ന ഒരു ലോകത്ത്, ടോർ നെറ്റ്‌വർക്ക് പോലുള്ള ഉപകരണങ്ങൾ നിർണായകമായിത്തീർന്നിരിക്കുന്നു.

കൂടുതല് വായിക്കുക "
കോബോൾഡ് ലെറ്ററുകൾ: HTML അടിസ്ഥാനമാക്കിയുള്ള ഇമെയിൽ ഫിഷിംഗ് ആക്രമണങ്ങൾ

കോബോൾഡ് ലെറ്ററുകൾ: HTML അടിസ്ഥാനമാക്കിയുള്ള ഇമെയിൽ ഫിഷിംഗ് ആക്രമണങ്ങൾ

കോബോൾഡ് ലെറ്റേഴ്സ്: എച്ച്ടിഎംഎൽ അടിസ്ഥാനമാക്കിയുള്ള ഇമെയിൽ ഫിഷിംഗ് ആക്രമണങ്ങൾ, 31 മാർച്ച് 2024-ന്, ലൂട്ട സെക്യൂരിറ്റി ഒരു പുതിയ അത്യാധുനിക ഫിഷിംഗ് വെക്റ്ററായ കോബോൾഡ് ലെറ്റേഴ്സിലേക്ക് വെളിച്ചം വീശുന്ന ഒരു ലേഖനം പുറത്തിറക്കി.

കൂടുതല് വായിക്കുക "