การทดสอบการโหลด API ด้วย Locust

การทดสอบการโหลด API ด้วย Locust

การทดสอบการโหลด API ด้วย Locust: บทนำ

คุณอาจเคยอยู่ในสถานการณ์นี้มาก่อน: คุณเขียนโค้ดที่ทำบางสิ่ง ตัวอย่างเช่น จุดสิ้นสุด คุณทดสอบจุดสิ้นสุดของคุณโดยใช้บุรุษไปรษณีย์หรือ Insomnia และทุกอย่างทำงานได้ดี คุณส่งต่อจุดสิ้นสุดไปยังผู้พัฒนาฝั่งไคลเอนต์ ซึ่งจากนั้นจะใช้ API และปรับใช้แอปพลิเคชัน แต่แล้ว API ก็ล้มเหลวเมื่อผู้ใช้ใช้แอป

นี่อาจเป็นสถานการณ์ที่น่ารำคาญสุดๆ ไม่ต้องพูดถึงเรื่องค่าใช้จ่ายสำหรับธุรกิจ นั่นเป็นเหตุผลที่นักพัฒนาซอฟต์แวร์ทำการทดสอบระบบซอฟต์แวร์ที่หลากหลายเพื่อให้มั่นใจว่าทำงานได้ตามที่คาดไว้ API ไม่แตกต่างกัน ก่อนการปรับใช้ คุณควรทำการทดสอบประสิทธิภาพและทดสอบความปลอดภัยเป็นอย่างน้อย

การทดสอบประสิทธิภาพสามารถแบ่งออกเป็นการทดสอบการทำงานและการทดสอบโหลด การทดสอบการทำงานเป็นสิ่งที่คุณมักจะใช้บุรุษไปรษณีย์หรือโรคนอนไม่หลับ พวกเขาทำให้แน่ใจว่า API ของคุณทำงานตามที่คุณคาดหวัง ในทางกลับกัน การทดสอบโหลดจะเกี่ยวข้องกับการทำงานของ API ของคุณกับการใช้งานจริงและการโหลดสูงสุด และนั่นคือสิ่งที่บทความนี้พูดถึง ลองดูที่การทดสอบการโหลดโดยละเอียด

การทดสอบโหลด API คืออะไร?

การทดสอบการโหลด API เป็นประเภทของการทดสอบที่นักพัฒนาใช้เพื่อจำลองการโหลดปกติและสูงสุดบนเอ็นด์พอยท์ การทดสอบประเภทนี้ช่วยให้นักพัฒนาสามารถประเมินประสิทธิภาพของ API ในโลกแห่งความเป็นจริงก่อนที่จะนำไปใช้จริง ช่วยให้พวกเขาระบุความสามารถในการทำงานสูงสุดของระบบ ปัญหาคอขวด (ถ้ามี) และการลดลงของประสิทธิภาพ การทดสอบโหลด API มักจะทำโดยการสร้างผู้ใช้เสมือน จากนั้นใช้พวกเขาเพื่อทดสอบการทำงานของ API พร้อมกัน 

การทดสอบโหลด API จะวัดเมตริกต่างๆ เช่น เวลาตอบสนอง ผู้ใช้พร้อมกัน อัตราปริมาณงาน ระดับการใช้ทรัพยากร เวลาเฉลี่ยระหว่างความล้มเหลว (MTBF) เวลาเฉลี่ยที่จะล้มเหลว (MTTF) และอื่นๆ เมตริกทั้งหมดเหล่านี้สามารถใช้เพื่อพิจารณาว่า API ทำงานได้ดีเพียงใด

ประเภทของการทดสอบโหลด

การทดสอบโหลดมีหลายประเภท แต่ละประเภทมีกรณีการใช้งาน ลองมาดูบางส่วนของพวกเขา

โหลดการทดสอบ: นี่คือรูปแบบพื้นฐานของการทดสอบโหลด ใช้เพื่อประเมินประสิทธิภาพของระบบ (ในกรณีนี้คือ API) ภายใต้โหลดปกติและโหลดสูงสุดที่คาดไว้

การทดสอบความเครียด: ใช้เพื่อประเมินประสิทธิภาพของระบบภายใต้โหลดที่หนักมาก เป้าหมายของการทดสอบนี้คือเพื่อดูว่าระบบกู้คืนหลังจากล้มเหลวหรือไม่ และใช้เวลานานเท่าใดในการดำเนินการดังกล่าว โหลดมักจะเพิ่มขึ้นอย่างช้า ๆ จนเกินความสามารถของระบบ

