API ჩატვირთვის ტესტირება Locust-ით

API ჩატვირთვის ტესტირება Locust-ით

API ჩატვირთვის ტესტირება Locust-ით: შესავალი

თქვენ ალბათ ადრე ყოფილხართ ასეთ სიტუაციაში: თქვენ წერთ კოდს, რომელიც რაღაცას აკეთებს, მაგალითად, საბოლოო წერტილს. თქვენ შეამოწმებთ თქვენს საბოლოო წერტილს Postman-ის ან Insomnia-ის გამოყენებით და ყველაფერი კარგად მუშაობს. თქვენ გადასცემთ საბოლოო წერტილს კლიენტის მხარის დეველოპერს, რომელიც შემდეგ მოიხმარს API და განათავსებს აპლიკაციას. მაგრამ შემდეგ, API მარცხდება, როდესაც მომხმარებლები იყენებენ აპს.

ეს შეიძლება იყოს სუპერ შემაშფოთებელი სიტუაცია, რომ აღარაფერი ვთქვათ ბიზნესისთვის ძვირადღირებულ სიტუაციაში. სწორედ ამიტომ, პროგრამული უზრუნველყოფის შემქმნელები ატარებენ სხვადასხვა ტესტებს პროგრამულ სისტემებზე, რათა უზრუნველყონ მათი შესრულება ისე, როგორც მოსალოდნელია. API არ განსხვავდება. განლაგებამდე, თქვენ უნდა გააკეთოთ მინიმუმ შესრულების ტესტები და უსაფრთხოების ტესტები.

შესრულების ტესტები შეიძლება დაჯგუფდეს ფუნქციონალურ ტესტებად და დატვირთვის ტესტებად. ფუნქციონალურობის ტესტები არის ის, რისთვისაც ჩვეულებრივ იყენებთ ფოსტალიონს ან უძილობას. ისინი უზრუნველყოფენ, რომ თქვენი API ფუნქციონირებს ისე, როგორც თქვენ მოელით. მეორეს მხრივ, ჩატვირთვის ტესტები უფრო მეტად ეხება იმას, თუ როგორ მუშაობს თქვენი API რეალურ სამყაროში გამოყენებისა და პიკური დატვირთვის დროს, და ეს არის ის, რასაც ეს სტატია ეხება. მოდით შევხედოთ დატვირთვის ტესტებს უფრო დეტალურად.

რა არის API დატვირთვის ტესტირება?

API დატვირთვის ტესტირება არის ტესტირების ტიპი, რომელსაც იყენებენ დეველოპერები ნორმალური და პიკური დატვირთვის სიმულაციისთვის საბოლოო წერტილებზე. ამ ტიპის ტესტირება დეველოპერებს საშუალებას აძლევს შეაფასონ API-ის რეალურ სამყაროში შესრულება, სანამ ის განლაგდება. ის ეხმარება მათ ამოიცნონ სისტემის მაქსიმალური ოპერაციული სიმძლავრე, შეფერხებები, თუ არსებობს, და შესრულების დეგრადაცია. API ჩატვირთვის ტესტები ჩვეულებრივ კეთდება ვირტუალური მომხმარებლების შექმნით და შემდეგ მათი გამოყენებით API-ს ფუნქციონირების პარალელურად შესამოწმებლად. 

API ჩატვირთვის ტესტები ზომავს მეტრებს, როგორიცაა რეაგირების დრო, თანმხლები მომხმარებლები, გამტარუნარიანობა, რესურსების გამოყენების დონე, საშუალო დრო წარუმატებლობას შორის (MTBF), საშუალო დრო წარუმატებლობამდე (MTTF) და ა.შ. ყველა ეს მეტრიკა შეიძლება გამოყენებულ იქნას იმის დასადგენად, თუ რამდენად კარგად მუშაობს API.

დატვირთვის ტესტირების სახეები

არსებობს დატვირთვის ტესტირების რამდენიმე ტიპი, თითოეულს აქვს თავისი გამოყენების შემთხვევები. მოდით შევხედოთ ზოგიერთ მათგანს.

დატვირთვის ტესტირება: ეს არის დატვირთვის ტესტის ძირითადი ფორმა. იგი გამოიყენება სისტემის (ამ შემთხვევაში, API) მუშაობის შესაფასებლად ნორმალური დატვირთვისა და მოსალოდნელი პიკური დატვირთვის პირობებში.

