வெட்டுக்கிளியுடன் API சுமை சோதனை
வெட்டுக்கிளியுடன் API சுமை சோதனை: அறிமுகம்
நீங்கள் இதற்கு முன் இந்த சூழ்நிலையில் இருந்திருக்கலாம்: நீங்கள் ஏதாவது செய்யும் குறியீட்டை எழுதுகிறீர்கள், எடுத்துக்காட்டாக ஒரு இறுதிப்புள்ளி. போஸ்ட்மேன் அல்லது இன்சோம்னியாவைப் பயன்படுத்தி உங்கள் இறுதிப் புள்ளியைச் சோதிக்கிறீர்கள், எல்லாம் நன்றாக வேலை செய்கிறது. கிளையன்ட் பக்க டெவலப்பருக்கு நீங்கள் இறுதிப்புள்ளியை அனுப்புகிறீர்கள், பின்னர் அவர் பயன்படுத்துகிறார் ஏபிஐ மற்றும் பயன்பாட்டை வரிசைப்படுத்துகிறது. ஆனால், பயனர்கள் பயன்பாட்டைப் பயன்படுத்தும் போது API தோல்வியடைகிறது.
இது மிகவும் எரிச்சலூட்டும் சூழ்நிலையாக இருக்கலாம், ஒரு வணிகத்திற்கு விலையுயர்ந்ததாக குறிப்பிட தேவையில்லை. அதனால்தான் மென்பொருள் உருவாக்குநர்கள் எதிர்பார்த்தபடி செயல்படுவதை உறுதி செய்வதற்காக மென்பொருள் அமைப்புகளில் பல்வேறு சோதனைகளை மேற்கொள்கின்றனர். APIகள் வேறுபட்டவை அல்ல. வரிசைப்படுத்துவதற்கு முன், நீங்கள் குறைந்தபட்சம் செயல்திறன் சோதனைகள் மற்றும் பாதுகாப்பு சோதனைகளை செய்ய வேண்டும்.
செயல்திறன் சோதனைகள் செயல்பாட்டு சோதனைகள் மற்றும் சுமை சோதனைகள் என தொகுக்கப்படலாம். நீங்கள் வழக்கமாக போஸ்ட்மேன் அல்லது இன்சோம்னியாவைப் பயன்படுத்துவதே செயல்பாட்டுச் சோதனைகள். நீங்கள் எதிர்பார்ப்பது போல் உங்கள் API செயல்படுவதை அவை உறுதி செய்கின்றன. மறுபுறம், சுமை சோதனைகள், நிஜ உலக பயன்பாடு மற்றும் உச்ச சுமை ஆகியவற்றில் உங்கள் API எவ்வாறு செயல்படுகிறது என்பதில் அதிக அக்கறை கொண்டுள்ளது, அதுதான் இந்தக் கட்டுரை. சுமை சோதனைகளை இன்னும் விரிவாகப் பார்ப்போம்.
ஏபிஐ சுமை சோதனை என்றால் என்ன?
ஏபிஐ சுமை சோதனை என்பது இறுதிப் புள்ளிகளில் இயல்பான மற்றும் உச்ச சுமையை உருவகப்படுத்த டெவலப்பர்கள் பயன்படுத்தும் ஒரு வகை சோதனை ஆகும். இந்த வகையான சோதனையானது, API பயன்படுத்தப்படுவதற்கு முன்பு அதன் நிஜ உலக செயல்திறனை மதிப்பீடு செய்ய டெவலப்பர்களை அனுமதிக்கிறது. ஒரு கணினியின் அதிகபட்ச இயக்கத் திறன், ஏதேனும் சிக்கல்கள் இருந்தால், மற்றும் செயல்திறன் சிதைவு ஆகியவற்றைக் கண்டறிய இது அவர்களுக்கு உதவுகிறது. ஏபிஐ சுமை சோதனைகள் பொதுவாக மெய்நிகர் பயனர்களை உருவாக்குவதன் மூலம் செய்யப்படுகின்றன, பின்னர் ஏபிஐயின் செயல்பாட்டை ஒரே நேரத்தில் சோதிக்க அவற்றைப் பயன்படுத்துகின்றன.
API சுமை சோதனைகள் மறுமொழி நேரம், ஒரே நேரத்தில் பயனர்கள், செயல்திறன் விகிதங்கள், வள பயன்பாட்டு நிலைகள், தோல்விக்கு இடையிலான சராசரி நேரம் (MTBF), தோல்விக்கான சராசரி நேரம் (MTTF) மற்றும் பல போன்ற அளவீடுகளை அளவிடுகின்றன. இந்த அளவீடுகள் அனைத்தும் API எவ்வளவு சிறப்பாகச் செயல்படுகிறது என்பதைத் தீர்மானிக்கப் பயன்படும்.
சுமை சோதனையின் வகைகள்
பல வகையான சுமை சோதனைகள் உள்ளன, ஒவ்வொன்றும் அதன் பயன்பாட்டு நிகழ்வுகளுடன். அவற்றில் சிலவற்றைப் பார்ப்போம்.
சுமை சோதனை: இது சுமை சோதனையின் அடிப்படை வடிவம். இது சாதாரண சுமை மற்றும் எதிர்பார்க்கப்படும் உச்ச சுமையின் கீழ் ஒரு கணினியின் செயல்திறனை (இந்த விஷயத்தில், ஒரு API) மதிப்பிட பயன்படுகிறது.
மன அழுத்த சோதனை: இது மிகவும் அதிக சுமையின் கீழ் ஒரு அமைப்பின் செயல்திறனை மதிப்பிட பயன்படுகிறது. இந்தச் சோதனையின் குறிக்கோள், தோல்விக்குப் பிறகு ஒரு கணினி மீட்கப்படுகிறதா, அதைச் செய்ய எவ்வளவு நேரம் ஆகும் என்பதைப் பார்ப்பது. கணினியின் திறன்களை மீறும் வரை சுமை பொதுவாக மெதுவாக அதிகரிக்கிறது.
ஸ்பைக் சோதனை: இது அழுத்த சோதனைக்கு சற்று ஒத்ததாகும், அதிக சுமை திடீரெனப் பயன்படுத்தப்படுவதைத் தவிர, மெதுவாக அதை உயர்த்துவதற்கு மாறாக. உங்கள் சராசரி பயனர்கள் அல்லது பார்வையாளர்களின் எண்ணிக்கையில் திடீர் அதிகரிப்பு ஏற்பட்டால் அல்லது உங்கள் கணினியில் DDOS தாக்குதல் ஏற்பட்டால் என்ன நடக்கும் என்பதை இந்த வகையான சோதனை பிரதிபலிக்கிறது.
ஊறவைத்தல் சோதனை: இந்த சோதனை மேலே உள்ளதைப் போலல்லாமல் உள்ளது. இது உங்கள் கணினியை 80% (அல்லது அதற்கு மேல்) சாதாரண சுமையின் கீழ் வைத்து, 12 முதல் 14 மணிநேரம் வரை நீண்ட காலத்திற்கு இயங்க வைக்கிறது. இந்த வகையான சோதனையானது காலப்போக்கில் ஒரு அமைப்பு எவ்வளவு நம்பகமானது என்பதை தீர்மானிக்கிறது.
வெட்டுக்கிளி மூலம் உங்கள் APIகளை சோதனை செய்வதை ஏற்றவும்
டெவலப்பர்கள் தங்கள் APIகளை சுமை சோதனை செய்வதற்கான பல்வேறு விருப்பங்களுக்கான அணுகலைக் கொண்டுள்ளனர். Gatling, JMeter மற்றும் Locust ஆகியவை சில பொதுவான சுமை சோதனைக் கருவிகள். இந்தக் கட்டுரையில் வெட்டுக்கிளி மீது கவனம் செலுத்துவோம்.
வெட்டுக்கிளி என்பது பைதான் அடிப்படையிலான ஓப்பன் சோர்ஸ் சுமை சோதனைக் கருவியாகும், இது கூகுள், மைக்ரோசாப்ட் மற்றும் ரைட் கேம்ஸ் போன்ற சிறந்த நிறுவனங்களால் தங்கள் ஏபிஐகளைச் சோதிக்கப் பயன்படுத்துகிறது. இந்த கட்டுரையில், சோதனை API ஐ எவ்வாறு ஏற்றுவது என்பதை நாங்கள் விளக்குவோம்.
இந்த டுடோரியலுக்காக, நான் ஒரு எளிய API ஐ Flask உடன் உருவாக்குகிறேன். நீங்கள் என்னுடன் சேர்ந்து பின்தொடரலாம் அல்லது உங்கள் API ஐ Node மூலம் உருவாக்கலாம் அல்லது உங்களுக்கு வசதியான எந்த கட்டமைப்பையும் உருவாக்கலாம்.
தேவைகள்
பைதான் 3
அமைவு & நிறுவல்
முதலில், உங்கள் கணினியில் ஒரு மெய்நிகர் சூழலை அமைக்க வேண்டும், இதனால் உங்கள் உலகளாவிய பைதான் சூழலை குழப்ப வேண்டாம். இதைச் செய்ய, பின்வரும் கட்டளைகளை இயக்கவும். இந்த கட்டளைகள் விண்டோஸ் டெர்மினலுக்கு பொருந்தும் என்பதை நினைவில் கொள்க.
$ mkdir திட்டம்
$ cd / d பாதை
$ python -m venv venv
$ venv\Scripts\activate
முதலில், நாங்கள் உருவாக்கினோம் திட்டம் அடைவு. பின்னர் எங்கள் தற்போதைய கோப்பகத்தை மாற்றினோம் திட்டம். அந்த கோப்பகத்தில் பைத்தானுக்கு ஒரு மெய்நிகர் சூழலை உருவாக்கி செயல்படுத்தினோம்.
இப்போது, நாம் நிறுவலுக்குச் செல்வோம் குடுவை(சுமை சோதனை செய்யப்பட வேண்டிய இறுதிப்புள்ளிகளை உருவாக்க இதைப் பயன்படுத்துவோம்) மற்றும் வெட்டுக்கிளி தன்னை.
பிளாஸ்கை நிறுவ, இயக்கவும். நீங்கள் உள்ளே இருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள் திட்டம் நீங்கள் ஒரு மெய்நிகர் சூழலை உருவாக்கியுள்ளீர்கள்.
$ பிப் நிறுவல் குடுவை
Locust ஐ நிறுவ, இயக்கவும்
$ பிப் நிறுவல் வெட்டுக்கிளி
அது முடிந்ததும், பின்வரும் கட்டளைகளை தட்டச்சு செய்யவும். நீங்கள் உங்களில் இருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள் திட்டம் நீங்கள் இதைச் செய்யும்போது அடைவு.
$ நகல் nul __init__.py
$ mkdir பயன்பாடு
$ nul app\app.py நகலெடு
$ nul பயன்பாட்டை நகலெடு\__init__.py
இந்த கட்டளை சில கோப்புகளை உருவாக்குகிறது, அதை நாம் Flask ஐப் பயன்படுத்தி இறுதிப் புள்ளிகளை உருவாக்கப் பயன்படுத்துவோம். உங்கள் கோப்பு எக்ஸ்ப்ளோரரைப் பயன்படுத்தியும் இந்தக் கோப்புகளை உருவாக்கலாம். ஆனால் இதில் என்ன வேடிக்கை? நீங்கள் அதைச் செய்தவுடன், கீழே உள்ள குறியீட்டை நகலெடுக்கவும் app.py
குடுவை இறக்குமதியிலிருந்து பிளாஸ்க், jsonify, கோரிக்கை
பயன்பாடு = குடுவை(__பெயர்__)
கார்_மாடல்கள் = [
{ 'பிராண்ட்': 'டெஸ்லா', 'மாடல்': 'மாடல் எஸ்' }
]
விமானம்_மாடல்கள் = [
{ 'பிராண்ட்': 'போயிங்', 'மாடல்': '747' }
]
@app.route('/cars')
def get_cars():
திரும்ப jsonify(car_models)
@app.route('/விமானங்கள்')
def get_planes():
திரும்ப jsonify(விமானம்_மாடல்கள்)
__பெயர்__ == '__முக்கிய__' என்றால்:
app.run(பிழைத்திருத்தம்=True)
மேலே உள்ள குறியீடு ஒரு முறையைக் கொண்டுள்ளது பெற_கார்கள் கார் பிராண்டுகள் மற்றும் அவற்றின் மாடல்களின் பட்டியலைப் பெறப் பயன்படுகிறது பெற_விமானங்கள் விமான பிராண்டுகள் மற்றும் அவற்றின் மாதிரிகளின் பட்டியலைப் பெறப் பயன்படுகிறது. இந்த இறுதிப்புள்ளியை சோதனையை ஏற்றுவதற்கு, app.pyஐ இயக்க வேண்டும். இதைச் செய்ய, கீழே உள்ள கட்டளையை இயக்கவும்.
$ பைதான் பாதை\to\app.py
நீங்கள் அதை இயக்கியதும், இது போன்ற ஒன்றை நீங்கள் பார்க்க வேண்டும்:
டெர்மினலில் இருந்து URL ஐ நகலெடுத்து தட்டச்சு செய்தால் கார்கள் or விமானங்கள் / க்குப் பிறகு, நீங்கள் அங்குள்ள தரவைப் பார்க்க முடியும். எவ்வாறாயினும், இறுதிப்புள்ளியை வெட்டுக்கிளி மூலம் சோதிப்பதே எங்கள் குறிக்கோள், உலாவி மூலம் அல்ல. எனவே அதை செய்வோம். உங்கள் ரூட்டில் பின்வரும் கட்டளையை இயக்கவும் திட்டம் அடைவு.
$ நகல் 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')
ஏபிஐ சோதனையை ஏற்றுவதற்கு வெட்டுக்கிளியைப் பயன்படுத்துவதற்கான அடிப்படை எடுத்துக்காட்டு இது. முதலில், நாங்கள் ஒரு வகுப்பை உருவாக்குகிறோம் பயனர் நடத்தை, எந்த பொருத்தமான பெயரையும் கொடுக்கலாம் ஆனால் நீட்டிக்க வேண்டும் HttpUser. HttpUser பல மெய்நிகர் பயனர்களை நாங்கள் குறிப்பிடும் பணிகளைச் செயல்படுத்துவதைக் கவனித்துக்கொள்ளும் வர்க்கம் பயனர் நடத்தை வர்க்கம்.
ஒரு முறையை அலங்கரிப்பதன் மூலம் ஒரு பணி குறிப்பிடப்படுகிறது @பணி அலங்கரிப்பவர். நமக்கும் ஒரு செயல்பாடு உள்ளது இடையில் () இது அடுத்த பணியைச் செய்வதற்கு முன் காத்திருக்க வேண்டிய வினாடிகளின் வரம்பைக் குறிப்பிட அனுமதிக்கிறது. எங்கள் குறியீட்டில் 5 முதல் 10 வினாடிகள் வரையிலான வரம்பை நாங்கள் ஒதுக்கியிருப்பதை நீங்கள் பார்க்கலாம்.
குறியீட்டை இயக்க, நீங்கள் இன்னும் உங்கள் மெய்நிகர் சூழலில் இருப்பதை உறுதிசெய்யவும். நீங்கள் உருவாக்கியதை API சேவை செய்யும் சர்வரால் பயன்படுத்தினால், புதிய டெர்மினலைத் திறந்து, உங்கள் கோப்பகத்தை மாற்றவும் திட்டம் அடைவு மற்றும் நீங்கள் உருவாக்கிய மெய்நிகர் சூழலை செயல்படுத்தவும். மேலே உள்ள மெய்நிகர் சூழலை செயல்படுத்துவதற்கான கட்டளையை நீங்கள் காணலாம். இப்போது, உங்கள் டெர்மினலில் கீழே உள்ள கட்டளையை உள்ளிடவும்.
$ வெட்டுக்கிளி -f locust_test.py
இது போன்ற ஒன்றை நீங்கள் காண வேண்டும்:
இயல்பாக, வெட்டுக்கிளியின் வலை இடைமுகம் http://localhost/8089 இல் அமைந்துள்ளது. நீங்கள் வலைத்தளத்தைப் பார்வையிட்டால், இது போன்ற ஒரு இடைமுகத்தை நீங்கள் பார்க்க வேண்டும்:
இடைமுகத்திலிருந்து, பயனர்களின் எண்ணிக்கை, ஸ்பான் வீதம் (பயனர்கள் ஒரு வினாடிக்கு உருவாக்கப்பட்டவர்கள்) மற்றும் ஹோஸ்ட் ஆகியவற்றைக் குறிப்பிடலாம். சர்வர் இயங்கும் டெர்மினலைச் சரிபார்த்து உங்கள் ஹோஸ்டின் முகவரியைப் பெறலாம். எங்கள் விஷயத்தில், அது போர்ட் 5000 இல் உள்ளது. நீங்கள் கிளிக் செய்யும் போது திரளத் தொடங்குங்கள், கீழே உள்ள இடைமுகத்துடன் நீங்கள் வழங்கப்படுவீர்கள்.
தோல்வியுற்ற கோரிக்கைகளின் எண்ணிக்கை, கோரிக்கைக்கான சராசரி நேரம், கோரிக்கைக்கான குறைந்தபட்ச நேரம், வினாடிக்கான கோரிக்கைகள் மற்றும் பல போன்ற பல்வேறு பயனுள்ள அளவீடுகளை இது காட்டுகிறது. நீங்கள் பார்த்ததில் திருப்தி அடைந்தவுடன், நிறுத்து பொத்தானைக் கிளிக் செய்யலாம்.
தவிர புள்ளியியல் தாவல், ஒரு உள்ளது வரைபடங்கள் மேலும் காட்டும் தாவல் தகவல் கீழே உள்ள படத்தைப் போல வரைபட வடிவில்.
அங்கே ஒரு ஒரு வினாடிக்கு மொத்த கோரிக்கைகள், பதில் நேர வரைபடம், மற்றும் பயனர்களின் எண்ணிக்கை வரைபடம், அனைத்தும் காலத்திற்கு எதிராக திட்டமிடப்பட்டது. வரைபடங்களைப் பயன்படுத்தி, ஒரு நிலையான பதிலளிப்பு நேரத்திற்கு எத்தனை பயனர்கள் ஏற்றுக்கொள்ளப்படுவார்கள் என்பதை நீங்கள் தீர்மானிக்கலாம் அல்லது பயனர்களின் எண்ணிக்கை அதிகரித்துள்ள போதிலும் நிலையான மறுமொழி நேரத்திற்கு உங்கள் விளக்கப்படங்களை நீங்கள் அவதானிக்கலாம் மற்றும் அது போன்ற பிற நுண்ணறிவுகள். இவற்றைப் பகிர விரும்பினால் புள்ளிவிவரங்கள் வேறொருவருடன், நீங்கள் ஒரு அறிக்கையைப் பதிவிறக்கலாம் தரவைப் பதிவிறக்குக தாவல்.
முடிவுக்கு...
உங்கள் ஏபிஐயை ஏற்றிச் சோதனை செய்வது உங்கள் மேம்பாட்டுச் செயல்பாட்டில் ஒரு முக்கியமான செயலாகும், எனவே இது உங்கள் வடிவமைப்பு சுழற்சியில் இணைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். மூலம், பயனர்களின் எண்ணிக்கை மற்றும் ஸ்பான் வீதத்திற்கான மதிப்புகளை மாற்றுவதன் மூலம் மற்ற சுமை சோதனை வகைகளையும் நீங்கள் மேற்கொள்ளலாம்.
நீங்கள் ஒரு ஸ்பைக் சோதனையை செய்ய விரும்பினால், பயனர்களின் எண்ணிக்கைக்கு ஒரு பெரிய மதிப்பைக் குறிப்பிடவும் (என்று 2000), பின்னர் உங்கள் ஸ்பான் விகிதத்திற்கு (உதாரணமாக 500) பெரிய மதிப்பைக் குறிப்பிடவும். அதாவது, 4 வினாடிகளில், 2000 பயனர்களும் உங்கள் இறுதிப்புள்ளிகளை உருவாக்கி அணுகிவிடுவீர்கள். ஒரு மன அழுத்த சோதனை ஒத்ததாக இருக்கும், ஆனால் ஸ்பான் விகிதத்திற்கான மிகக் குறைந்த மதிப்பைக் கொண்டிருக்கும். நீங்கள் செய்யக்கூடிய அனைத்தையும் அறிய, வெட்டுக்கிளியைப் பார்க்கவும் ஆவணங்கள்.
