ಲೋಕಸ್ಟ್‌ನೊಂದಿಗೆ API ಲೋಡ್ ಪರೀಕ್ಷೆ

ಲೋಕಸ್ಟ್‌ನೊಂದಿಗೆ API ಲೋಡ್ ಪರೀಕ್ಷೆ

ಲೋಕಸ್ಟ್‌ನೊಂದಿಗೆ API ಲೋಡ್ ಪರೀಕ್ಷೆ: ಪರಿಚಯ

ನೀವು ಬಹುಶಃ ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಮೊದಲು ಇದ್ದೀರಿ: ನೀವು ಏನನ್ನಾದರೂ ಮಾಡುವ ಕೋಡ್ ಅನ್ನು ಬರೆಯುತ್ತೀರಿ, ಉದಾಹರಣೆಗೆ ಎಂಡ್ ಪಾಯಿಂಟ್. ಪೋಸ್ಟ್‌ಮ್ಯಾನ್ ಅಥವಾ ನಿದ್ರಾಹೀನತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅಂತಿಮ ಬಿಂದುವನ್ನು ನೀವು ಪರೀಕ್ಷಿಸುತ್ತೀರಿ ಮತ್ತು ಎಲ್ಲವೂ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನೀವು ಕ್ಲೈಂಟ್-ಸೈಡ್ ಡೆವಲಪರ್‌ಗೆ ಅಂತಿಮ ಬಿಂದುವನ್ನು ರವಾನಿಸುತ್ತೀರಿ, ಅವರು ನಂತರ ಅದನ್ನು ಸೇವಿಸುತ್ತಾರೆ ಎಪಿಐ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ. ಆದರೆ ನಂತರ, ಬಳಕೆದಾರರು ಅಪ್ಲಿಕೇಶನ್ ಬಳಸುವಾಗ API ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

ಇದು ತುಂಬಾ ಕಿರಿಕಿರಿಗೊಳಿಸುವ ಪರಿಸ್ಥಿತಿಯಾಗಿರಬಹುದು, ವ್ಯವಹಾರಕ್ಕೆ ದುಬಾರಿ ಎಂದು ನಮೂದಿಸಬಾರದು. ಅದಕ್ಕಾಗಿಯೇ ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪರ್‌ಗಳು ಸಾಫ್ಟ್‌ವೇರ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ನಿರೀಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿವಿಧ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತಾರೆ. API ಗಳು ಭಿನ್ನವಾಗಿಲ್ಲ. ನಿಯೋಜನೆಯ ಮೊದಲು, ನೀವು ಕನಿಷ್ಟ ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಭದ್ರತಾ ಪರೀಕ್ಷೆಗಳನ್ನು ಮಾಡಬೇಕು.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರೀಕ್ಷೆಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕತೆ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಲೋಡ್ ಪರೀಕ್ಷೆಗಳಾಗಿ ವರ್ಗೀಕರಿಸಬಹುದು. ಕ್ರಿಯಾತ್ಮಕತೆಯ ಪರೀಕ್ಷೆಗಳನ್ನು ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಪೋಸ್ಟ್‌ಮ್ಯಾನ್ ಅಥವಾ ನಿದ್ರಾಹೀನತೆಗಾಗಿ ಬಳಸುತ್ತೀರಿ. ನೀವು ನಿರೀಕ್ಷಿಸಿದಂತೆ ನಿಮ್ಮ API ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಅವರು ಖಚಿತಪಡಿಸುತ್ತಾರೆ. ಲೋಡ್ ಪರೀಕ್ಷೆಗಳು, ಮತ್ತೊಂದೆಡೆ, ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆ ಮತ್ತು ಗರಿಷ್ಠ ಲೋಡ್‌ನೊಂದಿಗೆ ನಿಮ್ಮ API ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚು ಕಾಳಜಿ ವಹಿಸುತ್ತದೆ ಮತ್ತು ಈ ಲೇಖನದ ಬಗ್ಗೆ. ಲೋಡ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೋಡೋಣ.

API ಲೋಡ್ ಪರೀಕ್ಷೆ ಎಂದರೇನು?

