ការធ្វើតេស្តផ្ទុក API ជាមួយកណ្តូប
ការធ្វើតេស្តផ្ទុក API ជាមួយកណ្ដូប៖ ការណែនាំ
អ្នកប្រហែលជាធ្លាប់ស្ថិតក្នុងស្ថានភាពនេះពីមុនមក៖ អ្នកសរសេរកូដដែលធ្វើអ្វីមួយ ជាឧទាហរណ៍ចំណុចបញ្ចប់។ អ្នកសាកល្បងចំណុចបញ្ចប់របស់អ្នកដោយប្រើ Postman ឬ Insomnia ហើយអ្វីៗដំណើរការល្អ។ អ្នកបញ្ជូនចំណុចបញ្ចប់ទៅអ្នកអភិវឌ្ឍន៍ភាគីអតិថិជន ដែលបន្ទាប់មកប្រើប្រាស់ ការ API និងដាក់ឲ្យប្រើប្រាស់កម្មវិធី។ ប៉ុន្តែបន្ទាប់មក API បរាជ័យនៅពេលអ្នកប្រើប្រាស់ប្រើប្រាស់កម្មវិធី។
នេះអាចជាស្ថានភាពដ៏គួរឱ្យរំខានមួយដែលមិននិយាយអំពីថ្លៃដើមសម្រាប់អាជីវកម្ម។ នោះហើយជាមូលហេតុដែលអ្នកបង្កើតកម្មវិធីអនុវត្តការធ្វើតេស្តជាច្រើនលើប្រព័ន្ធសូហ្វវែរ ដើម្បីធានាថាពួកគេអនុវត្តដូចការរំពឹងទុក។ API គឺមិនខុសគ្នាទេ។ មុនពេលដាក់ពង្រាយ អ្នកគួរតែធ្វើយ៉ាងហោចណាស់ការធ្វើតេស្តដំណើរការ និងការធ្វើតេស្តសុវត្ថិភាព។
ការធ្វើតេស្តការអនុវត្តអាចត្រូវបានដាក់ជាក្រុមទៅជាការធ្វើតេស្តមុខងារ និងការធ្វើតេស្តផ្ទុក។ ការធ្វើតេស្តមុខងារគឺជាអ្វីដែលអ្នកតែងតែប្រើ Postman ឬ Insomnia សម្រាប់។ ពួកគេធានាថា API របស់អ្នកដំណើរការដូចដែលអ្នករំពឹងទុក។ ម៉្យាងវិញទៀត Load tests មានការព្រួយបារម្ភកាន់តែខ្លាំងជាមួយនឹងរបៀបដែល API របស់អ្នកដំណើរការជាមួយនឹងការប្រើប្រាស់ក្នុងពិភពលោកពិតៗ និងការផ្ទុកខ្ពស់បំផុត ហើយនោះជាអ្វីដែលអត្ថបទនេះគឺនិយាយអំពី។ សូមក្រឡេកមើលការធ្វើតេស្តផ្ទុកនៅក្នុងលម្អិតបន្ថែមទៀត។
តើការធ្វើតេស្តផ្ទុក API ជាអ្វី?
ការធ្វើតេស្តផ្ទុក API គឺជាប្រភេទនៃការធ្វើតេស្តដែលអ្នកអភិវឌ្ឍន៍ប្រើដើម្បីក្លែងធ្វើការផ្ទុកធម្មតា និងខ្ពស់បំផុតនៅលើចំនុចបញ្ចប់។ ប្រភេទនៃការធ្វើតេស្តនេះអនុញ្ញាតឱ្យអ្នកអភិវឌ្ឍន៍វាយតម្លៃការអនុវត្តជាក់ស្តែងនៃ API មុនពេលវាត្រូវបានដាក់ឱ្យប្រើប្រាស់។ វាជួយពួកគេកំណត់សមត្ថភាពប្រតិបត្តិការអតិបរមានៃប្រព័ន្ធ ភាពរាំងស្ទះប្រសិនបើមាន និងការថយចុះដំណើរការ។ ការធ្វើតេស្តផ្ទុក API ជាធម្មតាត្រូវបានធ្វើឡើងដោយការបង្កើតអ្នកប្រើប្រាស់និម្មិត ហើយបន្ទាប់មកប្រើប្រាស់ពួកវាដើម្បីសាកល្បងមុខងាររបស់ API ក្នុងពេលដំណាលគ្នា។
ការធ្វើតេស្តផ្ទុក API វាស់ម៉ែត្រដូចជាពេលវេលាឆ្លើយតប អ្នកប្រើប្រាស់ដំណាលគ្នា អត្រាឆ្លងកាត់ កម្រិតនៃការប្រើប្រាស់ធនធាន ពេលវេលាមធ្យមរវាងការបរាជ័យ (MTBF) ពេលវេលាមធ្យមដើម្បីបរាជ័យ (MTTF) ជាដើម។ ម៉ែត្រទាំងអស់នេះអាចត្រូវបានប្រើដើម្បីកំណត់ថាតើ API ដំណើរការបានល្អប៉ុណ្ណា។
ប្រភេទនៃការធ្វើតេស្តផ្ទុក
មានការធ្វើតេស្តផ្ទុកជាច្រើនប្រភេទ ដែលនីមួយៗមានករណីប្រើប្រាស់របស់វា។ តោះមើលពួកគេខ្លះ។
ការធ្វើតេស្តផ្ទុក៖ នេះគឺជាទម្រង់មូលដ្ឋាននៃការធ្វើតេស្តបន្ទុក។ វាត្រូវបានប្រើដើម្បីវាយតម្លៃការដំណើរការរបស់ប្រព័ន្ធមួយ (ក្នុងករណីនេះ API) ក្រោមការផ្ទុកធម្មតា និងការផ្ទុកខ្ពស់បំផុតដែលរំពឹងទុក។
ការធ្វើតេស្តភាពតានតឹង៖ វាត្រូវបានប្រើដើម្បីវាយតម្លៃដំណើរការនៃប្រព័ន្ធក្រោមបន្ទុកធ្ងន់។ គោលដៅនៃការធ្វើតេស្តនេះគឺដើម្បីមើលថាតើប្រព័ន្ធមួយនឹងងើបឡើងវិញបន្ទាប់ពីការបរាជ័យហើយតើវាត្រូវការពេលប៉ុន្មានដើម្បីធ្វើដូច្នេះ។ បន្ទុកជាធម្មតាកើនឡើងយឺតៗ រហូតដល់វាលើសពីសមត្ថភាពនៃប្រព័ន្ធ។
ការធ្វើតេស្ត Spike៖ នេះគឺស្រដៀងនឹងការធ្វើតេស្តស្ត្រេស លើកលែងតែបន្ទុកធ្ងន់ត្រូវបានអនុវត្តភ្លាមៗ ផ្ទុយទៅនឹងការបង្កើនវាយឺតៗ។ ប្រភេទនៃការធ្វើតេស្តនេះតំណាងឱ្យអ្វីដែលកើតឡើងនៅពេលដែលមានការកើនឡើងភ្លាមៗនៃចំនួនអ្នកប្រើប្រាស់ ឬអ្នកទស្សនាជាមធ្យមរបស់អ្នក ឬនៅពេលដែលមានការវាយប្រហារ DDOS លើប្រព័ន្ធរបស់អ្នក។
ការធ្វើតេស្តត្រាំ៖ ការធ្វើតេស្តនេះមិនដូចអ្វីផ្សេងទៀតខាងលើទេ។ វាធ្វើឱ្យប្រព័ន្ធរបស់អ្នកនៅក្រោម 80% (ឬប្រហែល) នៃបន្ទុកធម្មតា ហើយទុកឱ្យវាដំណើរការក្នុងរយៈពេលយូរ និយាយថា 12 ទៅ 14 ម៉ោង។ ប្រភេទនៃការធ្វើតេស្តនេះកំណត់ថាតើប្រព័ន្ធមួយអាចទុកចិត្តបានប៉ុណ្ណាតាមពេលវេលា។
ផ្ទុកការធ្វើតេស្ត APIs របស់អ្នកជាមួយកណ្ដូប
អ្នកអភិវឌ្ឍន៍មានសិទ្ធិចូលប្រើជម្រើសជាច្រើនសម្រាប់ការផ្ទុកសាកល្បង APIs របស់ពួកគេ។ ឧបករណ៍ធ្វើតេស្តផ្ទុកទូទៅមួយចំនួនគឺ Gatling, JMeter និង Locust ។ យើងនឹងផ្តោតលើ Locust នៅក្នុងអត្ថបទនេះ។
Locust គឺជាឧបករណ៍សាកល្បងផ្ទុកប្រភពបើកចំហដែលមានមូលដ្ឋានលើ python ដែលត្រូវបានប្រើប្រាស់ដោយក្រុមហ៊ុនកំពូលៗដូចជា Google, Microsoft និង Riot Games ដើម្បីសាកល្បង APIs របស់ពួកគេ។ នៅក្នុងអត្ថបទនេះ យើងនឹងបង្ហាញពីរបៀបផ្ទុក API សាកល្បង។
សម្រាប់មេរៀននេះ ខ្ញុំនឹងបង្កើត API សាមញ្ញជាមួយ Flask ។ អ្នកអាចធ្វើតាមខ្ញុំ ឬគ្រាន់តែបង្កើត API របស់អ្នកជាមួយ Node ឬក្របខ័ណ្ឌណាមួយដែលអ្នកពេញចិត្ត។
តម្រូវការ
ពស់ថ្លាន់ 3
តំឡើងនិងតំឡើង
ដំបូងអ្នកត្រូវរៀបចំបរិស្ថាននិម្មិតនៅលើកុំព្យូទ័ររបស់អ្នក ដើម្បីកុំឱ្យរំខានដល់បរិស្ថាន Python សកលរបស់អ្នក។ ដើម្បីធ្វើដូច្នេះ សូមដំណើរការពាក្យបញ្ជាខាងក្រោម។ ចំណាំថាពាក្យបញ្ជាទាំងនេះអនុវត្តចំពោះស្ថានីយវីនដូ។
គម្រោង $ mkdir
$ cd / d ផ្លូវ \\ ទៅ \\ គម្រោង
$ python -m venv venv
$venv\Scripts\ធ្វើឱ្យសកម្ម
ដំបូងយើងបង្កើត ក គម្រោង ថត។ បន្ទាប់មកយើងប្តូរថតបច្ចុប្បន្នរបស់យើងទៅជា គម្រោង. បន្ទាប់មកយើងបានបង្កើត និងធ្វើឱ្យបរិយាកាសនិម្មិតសម្រាប់ Python នៅក្នុងថតនោះ។
ឥឡូវនេះយើងនឹងបន្តទៅការដំឡើង Flask(យើងនឹងប្រើវាដើម្បីបង្កើតចំណុចបញ្ចប់ដែលត្រូវផ្ទុកសាកល្បង) និង កណ្តូប។ ខ្លួនវាផ្ទាល់។
ដើម្បីដំឡើង Flask សូមដំណើរការ។ ត្រូវប្រាកដថាអ្នកស្ថិតនៅក្នុង គម្រោង កន្លែងដែលអ្នកបង្កើតបរិយាកាសនិម្មិត។
$ pip ដំឡើងដប
ដើម្បីដំឡើង Locust សូមដំណើរការ
$ pip ដំឡើងកណ្ដូប
នៅពេលវារួចរាល់ សូមវាយពាក្យបញ្ជាខាងក្រោម។ ត្រូវប្រាកដថាអ្នកស្ថិតនៅក្នុងរបស់អ្នក។ គម្រោង ថតនៅពេលអ្នកធ្វើវា។
$ ចម្លង nul __init__.py
កម្មវិធី $ mkdir
$ copy nul app\app.py
$ copy nul កម្មវិធី\__init__.py
ពាក្យបញ្ជានេះបង្កើតឯកសារមួយចំនួនដែលយើងនឹងប្រើដើម្បីបង្កើតចំណុចបញ្ចប់របស់យើងដោយប្រើ Flask ។ អ្នកក៏អាចបង្កើតឯកសារទាំងនេះដោយប្រើកម្មវិធីរុករកឯកសាររបស់អ្នកផងដែរ។ ប៉ុន្តែអ្វីដែលជាការសប្បាយនៅក្នុងនោះ? ពេលអ្នកបានធ្វើរួចហើយ សូមចម្លងកូដខាងក្រោមទៅក្នុង app.py
ពីការនាំចូល flask Flask, jsonify, ស្នើសុំ
កម្មវិធី = Flask (__name__)
car_models = [
{ 'ម៉ាក': 'Tesla', 'ម៉ូដែល': 'ម៉ូដែល S' }
]
plane_models = [
{ 'ម៉ាក': 'Boeing', 'ម៉ូដែល': '747' }
]
@app.route('/cars')
def get_cars():
ត្រឡប់ jsonify(car_models)
@app.route('/planes')
def get_planes():
ត្រឡប់ jsonify(plane_models)
ប្រសិនបើ __name__ == '__main__':
app.run(debug=ពិត)
កូដខាងលើមានវិធីសាស្រ្តមួយ។ get_cars ធ្លាប់ទទួលបានបញ្ជីម៉ាករថយន្ត និងម៉ូដែលរបស់ពួកគេ និង get_planes ធ្លាប់ទទួលបានបញ្ជីម៉ាកយន្តហោះ និងម៉ូដែលរបស់ពួកគេ។ ដើម្បីឲ្យយើងផ្ទុកសាកល្បងចំណុចបញ្ចប់នេះ យើងត្រូវដំណើរការ app.py ។ ដើម្បីធ្វើដូចនេះរត់ពាក្យបញ្ជាខាងក្រោម។
$ python path\to\app.py
នៅពេលដែលអ្នកដំណើរការវា អ្នកគួរតែឃើញអ្វីមួយដូចនេះ៖
ប្រសិនបើអ្នកចម្លង URL ពីស្ថានីយហើយវាយ រថយន្ត or យន្តហោះ បន្ទាប់ពី /, អ្នកគួរតែអាចមើលឃើញទិន្នន័យនៅទីនោះ។ ទោះយ៉ាងណាក៏ដោយ គោលដៅរបស់យើងគឺដើម្បីសាកល្បងចំណុចបញ្ចប់ជាមួយកណ្ដូប មិនមែនជាមួយកម្មវិធីរុករកទេ។ ដូច្នេះ ចូរយើងធ្វើដូច្នេះ។ ដំណើរការពាក្យបញ្ជាខាងក្រោមនៅក្នុង root របស់អ្នក។ គម្រោង ថត។
$ copy nul locust_test.py
វាបង្កើតឯកសារ 'locust_test.py' នៅក្នុង root របស់អ្នក។ គម្រោង ថត។ ពេលអ្នកបានធ្វើរួចហើយ សូមបើកឯកសារ ហើយបិទភ្ជាប់ក្នុងកូដខាងក្រោម។ យើងនឹងពន្យល់យ៉ាងខ្លី។
ពេលវេលានាំចូល
ពីការនាំចូលកណ្ដូប HttpUser, ភារកិច្ច, រវាង
ថ្នាក់ UserBehaviour(HttpUser)៖
wait_time = ចន្លោះ (5, 10)
@កិច្ចការ
def get_cars (ខ្លួនឯង)៖
self.client.get('/cars')
@កិច្ចការ
def get_planes (ខ្លួនឯង)៖
self.client.get('/planes')
នេះគឺជាឧទាហរណ៍ជាមូលដ្ឋាននៃការប្រើប្រាស់ Locust ដើម្បីផ្ទុកសាកល្បង API ។ ដំបូងយើងបង្កើតថ្នាក់ ឥរិយាបថអ្នកប្រើប្រាស់ដែលអាចត្រូវបានផ្តល់ឈ្មោះសមរម្យណាមួយ ប៉ុន្តែត្រូវតែពង្រីក HttpUser HttpUser គឺជាថ្នាក់ដែលយកចិត្តទុកដាក់ក្នុងការធ្វើឱ្យអ្នកប្រើនិម្មិតច្រើនភ្លាមៗដើម្បីបំពេញកិច្ចការដែលយើងបញ្ជាក់ក្នុង ឥរិយាបថអ្នកប្រើប្រាស់ ថ្នាក់។
ភារកិច្ចត្រូវបានបញ្ជាក់ដោយការតុបតែងវិធីសាស្រ្តជាមួយ @កិច្ចការ អ្នកតុបតែង។ យើងក៏មានមុខងារហៅថា រវាង () ដែលអនុញ្ញាតឱ្យយើងបញ្ជាក់ជួរនៃវិនាទីដែលត្រូវរង់ចាំ មុនពេលប្រតិបត្តិកិច្ចការបន្ទាប់។ អ្នកអាចមើលឃើញថាយើងបានកំណត់ជួរពី 5 ទៅ 10 វិនាទីសម្រាប់នោះនៅក្នុងកូដរបស់យើង។
ដើម្បីដំណើរការកូដ សូមប្រាកដថាអ្នកនៅតែស្ថិតក្នុងបរិយាកាសនិម្មិតរបស់អ្នក។ ប្រសិនបើអ្នកបានបង្កើតត្រូវបានប្រើប្រាស់ដោយម៉ាស៊ីនមេដែលបម្រើ API បើកស្ថានីយថ្មី ផ្លាស់ប្តូរថតរបស់អ្នកទៅជារបស់អ្នក។ គម្រោង ថត និងធ្វើឱ្យបរិយាកាសនិម្មិតដែលអ្នកបានបង្កើត។ អ្នកអាចស្វែងរកពាក្យបញ្ជាសម្រាប់ធ្វើឱ្យបរិយាកាសនិម្មិតខាងលើសកម្ម។ ឥឡូវនេះ សូមបញ្ចូលពាក្យបញ្ជាខាងក្រោមនៅក្នុងស្ថានីយរបស់អ្នក។
$locust -f locust_test.py
អ្នកគួរតែឃើញអ្វីមួយដូចនេះ៖
តាមលំនាំដើម ចំណុចប្រទាក់បណ្ដាញរបស់កណ្តូបមានទីតាំងនៅ http://localhost/8089 ។ ប្រសិនបើអ្នកចូលទៅកាន់គេហទំព័រ អ្នកគួរតែឃើញចំណុចប្រទាក់ដូចនេះ៖
ពីចំណុចប្រទាក់ យើងអាចបញ្ជាក់ចំនួនអ្នកប្រើប្រាស់ អត្រាពង (អ្នកប្រើប្រាស់បង្កើតក្នុងមួយវិនាទី) និងម៉ាស៊ីន។ អ្នកអាចទទួលបានអាសយដ្ឋានរបស់ម៉ាស៊ីនរបស់អ្នកដោយពិនិត្យមើលស្ថានីយដែលម៉ាស៊ីនមេកំពុងដំណើរការ។ ក្នុងករណីរបស់យើងវាស្ថិតនៅច្រក 5000។ នៅពេលអ្នកចុចលើ ចាប់ផ្តើមវាយលុក, អ្នកនឹងត្រូវបានបង្ហាញជាមួយចំណុចប្រទាក់ខាងក្រោម។
នេះបង្ហាញអ្នកនូវរង្វាស់ដែលមានប្រយោជន៍ជាច្រើនដូចជាចំនួនសំណើដែលបរាជ័យ ពេលវេលាជាមធ្យមសម្រាប់សំណើ ពេលវេលាអប្បបរមាសម្រាប់សំណើ សំណើក្នុងមួយវិនាទី។ល។ នៅពេលដែលអ្នកពេញចិត្តនឹងអ្វីដែលអ្នកឃើញ អ្នកអាចចុចលើប៊ូតុងបញ្ឈប់។
ក្រៅពី ស្ថិតិ ផ្ទាំង, មានមួយ។ គំនូសតាង ផ្ទាំងដែលបង្ហាញច្រើនទៀត ព ក្នុងទម្រង់ជាក្រាហ្វ ដូចរូបភាពខាងក្រោម។
នៅទីនោះគឺជា សំណើសរុបក្នុងមួយក្រាហ្វទីពីរ, ក្រាហ្វពេលវេលាឆ្លើយតប, និង ចំនួនអ្នកប្រើប្រាស់ក្រាហ្វទាំងអស់គ្រោងប្រឆាំងនឹងពេលវេលា។ ដោយប្រើក្រាហ្វ អ្នកអាចកំណត់ថាតើអ្នកប្រើប្រាស់ប៉ុន្មាននាក់ដែលអាចទទួលយកបានសម្រាប់ពេលវេលាឆ្លើយតបថេរ ឬអ្នកអាចសង្កេតមើលតារាងរបស់អ្នកសម្រាប់ពេលវេលាឆ្លើយតបថេរ ទោះបីជាចំនួនអ្នកប្រើប្រាស់កើនឡើង និងការយល់ដឹងផ្សេងទៀតដូចនោះ។ ប្រសិនបើអ្នកចង់ចែករំលែកទាំងនេះ ស្ថិតិ ជាមួយអ្នកផ្សេង អ្នកអាចទាញយករបាយការណ៍ពី ទាញយកទិន្នន័យ។ ផ្ទាំង។
សរុបមក...
ការផ្ទុកការធ្វើតេស្ត API របស់អ្នកគឺជាសកម្មភាពសំខាន់នៅក្នុងដំណើរការអភិវឌ្ឍន៍របស់អ្នក ដូច្នេះត្រូវប្រាកដថាវាត្រូវបានបញ្ចូលក្នុងវដ្តនៃការរចនារបស់អ្នក។ ដោយវិធីនេះ អ្នកក៏អាចអនុវត្តប្រភេទតេស្តផ្ទុកផ្សេងទៀតដោយផ្លាស់ប្តូរតម្លៃសម្រាប់ចំនួនអ្នកប្រើប្រាស់ និងអត្រាពង។
ប្រសិនបើអ្នកចង់ធ្វើការធ្វើតេស្តកើនឡើង សូមបញ្ជាក់តម្លៃធំ (និយាយថា 2000) សម្រាប់ចំនួនអ្នកប្រើប្រាស់ ហើយបន្ទាប់មកតម្លៃធំស្មើគ្នាសម្រាប់អត្រាពងរបស់អ្នក (ឧទាហរណ៍ 500)។ នេះមានន័យថាក្នុងរយៈពេល 4 វិនាទី អ្នកនឹងមានអ្នកប្រើប្រាស់ 2000 នាក់ទាំងអស់ដែលបានបង្កើត និងចូលប្រើចំណុចបញ្ចប់របស់អ្នក។ ការធ្វើតេស្តស្ត្រេសនឹងស្រដៀងគ្នា ប៉ុន្តែជាមួយនឹងតម្លៃទាបជាងច្រើនសម្រាប់អត្រាពង។ ដើម្បីស្វែងយល់ពីអ្វីដែលអ្នកអាចធ្វើបាន សូមពិនិត្យមើលកណ្តូប ឯកសារ.
