ਟਿੱਡੀ ਦੇ ਨਾਲ API ਲੋਡ ਟੈਸਟਿੰਗ
ਟਿੱਡੀ ਦੇ ਨਾਲ API ਲੋਡ ਟੈਸਟਿੰਗ: ਜਾਣ-ਪਛਾਣ
ਤੁਸੀਂ ਸ਼ਾਇਦ ਪਹਿਲਾਂ ਵੀ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਰਹੇ ਹੋ: ਤੁਸੀਂ ਕੋਡ ਲਿਖਦੇ ਹੋ ਜੋ ਕੁਝ ਕਰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਅੰਤਮ ਬਿੰਦੂ। ਤੁਸੀਂ ਪੋਸਟਮੈਨ ਜਾਂ ਇਨਸੌਮਨੀਆ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਅੰਤਮ ਬਿੰਦੂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹੋ, ਅਤੇ ਸਭ ਕੁਝ ਠੀਕ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਅੰਤਮ ਬਿੰਦੂ ਨੂੰ ਕਲਾਇੰਟ-ਸਾਈਡ ਡਿਵੈਲਪਰ ਨੂੰ ਦਿੰਦੇ ਹੋ, ਜੋ ਫਿਰ ਖਪਤ ਕਰਦਾ ਹੈ API ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਦਾ ਹੈ। ਪਰ ਫਿਰ, ਜਦੋਂ ਉਪਭੋਗਤਾ ਐਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਤਾਂ API ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ.
ਇਹ ਇੱਕ ਬਹੁਤ ਤੰਗ ਕਰਨ ਵਾਲੀ ਸਥਿਤੀ ਹੋ ਸਕਦੀ ਹੈ, ਕਿਸੇ ਕਾਰੋਬਾਰ ਲਈ ਮਹਿੰਗੇ ਦਾ ਜ਼ਿਕਰ ਨਾ ਕਰਨਾ. ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਸਾਫਟਵੇਅਰ ਸਿਸਟਮਾਂ 'ਤੇ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਟੈਸਟ ਕਰਦੇ ਹਨ ਕਿ ਉਹ ਉਮੀਦ ਮੁਤਾਬਕ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੇ ਹਨ। API ਵੱਖਰਾ ਨਹੀਂ ਹਨ। ਤੈਨਾਤੀ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਪ੍ਰਦਰਸ਼ਨ ਟੈਸਟ ਅਤੇ ਸੁਰੱਖਿਆ ਟੈਸਟ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ।
ਪ੍ਰਦਰਸ਼ਨ ਟੈਸਟਾਂ ਨੂੰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਟੈਸਟਾਂ ਅਤੇ ਲੋਡ ਟੈਸਟਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਕਾਰਜਸ਼ੀਲਤਾ ਟੈਸਟ ਉਹ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਲਈ ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਪੋਸਟਮੈਨ ਜਾਂ ਇਨਸੌਮਨੀਆ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ। ਉਹ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਨ ਕਿ ਤੁਹਾਡੇ API ਫੰਕਸ਼ਨ ਜਿਵੇਂ ਤੁਸੀਂ ਉਮੀਦ ਕਰਦੇ ਹੋ. ਲੋਡ ਟੈਸਟ, ਦੂਜੇ ਪਾਸੇ, ਇਸ ਬਾਰੇ ਵਧੇਰੇ ਚਿੰਤਤ ਹਨ ਕਿ ਤੁਹਾਡੀ API ਅਸਲ-ਸੰਸਾਰ ਵਰਤੋਂ ਅਤੇ ਪੀਕ ਲੋਡ ਦੇ ਨਾਲ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਹ ਉਹੀ ਹੈ ਜਿਸ ਬਾਰੇ ਇਹ ਲੇਖ ਹੈ। ਆਉ ਲੋਡ ਟੈਸਟਾਂ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ.
API ਲੋਡ ਟੈਸਟਿੰਗ ਕੀ ਹੈ?
ਏਪੀਆਈ ਲੋਡ ਟੈਸਟਿੰਗ ਇੱਕ ਕਿਸਮ ਦੀ ਜਾਂਚ ਹੈ ਜੋ ਡਿਵੈਲਪਰ ਅੰਤਮ ਬਿੰਦੂਆਂ 'ਤੇ ਸਧਾਰਣ ਅਤੇ ਪੀਕ ਲੋਡ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਵਰਤਦੇ ਹਨ। ਇਸ ਕਿਸਮ ਦੀ ਜਾਂਚ ਡਿਵੈਲਪਰਾਂ ਨੂੰ API ਦੇ ਤੈਨਾਤ ਕੀਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਦੀ ਅਸਲ-ਸੰਸਾਰ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਦਿੰਦੀ ਹੈ। ਇਹ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਸਿਸਟਮ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਚਾਲਨ ਸਮਰੱਥਾ, ਰੁਕਾਵਟਾਂ ਜੇ ਕੋਈ ਹੋਵੇ, ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗਿਰਾਵਟ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। API ਲੋਡ ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ ਵਰਚੁਅਲ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਬਣਾ ਕੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਨਾਲ API ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਰਦੇ ਹਨ।
API ਲੋਡ ਟੈਸਟ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਮਾਪਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਜਵਾਬ ਸਮਾਂ, ਸਮਕਾਲੀ ਉਪਭੋਗਤਾ, ਥ੍ਰੁਪੁੱਟ ਦਰਾਂ, ਸਰੋਤ ਉਪਯੋਗਤਾ ਪੱਧਰ, ਅਸਫਲਤਾ ਦੇ ਵਿਚਕਾਰ ਦਾ ਸਮਾਂ (MTBF), ਅਸਫਲਤਾ ਦਾ ਔਸਤ ਸਮਾਂ (MTTF), ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ। ਇਹ ਸਾਰੇ ਮੈਟ੍ਰਿਕਸ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ ਕਿ API ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।
ਲੋਡ ਟੈਸਟਿੰਗ ਦੀਆਂ ਕਿਸਮਾਂ
ਲੋਡ ਟੈਸਟਿੰਗ ਦੀਆਂ ਕਈ ਕਿਸਮਾਂ ਹਨ, ਹਰ ਇੱਕ ਇਸਦੇ ਵਰਤੋਂ ਦੇ ਕੇਸਾਂ ਨਾਲ। ਆਓ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ.
ਲੋਡ ਟੈਸਟਿੰਗ: ਇਹ ਲੋਡ ਟੈਸਟ ਦਾ ਮੂਲ ਰੂਪ ਹੈ। ਇਹ ਆਮ ਲੋਡ ਅਤੇ ਸੰਭਾਵਿਤ ਪੀਕ ਲੋਡ ਦੇ ਅਧੀਨ ਇੱਕ ਸਿਸਟਮ (ਇਸ ਕੇਸ ਵਿੱਚ, ਇੱਕ API) ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਤਣਾਅ ਜਾਂਚ: ਇਹ ਇੱਕ ਬਹੁਤ ਜ਼ਿਆਦਾ ਭਾਰ ਹੇਠ ਇੱਕ ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਟੈਸਟ ਦਾ ਟੀਚਾ ਇਹ ਦੇਖਣਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਸਿਸਟਮ ਅਸਫਲਤਾ ਤੋਂ ਬਾਅਦ ਠੀਕ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅਜਿਹਾ ਕਰਨ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ। ਲੋਡ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਹੌਲੀ ਹੌਲੀ ਵਧਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਸਿਸਟਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਜਾਂਦਾ ਹੈ।
ਸਪਾਈਕ ਟੈਸਟਿੰਗ: ਇਹ ਤਣਾਅ ਜਾਂਚ ਦੇ ਸਮਾਨ ਹੈ, ਸਿਵਾਏ ਭਾਰੀ ਲੋਡ ਨੂੰ ਅਚਾਨਕ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਸਨੂੰ ਹੌਲੀ-ਹੌਲੀ ਵਧਾਉਣ ਦੇ ਉਲਟ। ਇਸ ਕਿਸਮ ਦਾ ਟੈਸਟ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਉਪਭੋਗਤਾਵਾਂ ਜਾਂ ਵਿਜ਼ਿਟਰਾਂ ਦੀ ਔਸਤ ਸੰਖਿਆ ਵਿੱਚ ਅਚਾਨਕ ਵਾਧਾ ਹੁੰਦਾ ਹੈ, ਜਾਂ ਜਦੋਂ ਤੁਹਾਡੇ ਸਿਸਟਮ 'ਤੇ DDOS ਹਮਲਾ ਹੁੰਦਾ ਹੈ।
ਸੋਕ ਟੈਸਟਿੰਗ: ਇਹ ਟੈਸਟ ਉਪਰੋਕਤ ਹੋਰਾਂ ਤੋਂ ਉਲਟ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਸਿਸਟਮ ਨੂੰ ਆਮ ਲੋਡ ਦੇ 80% (ਜਾਂ ਇਸ ਦੇ ਲਗਭਗ) ਦੇ ਹੇਠਾਂ ਰੱਖਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ 12 ਤੋਂ 14 ਘੰਟਿਆਂ ਲਈ ਲੰਬੇ ਸਮੇਂ ਲਈ ਚੱਲਦਾ ਛੱਡਦਾ ਹੈ। ਇਸ ਕਿਸਮ ਦਾ ਟੈਸਟ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਸਮੇਂ ਦੇ ਨਾਲ ਇੱਕ ਸਿਸਟਮ ਕਿੰਨਾ ਭਰੋਸੇਯੋਗ ਹੈ।
ਟਿੱਡੀ ਨਾਲ ਤੁਹਾਡੇ API ਦੀ ਜਾਂਚ ਲੋਡ ਕਰੋ
ਡਿਵੈਲਪਰਾਂ ਕੋਲ ਉਹਨਾਂ ਦੇ API ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਕਈ ਵਿਕਲਪਾਂ ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ। ਕੁਝ ਆਮ ਲੋਡ ਟੈਸਟਿੰਗ ਟੂਲ ਹਨ ਗੈਟਲਿੰਗ, ਜੇਮੀਟਰ, ਅਤੇ ਲੋਕਸਟ। ਅਸੀਂ ਇਸ ਲੇਖ ਵਿਚ ਟਿੱਡੀਆਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਾਂਗੇ।
ਟਿੱਡੀ ਇੱਕ ਪਾਇਥਨ-ਅਧਾਰਿਤ ਓਪਨ-ਸੋਰਸ ਲੋਡ ਟੈਸਟਿੰਗ ਟੂਲ ਹੈ ਜੋ ਚੋਟੀ ਦੀਆਂ ਕੰਪਨੀਆਂ ਜਿਵੇਂ ਕਿ Google, Microsoft, ਅਤੇ Riot Games ਦੁਆਰਾ ਉਹਨਾਂ ਦੇ APIs ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਾਂਗੇ ਕਿ ਇੱਕ API ਟੈਸਟ ਨੂੰ ਕਿਵੇਂ ਲੋਡ ਕਰਨਾ ਹੈ।
ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ, ਮੈਂ ਫਲਾਸਕ ਨਾਲ ਇੱਕ ਸਧਾਰਨ API ਬਣਾਵਾਂਗਾ। ਤੁਸੀਂ ਮੇਰੇ ਨਾਲ ਫਾਲੋ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਨੋਡ ਨਾਲ ਆਪਣਾ API ਬਣਾ ਸਕਦੇ ਹੋ, ਜਾਂ ਜੋ ਵੀ ਫਰੇਮਵਰਕ ਨਾਲ ਤੁਸੀਂ ਆਰਾਮਦਾਇਕ ਹੋ.
ਲੋੜ
ਪਾਇਥਨ 3
ਸਥਾਪਨਾ ਅਤੇ ਸਥਾਪਨਾ
ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਪੀਸੀ 'ਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਗਲੋਬਲ ਪਾਈਥਨ ਵਾਤਾਵਰਣ ਨੂੰ ਗੜਬੜ ਨਾ ਕਰੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਚਲਾਓ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕਮਾਂਡਾਂ ਵਿੰਡੋਜ਼ ਟਰਮੀਨਲ 'ਤੇ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ।
$ mkdir ਪ੍ਰੋਜੈਕਟ
$ cd /d ਮਾਰਗ\to\ਪ੍ਰੋਜੈਕਟ
$ python -m venv venv
$venv\ਸਕ੍ਰਿਪਟ\ਐਕਟੀਵੇਟ
ਪਹਿਲਾਂ, ਅਸੀਂ ਬਣਾਇਆ ਏ ਇਸ ਪ੍ਰਾਜੈਕਟ ਡਾਇਰੈਕਟਰੀ. ਫਿਰ ਅਸੀਂ ਆਪਣੀ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਇਸ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਇਸ ਪ੍ਰਾਜੈਕਟ. ਅਸੀਂ ਫਿਰ ਉਸ ਡਾਇਰੈਕਟਰੀ ਦੇ ਅੰਦਰ ਪਾਈਥਨ ਲਈ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਨ ਬਣਾਇਆ ਅਤੇ ਕਿਰਿਆਸ਼ੀਲ ਕੀਤਾ।
ਹੁਣ, ਅਸੀਂ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧਾਂਗੇ ਫਲਾਸਕ(ਅਸੀਂ ਲੋਡ ਟੈਸਟ ਕੀਤੇ ਜਾਣ ਲਈ ਅੰਤਮ ਬਿੰਦੂ ਬਣਾਉਣ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ) ਅਤੇ ਟਿੱਡੀ ਆਪਣੇ ਆਪ ਨੂੰ.
ਫਲਾਸਕ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ, ਚਲਾਓ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਵਿੱਚ ਹੋ ਇਸ ਪ੍ਰਾਜੈਕਟ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਬਣਾਇਆ ਹੈ।
$ pip ਇੰਸਟਾਲ ਫਲਾਸਕ
ਟਿੱਡੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਚਲਾਓ
$pip install locust
ਇੱਕ ਵਾਰ ਇਹ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਟਾਈਪ ਕਰੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਵਿੱਚ ਹੋ ਇਸ ਪ੍ਰਾਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਜਦੋਂ ਤੁਸੀਂ ਇਹ ਕਰਦੇ ਹੋ.
$ ਕਾਪੀ nul __init__.py
$ mkdir ਐਪ
$ ਕਾਪੀ nul app\app.py
$ ਕਾਪੀ nul ਐਪ\__init__.py
ਇਹ ਕਮਾਂਡਾਂ ਕੁਝ ਫਾਈਲਾਂ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਅਸੀਂ ਫਲਾਸਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਅੰਤਮ ਬਿੰਦੂ ਬਣਾਉਣ ਲਈ ਕਰਾਂਗੇ। ਤੁਸੀਂ ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਆਪਣੇ ਫਾਈਲ ਐਕਸਪਲੋਰਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਰ ਇਸ ਵਿੱਚ ਮਜ਼ਾ ਕੀ ਹੈ? ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਹ ਕਰ ਲੈਂਦੇ ਹੋ, ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਇਸ ਵਿੱਚ ਕਾਪੀ ਕਰੋ app.py
ਫਲਾਸਕ ਆਯਾਤ ਫਲਾਸਕ, jsonify, ਬੇਨਤੀ ਤੋਂ
ਐਪ = ਫਲਾਸਕ (__ਨਾਮ__)
ਕਾਰ_ਮਾਡਲ = [
{'ਬ੍ਰਾਂਡ': 'ਟੇਸਲਾ', 'ਮਾਡਲ': 'ਮਾਡਲ ਐਸ' }
]
ਜਹਾਜ਼_ਮਾਡਲ = [
{'ਬ੍ਰਾਂਡ': 'ਬੋਇੰਗ', 'ਮਾਡਲ': '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 path\to\app.py
ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:
ਜੇਕਰ ਤੁਸੀਂ ਟਰਮੀਨਲ ਤੋਂ URL ਕਾਪੀ ਕਰਦੇ ਹੋ ਅਤੇ ਟਾਈਪ ਕਰਦੇ ਹੋ ਕਾਰ or ਜਹਾਜ਼ / ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਉੱਥੇ ਡੇਟਾ ਦੇਖਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਸਾਡਾ ਟੀਚਾ ਟਿੱਡੀ ਨਾਲ ਅੰਤਮ ਬਿੰਦੂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈ, ਬ੍ਰਾਊਜ਼ਰ ਨਾਲ ਨਹੀਂ। ਇਸ ਲਈ ਆਓ ਅਜਿਹਾ ਕਰੀਏ। ਆਪਣੇ ਰੂਟ ਵਿੱਚ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ ਇਸ ਪ੍ਰਾਜੈਕਟ ਡਾਇਰੈਕਟਰੀ.
$ ਕਾਪੀ nul locust_test.py
ਇਹ ਤੁਹਾਡੇ ਰੂਟ ਵਿੱਚ ਇੱਕ 'locust_test.py' ਫਾਈਲ ਬਣਾਉਂਦਾ ਹੈ ਇਸ ਪ੍ਰਾਜੈਕਟ ਡਾਇਰੈਕਟਰੀ. ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਹ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਫਾਈਲ ਖੋਲ੍ਹੋ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਵਿੱਚ ਪੇਸਟ ਕਰੋ। ਅਸੀਂ ਜਲਦੀ ਹੀ ਇਸਦੀ ਵਿਆਖਿਆ ਕਰਾਂਗੇ।
ਆਯਾਤ ਦਾ ਸਮਾਂ
ਟਿੱਡੀ ਆਯਾਤ HttpUser, ਟਾਸਕ, ਵਿਚਕਾਰ
ਵਰਗ ਉਪਭੋਗਤਾ ਵਿਵਹਾਰ(HttpUser):
ਉਡੀਕ_ਸਮਾਂ = ਵਿਚਕਾਰ (5, 10)
@ਟਾਸਕ
def get_cars(ਸਵੈ):
self.client.get('/cars')
@ਟਾਸਕ
def get_planes(ਸਵੈ):
self.client.get('/planes')
ਇਹ ਇੱਕ API ਟੈਸਟ ਲੋਡ ਕਰਨ ਲਈ Locust ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਬੁਨਿਆਦੀ ਉਦਾਹਰਨ ਹੈ। ਪਹਿਲਾਂ, ਅਸੀਂ ਇੱਕ ਕਲਾਸ ਬਣਾਉਂਦੇ ਹਾਂ ਉਪਭੋਗਤਾ ਵਿਵਹਾਰ, ਜਿਸ ਨੂੰ ਕੋਈ ਵੀ ਢੁਕਵਾਂ ਨਾਮ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ ਪਰ ਵਧਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ HttpUser. HttpUser ਉਹ ਕਲਾਸ ਹੈ ਜੋ ਸਾਡੇ ਦੁਆਰਾ ਦਰਸਾਏ ਗਏ ਕੰਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਕਈ ਵਰਚੁਅਲ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਤੁਰੰਤ ਬਣਾਉਣ ਦਾ ਧਿਆਨ ਰੱਖਦੀ ਹੈ ਉਪਭੋਗਤਾ ਵਿਵਹਾਰ ਕਲਾਸ.
ਨਾਲ ਇੱਕ ਵਿਧੀ ਨੂੰ ਸਜਾਉਣ ਦੁਆਰਾ ਇੱਕ ਕਾਰਜ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ @ਟਾਸਕ ਸਜਾਵਟ ਕਰਨ ਵਾਲਾ ਸਾਡੇ ਕੋਲ ਇੱਕ ਫੰਕਸ਼ਨ ਵੀ ਹੈ ਜਿਸਨੂੰ ਕਹਿੰਦੇ ਹਨ ਵਿਚਕਾਰ() ਜੋ ਸਾਨੂੰ ਅਗਲੇ ਕੰਮ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਉਡੀਕ ਕਰਨ ਲਈ ਸਕਿੰਟਾਂ ਦੀ ਸੀਮਾ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇਸਦੇ ਲਈ 5 ਤੋਂ 10 ਸਕਿੰਟਾਂ ਦੀ ਰੇਂਜ ਨਿਰਧਾਰਤ ਕੀਤੀ ਹੈ।
ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਅਜੇ ਵੀ ਆਪਣੇ ਵਰਚੁਅਲ ਵਾਤਾਵਰਨ ਵਿੱਚ ਹੋ। ਜੇਕਰ ਤੁਹਾਡੇ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਇੱਕ API ਸਰਵਰ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਇੱਕ ਨਵਾਂ ਟਰਮੀਨਲ ਖੋਲ੍ਹੋ, ਆਪਣੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਆਪਣੇ ਵਿੱਚ ਬਦਲੋ ਇਸ ਪ੍ਰਾਜੈਕਟ ਡਾਇਰੈਕਟਰੀ, ਅਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਬਣਾਏ ਵਰਚੁਅਲ ਵਾਤਾਵਰਨ ਨੂੰ ਸਰਗਰਮ ਕਰੋ। ਤੁਸੀਂ ਉੱਪਰ ਵਰਚੁਅਲ ਵਾਤਾਵਰਨ ਨੂੰ ਸਰਗਰਮ ਕਰਨ ਲਈ ਕਮਾਂਡ ਲੱਭ ਸਕਦੇ ਹੋ। ਹੁਣ, ਆਪਣੇ ਟਰਮੀਨਲ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਦਿਓ।
$ locust -f locust_test.py
ਤੁਹਾਨੂੰ ਕੁਝ ਇਸ ਤਰਾਂ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਟਿੱਡੀ ਦਾ ਵੈੱਬ ਇੰਟਰਫੇਸ http://localhost/8089 'ਤੇ ਸਥਿਤ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਵੈੱਬਸਾਈਟ 'ਤੇ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਇੰਟਰਫੇਸ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:
ਇੰਟਰਫੇਸ ਤੋਂ, ਅਸੀਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਿਣਤੀ, ਸਪੌਨ ਰੇਟ (ਉਪਭੋਗਤਾ ਪ੍ਰਤੀ ਸਕਿੰਟ ਬਣਾਏ), ਅਤੇ ਮੇਜ਼ਬਾਨ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਤੁਸੀਂ ਟਰਮੀਨਲ ਦੀ ਜਾਂਚ ਕਰਕੇ ਆਪਣੇ ਹੋਸਟ ਦਾ ਪਤਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਜਿੱਥੇ ਸਰਵਰ ਚੱਲ ਰਿਹਾ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਪੋਰਟ 5000 'ਤੇ ਹੈ. ਜਦੋਂ ਤੁਸੀਂ ਕਲਿੱਕ ਕਰਦੇ ਹੋ ਝੁਲਸਣਾ ਸ਼ੁਰੂ ਕਰੋ, ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਇੰਟਰਫੇਸ ਨਾਲ ਪੇਸ਼ ਕੀਤਾ ਜਾਵੇਗਾ।
ਇਹ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਉਪਯੋਗੀ ਮੈਟ੍ਰਿਕਸ ਦਿਖਾਉਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਅਸਫਲ ਬੇਨਤੀਆਂ ਦੀ ਸੰਖਿਆ, ਬੇਨਤੀ ਲਈ ਔਸਤ ਸਮਾਂ, ਬੇਨਤੀ ਲਈ ਘੱਟੋ-ਘੱਟ ਸਮਾਂ, ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ, ਆਦਿ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਜੋ ਦੇਖਦੇ ਹੋ ਉਸ ਤੋਂ ਸੰਤੁਸ਼ਟ ਹੋ ਜਾਂਦੇ ਹੋ, ਤੁਸੀਂ ਸਟਾਪ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰ ਸਕਦੇ ਹੋ।
ਇਸ ਤੋਂ ਇਲਾਵਾ ਅੰਕੜੇ ਟੈਬ, ਉਥੇ ਏ ਚਾਰਟ ਟੈਬ ਜੋ ਹੋਰ ਦਿਖਾਉਂਦਾ ਹੈ ਜਾਣਕਾਰੀ ਇੱਕ ਗ੍ਰਾਫ ਦੇ ਰੂਪ ਵਿੱਚ, ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵਾਂਗ।
ਇੱਥੇ ਇੱਕ ਹੈ ਪ੍ਰਤੀ ਸਕਿੰਟ ਗ੍ਰਾਫ਼ ਕੁੱਲ ਬੇਨਤੀਆਂ, ਜਵਾਬ ਸਮਾਂ ਗ੍ਰਾਫ, ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਿਣਤੀ ਗ੍ਰਾਫ, ਸਾਰੇ ਸਮੇਂ ਦੇ ਵਿਰੁੱਧ ਸਾਜ਼ਿਸ਼ ਰਚਦੇ ਹਨ। ਗ੍ਰਾਫਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿੰਨੇ ਉਪਭੋਗਤਾ ਇੱਕ ਨਿਸ਼ਚਿਤ ਜਵਾਬ ਸਮੇਂ ਲਈ ਸਵੀਕਾਰਯੋਗ ਹਨ, ਜਾਂ ਤੁਸੀਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਵੱਧਦੀ ਗਿਣਤੀ ਦੇ ਬਾਵਜੂਦ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਹੋਰ ਸੂਝਾਂ ਦੇ ਬਾਵਜੂਦ ਇੱਕ ਨਿਰੰਤਰ ਜਵਾਬ ਸਮੇਂ ਲਈ ਆਪਣੇ ਚਾਰਟਾਂ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਇਹਨਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅੰਕੜੇ ਕਿਸੇ ਹੋਰ ਨਾਲ, ਤੁਸੀਂ ਤੋਂ ਇੱਕ ਰਿਪੋਰਟ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਡਾਉਨਲੋਡ ਕਰੋ ਡਾਟਾ ਟੈਬ
ਸਿੱਟਾ ਕੱਢਣ ਲਈ...
ਤੁਹਾਡੇ API ਨੂੰ ਲੋਡ ਕਰਨਾ ਤੁਹਾਡੀ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਗਤੀਵਿਧੀ ਹੈ, ਇਸ ਲਈ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਇਹ ਤੁਹਾਡੇ ਡਿਜ਼ਾਈਨ ਚੱਕਰ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ। ਤਰੀਕੇ ਨਾਲ, ਤੁਸੀਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੰਖਿਆ ਅਤੇ ਸਪੌਨ ਰੇਟ ਲਈ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲ ਕੇ ਹੋਰ ਲੋਡ ਟੈਸਟ ਕਿਸਮਾਂ ਨੂੰ ਵੀ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹੋ।
ਜੇਕਰ ਤੁਸੀਂ ਸਪਾਈਕ ਟੈਸਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਿਣਤੀ ਲਈ ਇੱਕ ਵੱਡਾ ਮੁੱਲ (2000 ਕਹੋ), ਅਤੇ ਫਿਰ ਤੁਹਾਡੀ ਸਪੌਨ ਰੇਟ (ਉਦਾਹਰਨ ਲਈ 500) ਲਈ ਬਰਾਬਰ ਵੱਡਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰੋ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ 4 ਸਕਿੰਟਾਂ ਵਿੱਚ, ਤੁਹਾਡੇ ਕੋਲ ਸਾਰੇ 2000 ਉਪਭੋਗਤਾ ਬਣਾਏ ਜਾਣਗੇ ਅਤੇ ਤੁਹਾਡੇ ਅੰਤਮ ਬਿੰਦੂਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਰਹੇ ਹਨ। ਇੱਕ ਤਣਾਅ ਟੈਸਟ ਸਮਾਨ ਹੋਵੇਗਾ, ਪਰ ਸਪੌਨ ਰੇਟ ਲਈ ਬਹੁਤ ਘੱਟ ਮੁੱਲ ਦੇ ਨਾਲ। ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਤੁਸੀਂ ਕੀ ਕਰ ਸਕਦੇ ਹੋ, ਟਿੱਡੀ ਦੀ ਜਾਂਚ ਕਰੋ ਦਸਤਾਵੇਜ਼.