API ಲೋಡ್ ಪರೀಕ್ಷೆಯು ಅಂತಿಮ ಬಿಂದುಗಳಲ್ಲಿ ಸಾಮಾನ್ಯ ಮತ್ತು ಗರಿಷ್ಠ ಲೋಡ್ ಅನ್ನು ಅನುಕರಿಸಲು ಡೆವಲಪರ್‌ಗಳು ಬಳಸುವ ಒಂದು ರೀತಿಯ ಪರೀಕ್ಷೆಯಾಗಿದೆ. ಈ ರೀತಿಯ ಪರೀಕ್ಷೆಯು ಡೆವಲಪರ್‌ಗಳಿಗೆ API ಅನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು ಅದರ ನೈಜ-ಪ್ರಪಂಚದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಸಿಸ್ಟಂನ ಗರಿಷ್ಟ ಕಾರ್ಯಾಚರಣಾ ಸಾಮರ್ಥ್ಯವನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಯಾವುದಾದರೂ ಇದ್ದರೆ ಅಡಚಣೆಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅವನತಿ. API ಲೋಡ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಚುವಲ್ ಬಳಕೆದಾರರನ್ನು ರಚಿಸುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ API ನ ಕಾರ್ಯವನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪರೀಕ್ಷಿಸಲು ಅವುಗಳನ್ನು ಬಳಸುತ್ತಾರೆ. 

API ಲೋಡ್ ಪರೀಕ್ಷೆಗಳು ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ, ಏಕಕಾಲೀನ ಬಳಕೆದಾರರು, ಥ್ರೋಪುಟ್ ದರಗಳು, ಸಂಪನ್ಮೂಲ ಬಳಕೆಯ ಮಟ್ಟಗಳು, ವೈಫಲ್ಯದ ನಡುವಿನ ಸರಾಸರಿ ಸಮಯ (MTBF), ವೈಫಲ್ಯಕ್ಕೆ ಸರಾಸರಿ ಸಮಯ (MTTF) ಮತ್ತು ಮುಂತಾದ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಅಳೆಯುತ್ತದೆ. API ಎಷ್ಟು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಈ ಎಲ್ಲಾ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ಲೋಡ್ ಪರೀಕ್ಷೆಯ ವಿಧಗಳು

ಹಲವಾರು ವಿಧದ ಲೋಡ್ ಪರೀಕ್ಷೆಗಳಿವೆ, ಪ್ರತಿಯೊಂದೂ ಅದರ ಬಳಕೆಯ ಪ್ರಕರಣಗಳೊಂದಿಗೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವನ್ನು ನೋಡೋಣ.

ಲೋಡ್ ಪರೀಕ್ಷೆ: ಇದು ಲೋಡ್ ಪರೀಕ್ಷೆಯ ಮೂಲ ರೂಪವಾಗಿದೆ. ಸಾಮಾನ್ಯ ಲೋಡ್ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಗರಿಷ್ಠ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಸಿಸ್ಟಮ್ (ಈ ಸಂದರ್ಭದಲ್ಲಿ, API) ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಒತ್ತಡ ಪರೀಕ್ಷೆ: ಭಾರೀ ಹೊರೆಯ ಅಡಿಯಲ್ಲಿ ಸಿಸ್ಟಮ್ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ವೈಫಲ್ಯದ ನಂತರ ಸಿಸ್ಟಮ್ ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತದೆಯೇ ಮತ್ತು ಅದನ್ನು ಮಾಡಲು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡುವುದು ಈ ಪರೀಕ್ಷೆಯ ಗುರಿಯಾಗಿದೆ. ಸಿಸ್ಟಮ್ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಮೀರುವವರೆಗೆ ಲೋಡ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿಧಾನವಾಗಿ ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ.