სტრესის ტესტირება: ეს გამოიყენება სისტემის მუშაობის შესაფასებლად ძალიან მძიმე დატვირთვის ქვეშ. ამ ტესტის მიზანია იმის დანახვა, აღდგება თუ არა სისტემა წარუმატებლობის შემდეგ და რამდენი დრო სჭირდება ამის გაკეთებას. დატვირთვა ჩვეულებრივ იზრდება ნელა, სანამ არ გადააჭარბებს სისტემის შესაძლებლობებს.

Spike ტესტირება: ეს ოდნავ წააგავს სტრეს ტესტირებას, გარდა იმისა, რომ მძიმე დატვირთვა ხდება მოულოდნელად, ნელ-ნელა აწევის საწინააღმდეგოდ. ამ ტიპის ტესტი ასახავს რა ხდება, როდესაც ხდება თქვენი მომხმარებლების ან ვიზიტორების საშუალო რაოდენობის უეცარი მატება, ან როდესაც ხდება DDOS შეტევა თქვენს სისტემაზე.

დატენვის ტესტირება: ეს ტესტი განსხვავდება ზემოაღნიშნული დანარჩენებისგან. ის თქვენს სისტემას აყენებს ნორმალური დატვირთვის 80% (ან დაახლოებით) ქვეშ და ტოვებს მას მუშაობას ხანგრძლივი პერიოდის განმავლობაში, ვთქვათ 12-დან 14 საათამდე. ამ ტიპის ტესტი განსაზღვრავს რამდენად სანდოა სისტემა დროთა განმავლობაში.

ჩატვირთეთ თქვენი API-ების ტესტირება Locust-ით

დეველოპერებს აქვთ წვდომა სხვადასხვა ვარიანტზე მათი API-ების ჩატვირთვის შესამოწმებლად. დატვირთვის ტესტირების ზოგიერთი ჩვეულებრივი ინსტრუმენტია Gatling, JMeter და Locust. ამ სტატიაში ჩვენ ყურადღებას გავამახვილებთ Locust-ზე.

Locust არის პითონზე დაფუძნებული ღია კოდის ჩატვირთვის ტესტირების ინსტრუმენტი, რომელსაც იყენებენ ტოპ კომპანიები, როგორიცაა Google, Microsoft და Riot Games თავიანთი API-ების შესამოწმებლად. ამ სტატიაში ჩვენ გაჩვენებთ, თუ როგორ უნდა ჩატვირთოთ ტესტი API. 

ამ გაკვეთილისთვის მე შევქმნი მარტივ API-ს Flask-ით. შეგიძლიათ მომყვეთ ჩემთან ერთად ან უბრალოდ შექმნათ თქვენი API Node-ით, ან ნებისმიერი ფრეიმიკით, რომელიც თქვენთვის კომფორტულია.

მოთხოვნები

Python 3

დაყენება და ინსტალაცია

პირველ რიგში, თქვენ უნდა დააყენოთ ვირტუალური გარემო თქვენს კომპიუტერზე, რათა არ გააფუჭოთ თქვენი გლობალური Python გარემო. ამისათვის შეასრულეთ შემდეგი ბრძანებები. გაითვალისწინეთ, რომ ეს ბრძანებები ვრცელდება Windows ტერმინალზე.

$ mkdir პროექტი

$ cd /d გზა\ to\ პროექტი

$ python -m venv venv

$ venv\Scripts\activate

 

პირველ რიგში, ჩვენ შევქმენით ა პროექტი დირექტორია. შემდეგ ჩვენ შევცვალეთ ჩვენი მიმდინარე დირექტორია პროექტი. შემდეგ ჩვენ შევქმენით და გავააქტიურეთ ვირტუალური გარემო Python-ისთვის ამ დირექტორიაში. 

ახლა ჩვენ გადავალთ ინსტალაციაზე სინჯარისთვის(ჩვენ მას გამოვიყენებთ ჩატვირთვის შესამოწმებელი ბოლო წერტილების შესაქმნელად) და Locust თავად. 

 

Flask-ის დასაყენებლად გაუშვით. დარწმუნდით, რომ თქვენ ხართ პროექტი სადაც შექმენით ვირტუალური გარემო.

$ pip ინსტალაციის კოლბა

 

Locust-ის დასაყენებლად გაუშვით

$ pip install კალია

 

ამის დასრულების შემდეგ, ჩაწერეთ შემდეგი ბრძანებები. დარწმუნდით, რომ თქვენ ხართ პროექტი დირექტორია, როდესაც ამას აკეთებთ.