การทดสอบสไปค์: สิ่งนี้คล้ายกับการทดสอบความเครียดเล็กน้อย ยกเว้นว่าโหลดหนักจะถูกนำไปใช้อย่างกะทันหัน ซึ่งต่างจากการเพิ่มขึ้นอย่างช้าๆ การทดสอบประเภทนี้แสดงถึงสิ่งที่เกิดขึ้นเมื่อมีจำนวนผู้ใช้หรือผู้เยี่ยมชมโดยเฉลี่ยเพิ่มขึ้นอย่างกะทันหัน หรือเมื่อมีการโจมตี DDOS บนระบบของคุณ

การทดสอบการแช่: การทดสอบนี้ไม่เหมือนกับการทดสอบอื่นๆ ข้างต้น มันทำให้ระบบของคุณต่ำกว่า 80% (หรือประมาณนั้น) ของโหลดปกติ และปล่อยให้มันทำงานเป็นเวลานาน เช่น 12 ถึง 14 ชั่วโมง การทดสอบประเภทนี้จะกำหนดความน่าเชื่อถือของระบบเมื่อเวลาผ่านไป

โหลดการทดสอบ API ของคุณด้วย Locust

นักพัฒนาสามารถเข้าถึงตัวเลือกที่หลากหลายสำหรับการทดสอบโหลด API ของพวกเขา เครื่องมือทดสอบโหลดทั่วไป ได้แก่ Gatling, JMeter และ Locust เราจะมุ่งเน้นไปที่ตั๊กแตนในบทความนี้

Locust เป็นเครื่องมือทดสอบโหลดแบบโอเพ่นซอร์สที่ใช้ไพธอนซึ่งใช้โดยบริษัทชั้นนำ เช่น Google, Microsoft และ Riot Games เพื่อทดสอบ API ของพวกเขา ในบทความนี้ เราจะสาธิตวิธีโหลดทดสอบ API 

สำหรับบทช่วยสอนนี้ ฉันจะสร้าง API อย่างง่ายด้วย Flask คุณสามารถทำตามฉันหรือเพียงแค่สร้าง API ของคุณด้วย Node หรือเฟรมเวิร์กใดก็ตามที่คุณพอใจ

ความต้องการ

งูหลาม 3

การติดตั้ง & การติดตั้ง

ขั้นแรก คุณต้องตั้งค่าสภาพแวดล้อมเสมือนจริงบนพีซีของคุณ เพื่อไม่ให้สภาพแวดล้อม Python ส่วนกลางของคุณยุ่งเหยิง โดยเรียกใช้คำสั่งต่อไปนี้ โปรดทราบว่าคำสั่งเหล่านี้ใช้กับเทอร์มินัล Windows

โครงการ $ mkdir

$ cd /d เส้นทาง\to\project

$ หลาม -m venv venv

$ venv\สคริปต์\เปิดใช้งาน

 

อันดับแรก เราได้สร้าง โครงการ ไดเรกทอรี จากนั้นเราเปลี่ยนไดเร็กทอรีปัจจุบันเป็น โครงการ. จากนั้นเราสร้างและเปิดใช้งานสภาพแวดล้อมเสมือนจริงสำหรับ Python ภายในไดเร็กทอรีนั้น 

ตอนนี้เราจะไปยังการติดตั้ง ขวด(เราจะใช้เพื่อสร้างจุดสิ้นสุดที่จะทดสอบโหลด) และ ปาทังกา ตัวเอง 

 

ในการติดตั้ง Flask ให้เรียกใช้ ตรวจสอบให้แน่ใจว่าคุณอยู่ใน โครงการ ที่คุณสร้างสภาพแวดล้อมเสมือนจริง

$ pip ติดตั้งขวด

 

ในการติดตั้ง Locust ให้เรียกใช้

$ pip ติดตั้งตั๊กแตน

 

เมื่อเสร็จแล้วให้พิมพ์คำสั่งต่อไปนี้ ตรวจสอบให้แน่ใจว่าคุณอยู่ใน โครงการ ไดเร็กทอรีเมื่อคุณทำเช่นนี้

$ คัดลอก nul __init__.py

แอพ $ mkdir

$ คัดลอก nul app\app.py

$ คัดลอกแอป nul\__init__.py

 

คำสั่งนี้สร้างไฟล์บางไฟล์ที่เราจะใช้เพื่อสร้างจุดสิ้นสุดของเราโดยใช้ Flask คุณยังสามารถสร้างไฟล์เหล่านี้โดยใช้ตัวสำรวจไฟล์ได้อีกด้วย แต่ความสนุกคืออะไร? เมื่อคุณทำเสร็จแล้ว ให้คัดลอกโค้ดด้านล่างลงไป app.py

จากขวดนำเข้าขวด, jsonify, คำขอ

แอพ = ขวด (__name__)