ಸ್ಪೈಕ್ ಪರೀಕ್ಷೆ: ಇದು ಒತ್ತಡದ ಪರೀಕ್ಷೆಗೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಹೋಲುತ್ತದೆ, ಭಾರವಾದ ಹೊರೆಯನ್ನು ಹಠಾತ್ತನೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ ಹೊರತುಪಡಿಸಿ, ನಿಧಾನವಾಗಿ ಅದನ್ನು ಹೆಚ್ಚಿಸುವುದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ. ನಿಮ್ಮ ಸರಾಸರಿ ಬಳಕೆದಾರರು ಅಥವಾ ಸಂದರ್ಶಕರ ಸಂಖ್ಯೆಯಲ್ಲಿ ಹಠಾತ್ ಸ್ಪೈಕ್ ಉಂಟಾದಾಗ ಅಥವಾ ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ DDOS ದಾಳಿಯಾದಾಗ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಈ ರೀತಿಯ ಪರೀಕ್ಷೆಯು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಸೋಕ್ ಪರೀಕ್ಷೆ: ಈ ಪರೀಕ್ಷೆಯು ಮೇಲಿನ ಇತರಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿದೆ. ಇದು ನಿಮ್ಮ ಸಿಸ್ಟಂ ಅನ್ನು ಸಾಮಾನ್ಯ ಲೋಡ್‌ನ 80% (ಅಥವಾ ಸುಮಾರು) ಅಡಿಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ ಮತ್ತು 12 ರಿಂದ 14 ಗಂಟೆಗಳ ಕಾಲ ಅದನ್ನು ದೀರ್ಘಾವಧಿಯವರೆಗೆ ಚಾಲನೆಯಲ್ಲಿರಿಸುತ್ತದೆ. ಈ ರೀತಿಯ ಪರೀಕ್ಷೆಯು ಕಾಲಾನಂತರದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಎಷ್ಟು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಲೋಕಸ್ಟ್‌ನೊಂದಿಗೆ ನಿಮ್ಮ API ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದನ್ನು ಲೋಡ್ ಮಾಡಿ

ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ API ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ವಿವಿಧ ಆಯ್ಕೆಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತಾರೆ. ಕೆಲವು ಸಾಮಾನ್ಯ ಲೋಡ್ ಟೆಸ್ಟಿಂಗ್ ಪರಿಕರಗಳೆಂದರೆ ಗ್ಯಾಟ್ಲಿಂಗ್, ಜೆಮೀಟರ್ ಮತ್ತು ಲೋಕಸ್ಟ್. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಮಿಡತೆಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ.

ಲೋಕಸ್ಟ್ ಎಂಬುದು ಪೈಥಾನ್-ಆಧಾರಿತ ಓಪನ್ ಸೋರ್ಸ್ ಲೋಡ್ ಟೆಸ್ಟಿಂಗ್ ಟೂಲ್ ಆಗಿದ್ದು, ತಮ್ಮ API ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು Google, Microsoft ಮತ್ತು Riot Games ನಂತಹ ಉನ್ನತ ಕಂಪನಿಗಳು ಬಳಸುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ, API ಪರೀಕ್ಷೆಯನ್ನು ಹೇಗೆ ಲೋಡ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ನಾವು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ. 

ಈ ಟ್ಯುಟೋರಿಯಲ್‌ಗಾಗಿ, ನಾನು ಫ್ಲಾಸ್ಕ್‌ನೊಂದಿಗೆ ಸರಳ API ಅನ್ನು ರಚಿಸುತ್ತೇನೆ. ನೀವು ನನ್ನೊಂದಿಗೆ ಅನುಸರಿಸಬಹುದು ಅಥವಾ ನೋಡ್‌ನೊಂದಿಗೆ ನಿಮ್ಮ API ಅನ್ನು ರಚಿಸಬಹುದು ಅಥವಾ ನೀವು ಆರಾಮದಾಯಕವಾದ ಯಾವುದೇ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ರಚಿಸಬಹುದು.

ಅವಶ್ಯಕತೆಗಳು

ಪೈಥಾನ್ 3

ಸ್ಥಾಪನೆ ಮತ್ತು ಸ್ಥಾಪನೆ