$ ასლი nul __init__.py

$ mkdir აპლიკაცია

$ ასლი nul app\app.py

$ დააკოპირეთ nul app\__init__.py

 

ეს ბრძანებები ქმნის რამდენიმე ფაილს, რომლებსაც გამოვიყენებთ ჩვენი ბოლო წერტილების შესაქმნელად Flask-ის გამოყენებით. თქვენ ასევე შეგიძლიათ შექმნათ ეს ფაილები თქვენი ფაილების მკვლევარის გამოყენებით. მაგრამ რა არის ამაში გართობა? როგორც კი ამას გააკეთებთ, დააკოპირეთ ქვემოთ მოცემული კოდი app.py

flask import-დან Flask, jsonify, მოთხოვნა

აპლიკაცია = კოლბა (__name__)

მანქანის_მოდელები = [

  { 'ბრენდი': 'ტესლა', 'მოდელი': 'მოდელი S' }

]

 

თვითმფრინავის_მოდელები = [

  { 'ბრენდი': 'ბოინგი', 'მოდელი': '747' }

]

 

@app.route ('/cars')

def get_cars():

  დაბრუნება jsonify (car_models)

@app.route ('/planes')

def get_planes():

  დაბრუნება jsonify (plane_models)

თუ __name__ == '__მთავარი__':

    app.run(debug=True)  

 

ზემოთ მოყვანილი კოდი შეიცავს მეთოდს მიიღეთ_მანქანები გამოიყენება ავტომობილების ბრენდებისა და მათი მოდელების სიის მისაღებად და მიიღეთ_თვითმფრინავები გამოიყენება თვითმფრინავების ბრენდებისა და მათი მოდელების სიის მისაღებად. ამ ბოლო წერტილის ტესტის ჩატვირთვისთვის საჭიროა app.py-ის გაშვება. ამისათვის გაუშვით ქვემოთ მოცემული ბრძანება.

$ python გზა\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')

 

ეს არის Locust-ის გამოყენების ძირითადი მაგალითი API-ის შესამოწმებლად. პირველ რიგში, ჩვენ ვქმნით კლასს მომხმარებლის ქცევა, რომელსაც შეიძლება მიენიჭოს ნებისმიერი შესაბამისი სახელი, მაგრამ უნდა გაგრძელდეს HttpUser. HttpUser არის კლასი, რომელიც ზრუნავს რამდენიმე ვირტუალური მომხმარებლის ინსტანციირებაზე, რათა შეასრულონ ჩვენ მიერ მითითებული დავალება მომხმარებლის ქცევა კლასში. 

დავალება მითითებულია მეთოდის გაფორმებით @ ამოცანა დეკორატორი. ჩვენ ასევე გვაქვს ფუნქცია ე.წ შორის() რომელიც საშუალებას გვაძლევს, განვსაზღვროთ წამების დიაპაზონი, რომელსაც უნდა დაველოდოთ შემდეგი დავალების შესრულებამდე. თქვენ ხედავთ, რომ ჩვენ ამ კოდში 5-დან 10 წამამდე დიაპაზონი მივანიჭეთ. 

კოდის გასაშვებად, დარწმუნდით, რომ კვლავ თქვენს ვირტუალურ გარემოში ხართ. თუ თქვენ მიერ შექმნილს იყენებს სერვერი, რომელიც ემსახურება API-ს, გახსენით ახალი ტერმინალი, შეცვალეთ თქვენი დირექტორია თქვენით პროექტი დირექტორია და გაააქტიურეთ თქვენ მიერ შექმნილი ვირტუალური გარემო. ვირტუალური გარემოს გააქტიურების ბრძანება შეგიძლიათ იხილოთ ზემოთ. ახლა შეიყვანეთ ქვემოთ მოცემული ბრძანება თქვენს ტერმინალში.

 

$ კალია -f locust_test.py

 

თქვენ მსგავსი რამ უნდა ნახოთ:

API დატვირთვის ტესტირება 2

ნაგულისხმევად, Locus-ის ვებ ინტერფეისი მდებარეობს http://localhost/8089. თუ ეწვიეთ საიტს, უნდა ნახოთ ასეთი ინტერფეისი:

API დატვირთვის ტესტირება 3