รถ_รุ่น = [

  { 'ยี่ห้อ': 'Tesla', 'รุ่น': 'รุ่น S' }

]

 

เครื่องบิน_รุ่น = [

  { 'ยี่ห้อ': 'โบอิ้ง', 'รุ่น': '747' }

]

 

@app.route('/รถยนต์')

def get_cars ():

  ส่งคืน jsonify (car_models)

@app.route('/เครื่องบิน')

def get_planes ():

  ส่งคืน jsonify (plane_models)

ถ้า __name__ == '__main__':

    app.run(ดีบัก=จริง)  

 

รหัสข้างต้นมีวิธีการ get_cars ใช้เพื่อดูรายชื่อยี่ห้อและรุ่นของรถยนต์ และ get_planes ใช้เพื่อรับรายชื่อยี่ห้อและรุ่นของเครื่องบิน เพื่อให้เราโหลดทดสอบตำแหน่งข้อมูลนี้ได้ เราต้องเรียกใช้ app.py ในการทำเช่นนั้นให้รันคำสั่งด้านล่าง

$ เส้นทางหลาม\to\app.py

เมื่อคุณเรียกใช้คุณควรเห็นสิ่งนี้:

การทดสอบการโหลด API 1

หากคุณคัดลอก URL จากเทอร์มินัลแล้วพิมพ์ รถยนต์ or เครื่องบิน หลังจาก / คุณควรจะเห็นข้อมูลที่นั่น อย่างไรก็ตาม เป้าหมายของเราคือการทดสอบจุดสิ้นสุดด้วยตั๊กแตน ไม่ใช่กับเบราว์เซอร์ มาทำกันเถอะ เรียกใช้คำสั่งต่อไปนี้ในรูทของคุณ โครงการ ไดเรกทอรี

 

$ คัดลอก nul locust_test.py

 

สิ่งนี้จะสร้างไฟล์ 'locust_test.py' ในรูทของคุณ โครงการ ไดเรกทอรี เมื่อเสร็จแล้ว ให้เปิดไฟล์และวางโค้ดด้านล่าง เราจะอธิบายในไม่ช้า

 

เวลานำเข้า

จากตั๊กแตนนำเข้า HttpUser, งาน, ระหว่าง

 

คลาส UserBehavior (HttpUser):

    wait_time = ระหว่าง (5, 10)

 

    @งาน

    def get_cars (ตัวเอง):

        self.client.get('/รถยนต์')

    

    @งาน

    def get_planes (ตัวเอง):

        self.client.get('/เครื่องบิน')

 

นี่เป็นตัวอย่างพื้นฐานของการใช้ Locust เพื่อโหลดทดสอบ API ขั้นแรก เราสร้างชั้นเรียน พฤติกรรมผู้ใช้ซึ่งสามารถให้ชื่อที่เหมาะสมใด ๆ แต่ต้องขยาย ผู้ใช้ Http ผู้ใช้ Http เป็นคลาสที่ดูแลการสร้างอินสแตนซ์ให้กับผู้ใช้เสมือนหลายคนเพื่อดำเนินงานที่เราระบุไว้ใน พฤติกรรมผู้ใช้ ชั้นเรียน 

มีการระบุงานโดยการตกแต่งเมธอดด้วย @งาน มัณฑนากร. เรายังมีฟังก์ชั่นที่เรียกว่า ระหว่าง() ที่ช่วยให้เราสามารถระบุช่วงของวินาทีที่จะรอก่อนที่จะดำเนินการงานต่อไป คุณจะเห็นว่าเราได้กำหนดช่วง 5 ถึง 10 วินาทีสำหรับสิ่งนั้นในรหัสของเรา 

ในการรันโค้ด ตรวจสอบให้แน่ใจว่าคุณยังอยู่ในสภาพแวดล้อมเสมือนของคุณ ถ้าสิ่งที่คุณสร้างถูกใช้โดยเซิร์ฟเวอร์ที่ให้บริการ API ให้เปิดเทอร์มินัลใหม่ เปลี่ยนไดเร็กทอรีของคุณเป็นของคุณ โครงการ ไดเร็กทอรีและเปิดใช้งานสภาพแวดล้อมเสมือนที่คุณสร้างขึ้น คุณสามารถค้นหาคำสั่งสำหรับการเปิดใช้งานสภาพแวดล้อมเสมือนจริงด้านบน ตอนนี้ ป้อนคำสั่งด้านล่างในเทอร์มินัลของคุณ

 

$ ตั๊กแตน -f locust_test.py

 

คุณควรเห็นสิ่งต่างๆดังนี้:

การทดสอบการโหลด API 2