ಮೊದಲಿಗೆ, ನಿಮ್ಮ PC ಯಲ್ಲಿ ನೀವು ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ ಇದರಿಂದ ನಿಮ್ಮ ಜಾಗತಿಕ ಪೈಥಾನ್ ಪರಿಸರವನ್ನು ನೀವು ಗೊಂದಲಗೊಳಿಸುವುದಿಲ್ಲ. ಅದನ್ನು ಮಾಡಲು, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಿ. ಈ ಆಜ್ಞೆಗಳು ವಿಂಡೋಸ್ ಟರ್ಮಿನಲ್‌ಗೆ ಅನ್ವಯಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

$ mkdir ಯೋಜನೆ

$ cd /d ಮಾರ್ಗ\\\ ಯೋಜನೆಗೆ

$ ಪೈಥಾನ್ -m venv venv

$ venv\scripts\activate

 

ಮೊದಲಿಗೆ, ನಾವು ಎ ರಚಿಸಿದ್ದೇವೆ ಯೋಜನೆಯ ಡೈರೆಕ್ಟರಿ. ನಂತರ ನಾವು ನಮ್ಮ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಬದಲಾಯಿಸಿದ್ದೇವೆ ಯೋಜನೆಯ. ನಾವು ನಂತರ ಆ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಪೈಥಾನ್‌ಗಾಗಿ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದೇವೆ. 

ಈಗ, ನಾವು ಅನುಸ್ಥಾಪನೆಗೆ ಮುಂದುವರಿಯುತ್ತೇವೆ ಫ್ಲಾಸ್ಕ್(ಲೋಡ್ ಪರೀಕ್ಷೆಗೆ ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ರಚಿಸಲು ನಾವು ಇದನ್ನು ಬಳಸುತ್ತೇವೆ) ಮತ್ತು ಮಿಡತೆ ಸ್ವತಃ. 

 

ಫ್ಲಾಸ್ಕ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು, ರನ್ ಮಾಡಿ. ನೀವು ಒಳಗೆ ಇದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಯೋಜನೆಯ ಅಲ್ಲಿ ನೀವು ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿದ್ದೀರಿ.

$ ಪಿಪ್ ಇನ್ಸ್ಟಾಲ್ ಫ್ಲಾಸ್ಕ್

 

ಲೋಕಸ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು, ರನ್ ಮಾಡಿ

$ ಪಿಪ್ ಮಿಡತೆ ಸ್ಥಾಪಿಸಿ

 

ಅದು ಮುಗಿದ ನಂತರ, ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಟೈಪ್ ಮಾಡಿ. ನೀವು ನಿಮ್ಮಲ್ಲಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಯೋಜನೆಯ ನೀವು ಇದನ್ನು ಮಾಡಿದಾಗ ಡೈರೆಕ್ಟರಿ.

$ ನಕಲಿಸಿ nul __init__.py

$ mkdir ಅಪ್ಲಿಕೇಶನ್

$ ನಕಲಿಸಿ nul ಅಪ್ಲಿಕೇಶನ್\app.py

$ nul ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಕಲಿಸಿ\__init__.py

 

ಈ ಆಜ್ಞೆಗಳು ಕೆಲವು ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಅದನ್ನು ನಾವು ಫ್ಲಾಸ್ಕ್ ಬಳಸಿ ನಮ್ಮ ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ರಚಿಸಲು ಬಳಸುತ್ತೇವೆ. ನಿಮ್ಮ ಫೈಲ್ ಎಕ್ಸ್‌ಪ್ಲೋರರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಈ ಫೈಲ್‌ಗಳನ್ನು ಸಹ ರಚಿಸಬಹುದು. ಆದರೆ ಅದರಲ್ಲಿ ಮಜಾ ಏನು? ಒಮ್ಮೆ ನೀವು ಅದನ್ನು ಮಾಡಿದ ನಂತರ, ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ app.py

ಫ್ಲಾಸ್ಕ್ ಆಮದು ಫ್ಲಾಸ್ಕ್, jsonify, ವಿನಂತಿಯಿಂದ

ಅಪ್ಲಿಕೇಶನ್ = ಫ್ಲಾಸ್ಕ್ (__ಹೆಸರು__)