ინტერფეისიდან შეგვიძლია განვსაზღვროთ მომხმარებელთა რაოდენობა, ქვირითობის მაჩვენებელი (წამში შექმნილი მომხმარებლები) და მასპინძელი. თქვენ შეგიძლიათ მიიღოთ თქვენი ჰოსტის მისამართი ტერმინალის შემოწმებით, სადაც სერვერი მუშაობს. ჩვენს შემთხვევაში, ის არის პორტში 5000. როცა დააწკაპუნებთ დაიწყე ჭექა-ქუხილი, ქვემოთ მოგეჩვენებათ ინტერფეისი.

API დატვირთვის ტესტირება 4

ეს გიჩვენებთ სხვადასხვა სასარგებლო მეტრიკას, როგორიცაა წარუმატებელი მოთხოვნების რაოდენობა, მოთხოვნის საშუალო დრო, მოთხოვნის მინიმალური დრო, მოთხოვნები წამში და ა.შ. მას შემდეგ რაც კმაყოფილი იქნებით ნანახით, შეგიძლიათ დააჭიროთ გაჩერების ღილაკს. 


გარდა ამისა სტატისტიკა ჩანართი, არის ა დიაგრამები ჩანართი, რომელიც აჩვენებს მეტს ინფორმაცია გრაფიკის სახით, როგორც ქვემოთ მოცემული სურათი.

არსებობს ჯამური მოთხოვნები წამში გრაფიკზე, რეაგირების დროის გრაფიკი, მდე მომხმარებელთა რაოდენობის გრაფიკი, ყველა შეთქმულება დროის წინააღმდეგ. გრაფიკების გამოყენებით შეგიძლიათ განსაზღვროთ რამდენი მომხმარებელია მისაღები ფიქსირებული რეაგირების დროისთვის, ან შეგიძლიათ დააკვირდეთ თქვენს დიაგრამებს მუდმივი რეაგირების დროს, მიუხედავად მომხმარებელთა მზარდი რაოდენობისა და მსგავსი სხვა შეხედულებებისა. თუ გსურთ გააზიარეთ ეს სტატისტიკა სხვასთან ერთად, შეგიძლიათ ჩამოტვირთოთ ანგარიში ჩამოტვირთეთ მონაცემები Tab.

Დასკვა...

თქვენი API-ს ჩატვირთვის ტესტირება გადამწყვეტი აქტივობაა თქვენი განვითარების პროცესში, ამიტომ დარწმუნდით, რომ ის ჩართულია თქვენს დიზაინის ციკლში. სხვათა შორის, თქვენ ასევე შეგიძლიათ ჩაატაროთ დატვირთვის ტესტის სხვა ტიპები მომხმარებლების რაოდენობისა და ქვირითის სიჩქარის მნიშვნელობების შეცვლით. 

თუ გსურთ სპაიკის ტესტის გაკეთება, მიუთითეთ დიდი მნიშვნელობა (ვთქვათ 2000) მომხმარებელთა რაოდენობისთვის და შემდეგ თანაბრად დიდი მნიშვნელობა თქვენი ქვირითის სიჩქარისთვის (მაგალითად, 500). ეს ნიშნავს, რომ 4 წამში თქვენ გექნებათ 2000-ვე მომხმარებელი შექმნილი და წვდომა თქვენს საბოლოო წერტილებზე. სტრეს-ტესტი მსგავსი იქნება, მაგრამ ქვირითის სიჩქარის გაცილებით დაბალი მნიშვნელობით. იმის გასარკვევად, თუ რა შეგიძლიათ გააკეთოთ, შეამოწმეთ Locust დოკუმენტაცია

TOR ცენზურის გვერდის ავლით

ინტერნეტ ცენზურის გვერდის ავლით TOR-ით

ინტერნეტ ცენზურის გვერდის ავლით TOR-ით შესავალი მსოფლიოში, სადაც ინფორმაციაზე წვდომა სულ უფრო და უფრო რეგულირდება, Tor ქსელის მსგავსი ინსტრუმენტები გადამწყვეტი გახდა.

Წაიკითხე მეტი "
Kobold Letters: HTML-ზე დაფუძნებული ელ.ფოსტის ფიშინგ შეტევები

Kobold Letters: HTML-ზე დაფუძნებული ელ.ფოსტის ფიშინგ შეტევები

Kobold Letters: HTML-ზე დაფუძნებული ელ.ფოსტის ფიშინგის შეტევები 31 წლის 2024 მარტს, Luta Security-მ გამოაქვეყნა სტატია, რომელიც ნათელს ჰფენს ახალ დახვეწილ ფიშინგ ვექტორს, Kobold Letters.

Წაიკითხე მეტი "