ตามค่าเริ่มต้น เว็บอินเตอร์เฟสของตั๊กแตนจะอยู่ที่ http://localhost/8089 หากคุณเยี่ยมชมเว็บไซต์ คุณควรเห็นอินเทอร์เฟซดังนี้:

การทดสอบการโหลด API 3

จากอินเทอร์เฟซ เราสามารถระบุจำนวนผู้ใช้ อัตราการเกิด (ผู้ใช้ที่สร้างต่อวินาที) และโฮสต์ คุณสามารถรับที่อยู่ของโฮสต์ได้โดยการตรวจสอบเทอร์มินัลที่เซิร์ฟเวอร์ทำงานอยู่ ในกรณีของเราอยู่ที่พอร์ต 5000 เมื่อคุณคลิกที่ เริ่มจับกลุ่ม คุณจะเห็นอินเทอร์เฟซด้านล่าง

การทดสอบการโหลด API 4

ข้อมูลนี้จะแสดงเมตริกที่มีประโยชน์ต่างๆ เช่น จำนวนคำขอที่ล้มเหลว เวลาเฉลี่ยสำหรับคำขอ เวลาขั้นต่ำสำหรับคำขอ คำขอต่อวินาที และอื่นๆ เมื่อคุณพอใจกับสิ่งที่คุณเห็น คุณสามารถคลิกที่ปุ่มหยุด 


นอกจากนี้ สถิติ แท็บมี ชาร์ต แท็บที่แสดงเพิ่มเติม ข้อมูล ในรูปแบบกราฟดังภาพด้านล่าง

มี คำขอทั้งหมดต่อวินาทีกราฟ, กราฟเวลาตอบสนอง และ กราฟจำนวนผู้ใช้วางแผนทั้งหมดกับเวลา เมื่อใช้กราฟ คุณสามารถกำหนดจำนวนผู้ใช้ที่ยอมรับได้สำหรับเวลาตอบสนองที่แน่นอน หรือคุณสามารถสังเกตแผนภูมิของคุณสำหรับเวลาตอบสนองที่คงที่แม้จะมีจำนวนผู้ใช้เพิ่มขึ้นก็ตาม และข้อมูลเชิงลึกอื่นๆ เช่นนั้น หากคุณต้องการแบ่งปันสิ่งเหล่านี้ สถิติ กับบุคคลอื่น คุณสามารถดาวน์โหลดรายงานได้จาก ดาวน์โหลดข้อมูล แถบ

สรุป...

การทดสอบการโหลด API ของคุณเป็นกิจกรรมที่สำคัญในกระบวนการพัฒนาของคุณ ดังนั้นตรวจสอบให้แน่ใจว่ามันรวมอยู่ในวงจรการออกแบบของคุณ นอกจากนี้ คุณยังดำเนินการทดสอบโหลดประเภทอื่นๆ ได้โดยเปลี่ยนค่าตามจำนวนผู้ใช้และอัตราการเกิด 

หากคุณต้องการทำการทดสอบแบบสไปค์ ให้ระบุค่าจำนวนมาก (เช่น 2000) สำหรับจำนวนผู้ใช้ จากนั้นระบุค่าที่มากเท่าๆ กันสำหรับอัตราการเกิดของคุณ (เช่น 500) ซึ่งหมายความว่าใน 4 วินาที คุณจะมีผู้ใช้ทั้งหมด 2000 รายที่สร้างและเข้าถึงจุดสิ้นสุดของคุณ การทดสอบความเครียดจะคล้ายกัน แต่มีค่าอัตราการวางไข่ที่ต่ำกว่ามาก เพื่อค้นหาสิ่งที่คุณทำได้ ลองดูตั๊กแตน เอกสาร

ผ่านการเซ็นเซอร์ TOR

ข้ามการเซ็นเซอร์อินเทอร์เน็ตด้วย TOR

หลีกเลี่ยงการเซ็นเซอร์อินเทอร์เน็ตด้วย TOR Introduction ในโลกที่การเข้าถึงข้อมูลได้รับการควบคุมมากขึ้น เครื่องมือเช่นเครือข่าย Tor ได้กลายเป็นสิ่งสำคัญสำหรับ

Read More »
Kobold Letters: การโจมตีแบบฟิชชิ่งทางอีเมลที่ใช้ HTML

Kobold Letters: การโจมตีแบบฟิชชิ่งทางอีเมลที่ใช้ HTML

Kobold Letters: การโจมตีแบบฟิชชิ่งทางอีเมลแบบ HTML เมื่อวันที่ 31 มีนาคม 2024 Luta Security ได้เผยแพร่บทความที่ให้ความกระจ่างเกี่ยวกับเวกเตอร์ฟิชชิ่งที่ซับซ้อนตัวใหม่ Kobold Letters

Read More »