ಕಾರ್_ಮಾಡೆಲ್ಸ್ = [

  { 'ಬ್ರಾಂಡ್': 'ಟೆಸ್ಲಾ', 'ಮಾದರಿ': 'ಮಾಡೆಲ್ ಎಸ್' }

]

 

ವಿಮಾನ_ಮಾದರಿಗಳು = [

  { 'ಬ್ರಾಂಡ್': 'ಬೋಯಿಂಗ್', 'ಮಾದರಿ': '747' }

]

 

@app.route('/cars')

ಡೆಫ್ ಗೆಟ್_ಕಾರ್ಸ್():

  ರಿಟರ್ನ್ jsonify(car_models)

@app.route('/ಪ್ಲೇನ್ಸ್')

ಡೆಫ್ ಗೆಟ್_ಪ್ಲೇನ್ಸ್():

  ರಿಟರ್ನ್ jsonify(ಪ್ಲೇನ್_ಮಾಡೆಲ್ಸ್)

__ಹೆಸರು__ == '__ಮುಖ್ಯ__':

    app.run(ಡೀಬಗ್=True)  

 

ಮೇಲಿನ ಕೋಡ್ ಒಂದು ವಿಧಾನವನ್ನು ಒಳಗೊಂಡಿದೆ ಪಡೆಯಿರಿ_ಕಾರುಗಳು ಕಾರ್ ಬ್ರಾಂಡ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಮಾದರಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಪಡೆಯಿರಿ_ವಿಮಾನಗಳು ಪ್ಲೇನ್ ಬ್ರಾಂಡ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಮಾದರಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ನಮಗೆ ಈ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಲೋಡ್ ಮಾಡಲು, ನಾವು app.py ಅನ್ನು ರನ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಅದನ್ನು ಮಾಡಲು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ.

$ ಪೈಥಾನ್ ಮಾರ್ಗ\to\app.py

ಒಮ್ಮೆ ನೀವು ಅದನ್ನು ಚಲಾಯಿಸಿದರೆ, ನೀವು ಈ ರೀತಿಯದನ್ನು ನೋಡಬೇಕು:

API ಲೋಡ್ ಪರೀಕ್ಷೆ 1

ನೀವು ಟರ್ಮಿನಲ್‌ನಿಂದ URL ಅನ್ನು ನಕಲಿಸಿದರೆ ಮತ್ತು ಟೈಪ್ ಮಾಡಿ ಕಾರುಗಳು or ವಿಮಾನಗಳು / ನಂತರ, ನೀವು ಅಲ್ಲಿ ಡೇಟಾವನ್ನು ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಬ್ರೌಸರ್‌ನೊಂದಿಗೆ ಅಲ್ಲ, ಮಿಡತೆಯೊಂದಿಗೆ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಪರೀಕ್ಷಿಸುವುದು ನಮ್ಮ ಗುರಿಯಾಗಿದೆ. ಹಾಗಾಗಿ ಅದನ್ನು ಮಾಡೋಣ. ನಿಮ್ಮ ಮೂಲದಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಯೋಜನೆಯ ಡೈರೆಕ್ಟರಿ.

 

$ ನಕಲಿಸಿ nul locust_test.py

 

ಇದು ನಿಮ್ಮ ರೂಟ್‌ನಲ್ಲಿ 'locust_test.py' ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಯೋಜನೆಯ ಡೈರೆಕ್ಟರಿ. ಒಮ್ಮೆ ನೀವು ಅದನ್ನು ಮಾಡಿದ ನಂತರ, ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್‌ನಲ್ಲಿ ಅಂಟಿಸಿ. ನಾವು ಅದನ್ನು ಶೀಘ್ರದಲ್ಲೇ ವಿವರಿಸುತ್ತೇವೆ.

 

ಆಮದು ಸಮಯ

ಮಿಡತೆ ಆಮದು HttpUser ನಿಂದ, ಕಾರ್ಯ, ನಡುವೆ

 

ವರ್ಗ ಬಳಕೆದಾರ ನಡವಳಿಕೆ(HttpUser):

    ನಿರೀಕ್ಷಿಸಿ_ಸಮಯ = ನಡುವೆ (5, 10)

 

    @ಕಾರ್ಯ

    ಡೆಫ್ ಗೆಟ್_ಕಾರ್ಸ್(ಸ್ವಯಂ):

        self.client.get('/cars')

    

    @ಕಾರ್ಯ

    ಡೆಫ್ ಗೆಟ್_ಪ್ಲೇನ್ಸ್(ಸ್ವಯಂ):

        self.client.get('/ಪ್ಲೇನ್ಸ್')

 

API ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಲೋಕಸ್ಟ್ ಅನ್ನು ಬಳಸುವ ಒಂದು ಮೂಲ ಉದಾಹರಣೆಯಾಗಿದೆ. ಮೊದಲಿಗೆ, ನಾವು ವರ್ಗವನ್ನು ರಚಿಸುತ್ತೇವೆ ಬಳಕೆದಾರರ ನಡವಳಿಕೆ, ಇದು ಯಾವುದೇ ಸೂಕ್ತವಾದ ಹೆಸರನ್ನು ನೀಡಬಹುದು ಆದರೆ ವಿಸ್ತರಿಸಬೇಕು HttpUser. HttpUser ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾರ್ಯಗಳನ್ನು ಕೈಗೊಳ್ಳಲು ಬಹು ವರ್ಚುವಲ್ ಬಳಕೆದಾರರನ್ನು ತ್ವರಿತಗೊಳಿಸುವ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸುವ ವರ್ಗವಾಗಿದೆ ಬಳಕೆದಾರರ ನಡವಳಿಕೆ ವರ್ಗ. 

ಒಂದು ವಿಧಾನವನ್ನು ಅಲಂಕರಿಸುವ ಮೂಲಕ ಕಾರ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ @ಕಾರ್ಯ ಅಲಂಕಾರಕಾರ. ಎಂಬ ಕಾರ್ಯವನ್ನೂ ನಾವು ಹೊಂದಿದ್ದೇವೆ ನಡುವೆ () ಮುಂದಿನ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಕಾಯಲು ಸೆಕೆಂಡುಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ನಾವು 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 ಪರಿಚಯದೊಂದಿಗೆ ಇಂಟರ್ನೆಟ್ ಸೆನ್ಸಾರ್‌ಶಿಪ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡುವುದು ಮಾಹಿತಿಯ ಪ್ರವೇಶವನ್ನು ಹೆಚ್ಚು ನಿಯಂತ್ರಿಸುವ ಜಗತ್ತಿನಲ್ಲಿ, ಟಾರ್ ನೆಟ್‌ವರ್ಕ್‌ನಂತಹ ಸಾಧನಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ

ಮತ್ತಷ್ಟು ಓದು "
ಕೋಬೋಲ್ಡ್ ಲೆಟರ್ಸ್: HTML-ಆಧಾರಿತ ಇಮೇಲ್ ಫಿಶಿಂಗ್ ದಾಳಿಗಳು

ಕೋಬೋಲ್ಡ್ ಲೆಟರ್ಸ್: HTML-ಆಧಾರಿತ ಇಮೇಲ್ ಫಿಶಿಂಗ್ ದಾಳಿಗಳು

ಕೋಬೋಲ್ಡ್ ಲೆಟರ್‌ಗಳು: ಎಚ್‌ಟಿಎಮ್‌ಎಲ್-ಆಧಾರಿತ ಇಮೇಲ್ ಫಿಶಿಂಗ್ ದಾಳಿಗಳು ಮಾರ್ಚ್ 31, 2024 ರಂದು, ಲೂಟಾ ಸೆಕ್ಯುರಿಟಿ ಹೊಸ ಅತ್ಯಾಧುನಿಕ ಫಿಶಿಂಗ್ ವೆಕ್ಟರ್, ಕೊಬೋಲ್ಡ್ ಲೆಟರ್‌ಗಳ ಮೇಲೆ ಬೆಳಕು ಚೆಲ್ಲುವ ಲೇಖನವನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದೆ.

ಮತ್ತಷ್ಟು ಓದು "