ਅਸੀਂ ਕਾਨਫਰੰਸ ਤੋਂ ਰਿਪੋਰਟ ਦੀ ਪ੍ਰਤੀਲਿਪੀ ਨੂੰ ਦੁਬਾਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਹਾਈਲੋਡ++ 2016, ਜੋ ਕਿ ਪਿਛਲੇ ਸਾਲ 7-8 ਨਵੰਬਰ ਨੂੰ ਮਾਸਕੋ ਦੇ ਨੇੜੇ ਸਕੋਲਕੋਵੋ ਵਿੱਚ ਆਯੋਜਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਵਲਾਦੀਮੀਰ ਪ੍ਰੋਟਾਸੋਵ ਦੱਸਦਾ ਹੈ ਕਿ ਓਪਨਰੇਸਟੀ ਅਤੇ ਲੁਆ ਨਾਲ NGINX ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਕਿਵੇਂ ਵਧਾਇਆ ਜਾਵੇ।

ਸਾਰਿਆਂ ਨੂੰ ਹੈਲੋ, ਮੇਰਾ ਨਾਮ ਵਲਾਦੀਮੀਰ ਪ੍ਰੋਟਾਸੋਵ ਹੈ, ਮੈਂ ਸਮਾਨਾਂਤਰਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹਾਂ। ਮੈਂ ਤੁਹਾਨੂੰ ਆਪਣੇ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ ਦੱਸਾਂਗਾ। ਮੈਂ ਆਪਣੀ ਜ਼ਿੰਦਗੀ ਦਾ ਤਿੰਨ ਚੌਥਾਈ ਕੋਡ ਲਿਖਣ ਵਿੱਚ ਬਿਤਾਉਂਦਾ ਹਾਂ। ਮੈਂ ਸ਼ਾਬਦਿਕ ਅਰਥਾਂ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਬਣ ਗਿਆ: ਮੈਂ ਕਈ ਵਾਰ ਆਪਣੇ ਸੁਪਨਿਆਂ ਵਿੱਚ ਕੋਡ ਵੇਖਦਾ ਹਾਂ. ਜੀਵਨ ਦਾ ਇੱਕ ਚੌਥਾਈ ਹਿੱਸਾ ਉਦਯੋਗਿਕ ਵਿਕਾਸ ਹੈ, ਕੋਡ ਲਿਖਣਾ ਜੋ ਸਿੱਧਾ ਉਤਪਾਦਨ ਵਿੱਚ ਜਾਂਦਾ ਹੈ। ਕੋਡ ਜੋ ਤੁਹਾਡੇ ਵਿੱਚੋਂ ਕੁਝ ਵਰਤਦੇ ਹਨ ਪਰ ਇਸਨੂੰ ਨਹੀਂ ਜਾਣਦੇ।

ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਕਿ ਇਹ ਕਿੰਨਾ ਬੁਰਾ ਸੀ। ਜਦੋਂ ਮੈਂ ਥੋੜਾ ਜੂਨੀਅਰ ਸੀ, ਮੈਂ ਅੰਦਰ ਆਇਆ ਅਤੇ ਉਨ੍ਹਾਂ ਨੇ ਮੈਨੂੰ ਇਹ ਦੋ ਟੈਰਾਬਾਈਟ ਡੇਟਾਬੇਸ ਦਿੱਤੇ। ਇਹ ਹੁਣ ਹਰ ਕਿਸੇ ਲਈ ਹਾਈਲੋਡ ਹੈ। ਮੈਂ ਕਾਨਫਰੰਸਾਂ ਵਿੱਚ ਗਿਆ ਅਤੇ ਪੁੱਛਿਆ: "ਮੁੰਡੇ, ਮੈਨੂੰ ਦੱਸੋ, ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਵੱਡਾ ਡੇਟਾ ਹੈ, ਕੀ ਸਭ ਕੁਝ ਵਧੀਆ ਹੈ? ਤੁਹਾਡੇ ਕੋਲ ਕਿੰਨੇ ਅਧਾਰ ਹਨ? ਉਨ੍ਹਾਂ ਨੇ ਮੈਨੂੰ ਜਵਾਬ ਦਿੱਤਾ: "ਸਾਡੇ ਕੋਲ 100 ਗੀਗਾਬਾਈਟ ਹਨ!" ਮੈਂ ਕਿਹਾ: "ਠੰਡਾ, 100 ਗੀਗਾਬਾਈਟ!" ਅਤੇ ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਸੋਚਿਆ ਕਿ ਪੋਕਰ ਦੇ ਚਿਹਰੇ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕਿਵੇਂ ਬਚਾਇਆ ਜਾਵੇ. ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ, ਹਾਂ, ਮੁੰਡੇ ਵਧੀਆ ਹਨ, ਅਤੇ ਫਿਰ ਤੁਸੀਂ ਵਾਪਸ ਆਉਂਦੇ ਹੋ ਅਤੇ ਇਹਨਾਂ ਮਲਟੀ-ਟੇਰਾਬਾਈਟ ਡੇਟਾਬੇਸ ਨਾਲ ਟਿੰਕਰ ਕਰਦੇ ਹੋ। ਅਤੇ ਇਹ ਇੱਕ ਜੂਨੀਅਰ ਹੋ ਰਿਹਾ ਹੈ. ਕੀ ਤੁਸੀਂ ਕਲਪਨਾ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕਿੰਨੀ ਹਿੱਟ ਹੈ?

ਮੈਂ 20 ਤੋਂ ਵੱਧ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਜਾਣਦਾ ਹਾਂ। ਇਹ ਉਹ ਹੈ ਜੋ ਮੈਨੂੰ ਕੰਮ ਦੇ ਦੌਰਾਨ ਪਤਾ ਲਗਾਉਣਾ ਪਿਆ. ਉਹ ਤੁਹਾਨੂੰ ਏਰਲਾਂਗ ਵਿੱਚ, C ਵਿੱਚ, C++ ਵਿੱਚ, ਲੁਆ ਵਿੱਚ, ਪਾਈਥਨ ਵਿੱਚ, ਰੂਬੀ ਵਿੱਚ, ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਵਿੱਚ ਕੋਡ ਦਿੰਦੇ ਹਨ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਹ ਸਭ ਕੱਟਣਾ ਪਵੇਗਾ। ਆਮ ਤੌਰ 'ਤੇ, ਮੈਨੂੰ ਕਰਨਾ ਪਿਆ. ਸਹੀ ਗਿਣਤੀ ਦਾ ਹਿਸਾਬ ਲਗਾਉਣਾ ਸੰਭਵ ਨਹੀਂ ਸੀ, ਪਰ ਕਿਤੇ ਨਾ ਕਿਤੇ 20 ਦੇ ਆਸਪਾਸ ਨੰਬਰ ਗੁਆਚ ਗਿਆ.

ਕਿਉਂਕਿ ਇੱਥੇ ਹਰ ਕੋਈ ਜਾਣਦਾ ਹੈ ਕਿ ਸਮਾਨਤਾਵਾਂ ਕੀ ਹੈ ਅਤੇ ਅਸੀਂ ਕੀ ਕਰਦੇ ਹਾਂ, ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਨਹੀਂ ਕਰਾਂਗਾ ਕਿ ਅਸੀਂ ਕਿੰਨੇ ਚੰਗੇ ਹਾਂ ਅਤੇ ਅਸੀਂ ਕੀ ਕਰਦੇ ਹਾਂ। ਮੈਂ ਤੁਹਾਨੂੰ ਸਿਰਫ ਇਹ ਦੱਸਾਂਗਾ ਕਿ ਸਾਡੇ ਕੋਲ ਦੁਨੀਆ ਭਰ ਵਿੱਚ 13 ਦਫਤਰ ਹਨ, 300 ਤੋਂ ਵੱਧ ਕਰਮਚਾਰੀ, ਮਾਸਕੋ, ਟੈਲਿਨ ਅਤੇ ਮਾਲਟਾ ਵਿੱਚ ਵਿਕਾਸ. ਜੇ ਤੁਸੀਂ ਚਾਹੋ, ਤਾਂ ਤੁਸੀਂ ਮਾਲਟਾ ਲੈ ਕੇ ਜਾ ਸਕਦੇ ਹੋ, ਜੇਕਰ ਸਰਦੀਆਂ ਵਿੱਚ ਠੰਡ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਆਪਣੀ ਪਿੱਠ ਨੂੰ ਗਰਮ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ।

ਖਾਸ ਤੌਰ 'ਤੇ, ਸਾਡਾ ਵਿਭਾਗ ਪਾਈਥਨ 2 ਵਿੱਚ ਲਿਖਦਾ ਹੈ. ਅਸੀਂ ਕਾਰੋਬਾਰ ਵਿੱਚ ਹਾਂ ਅਤੇ ਸਾਡੇ ਕੋਲ ਫੈਸ਼ਨੇਬਲ ਤਕਨਾਲੋਜੀਆਂ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਲਈ ਸਮਾਂ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਦੁੱਖ ਝੱਲਦੇ ਹਾਂ। ਸਾਡੇ ਕੋਲ Django ਹੈ, ਕਿਉਂਕਿ ਇਸ ਕੋਲ ਸਭ ਕੁਝ ਹੈ, ਅਤੇ ਅਸੀਂ ਵਾਧੂ ਲਿਆ ਅਤੇ ਇਸਨੂੰ ਸੁੱਟ ਦਿੱਤਾ. MySQL, Redis ਅਤੇ NGINX ਵੀ। ਸਾਡੇ ਕੋਲ ਹੋਰ ਬਹੁਤ ਸਾਰੀਆਂ ਵਧੀਆ ਚੀਜ਼ਾਂ ਵੀ ਹਨ। ਸਾਡੇ ਕੋਲ ਮੋਂਗੋਡੀਬੀ ਹੈ, ਸਾਡੇ ਕੋਲ ਖਰਗੋਸ਼ ਚੱਲ ਰਹੇ ਹਨ, ਸਾਡੇ ਕੋਲ ਕੁਝ ਵੀ ਨਹੀਂ ਹੈ - ਪਰ ਇਹ ਮੇਰਾ ਨਹੀਂ ਹੈ, ਅਤੇ ਮੈਂ ਇਹ ਨਹੀਂ ਕਰਦਾ।

OpenResty

ਮੈਂ ਆਪਣੇ ਬਾਰੇ ਦੱਸਿਆ। ਆਓ ਦੇਖੀਏ ਕਿ ਮੈਂ ਅੱਜ ਕਿਸ ਬਾਰੇ ਗੱਲ ਕਰਨ ਜਾ ਰਿਹਾ ਹਾਂ:

• ਓਪਨਰੇਸਟੀ ਕੀ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਕੀ ਖਾਧਾ ਜਾਂਦਾ ਹੈ?
• ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਪਾਈਥਨ, ਨੋਡਜੇਐਸ, ਪੀਐਚਪੀ, ਗੋ ਅਤੇ ਹੋਰ ਵਧੀਆ ਚੀਜ਼ਾਂ ਹਨ ਜਿਸ ਨਾਲ ਹਰ ਕੋਈ ਖੁਸ਼ ਹੈ ਤਾਂ ਪਹੀਏ ਨੂੰ ਦੁਬਾਰਾ ਕਿਉਂ ਬਣਾਇਆ ਜਾਵੇ?
• ਅਤੇ ਕੁਝ ਅਸਲ ਜੀਵਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ। ਮੈਨੂੰ ਰਿਪੋਰਟ ਨੂੰ ਬਹੁਤ ਘੱਟ ਕਰਨਾ ਪਿਆ, ਕਿਉਂਕਿ ਮੈਨੂੰ ਇਹ 3,5 ਘੰਟੇ ਲਈ ਮਿਲੀ, ਇਸ ਲਈ ਕੁਝ ਉਦਾਹਰਣਾਂ ਹੋਣਗੀਆਂ.

OpenResty NGINX ਹੈ। ਉਸਦਾ ਧੰਨਵਾਦ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਪੂਰਾ ਵੈਬ ਸਰਵਰ ਹੈ, ਜੋ ਕਿ ਚੰਗੀ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਇਹ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ. ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਸਾਡੇ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਉਤਪਾਦਨ ਵਿੱਚ NGINX ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ. ਤੁਸੀਂ ਸਾਰੇ ਜਾਣਦੇ ਹੋ ਕਿ ਉਹ ਤੇਜ਼ ਅਤੇ ਠੰਡਾ ਹੈ। ਉਹਨਾਂ ਨੇ ਇਸ ਵਿੱਚ ਠੰਡਾ ਸਮਕਾਲੀ I/O ਬਣਾਇਆ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਸਾਈਕਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਜਿਸ ਤਰ੍ਹਾਂ ਪਾਈਥਨ ਵਿੱਚ ਗੇਵੈਂਟ ਨੂੰ ਸਾਈਕਲ ਕੀਤਾ ਗਿਆ ਸੀ। Gevent ਠੰਡਾ, ਠੰਡਾ ਹੈ, ਪਰ ਜੇ ਤੁਸੀਂ C-ਕੋਡ ਲਿਖਦੇ ਹੋ ਅਤੇ gevent ਨਾਲ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਡੀਬੱਗ ਕਰਨ ਲਈ ਪਾਗਲ ਹੋ ਜਾਵੋਗੇ. ਮੇਰੇ ਕੋਲ ਅਨੁਭਵ ਸੀ: ਇਹ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਪੂਰੇ ਦੋ ਦਿਨ ਲੱਗ ਗਏ ਕਿ ਉੱਥੇ ਕੀ ਗਲਤ ਹੋਇਆ ਹੈ। ਜੇ ਕਿਸੇ ਨੇ ਕੁਝ ਹਫ਼ਤੇ ਪਹਿਲਾਂ ਨਹੀਂ ਪੁੱਟਿਆ ਸੀ, ਸਮੱਸਿਆ ਲੱਭੀ ਹੈ, ਇਸ ਨੂੰ ਇੰਟਰਨੈਟ 'ਤੇ ਲਿਖਿਆ ਹੈ, ਅਤੇ ਗੂਗਲ ਨੇ ਇਹ ਨਹੀਂ ਲੱਭਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪਾਗਲ ਹੋ ਜਾਂਦੇ ਹਾਂ.

NGINX ਪਹਿਲਾਂ ਹੀ ਕੈਚਿੰਗ ਅਤੇ ਸਥਿਰ ਸਮੱਗਰੀ ਕਰਦਾ ਹੈ. ਤੁਹਾਨੂੰ ਇਸ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ ਕਿ ਇਸਨੂੰ ਮਨੁੱਖੀ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਕਿਤੇ ਹੌਲੀ ਨਾ ਹੋ ਜਾਓ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਕਿਤੇ ਵਰਣਨਕਰਤਾਵਾਂ ਨੂੰ ਨਾ ਗੁਆ ਦਿਓ। Nginx ਤੈਨਾਤ ਕਰਨ ਲਈ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ, ਤੁਹਾਨੂੰ ਇਸ ਬਾਰੇ ਸੋਚਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ ਕਿ ਕੀ ਲੈਣਾ ਹੈ - WSGI, PHP-FPM, Gunicorn, Unicorn. Nginx ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਪ੍ਰਬੰਧਕਾਂ ਨੂੰ ਦਿੱਤਾ ਗਿਆ, ਉਹ ਜਾਣਦੇ ਹਨ ਕਿ ਇਸ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ. Nginx ਇੱਕ ਢਾਂਚਾਗਤ ਤਰੀਕੇ ਨਾਲ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ. ਮੈਂ ਇਸ ਬਾਰੇ ਥੋੜ੍ਹੀ ਦੇਰ ਬਾਅਦ ਗੱਲ ਕਰਾਂਗਾ। ਸੰਖੇਪ ਵਿੱਚ, ਉਸ ਕੋਲ ਇੱਕ ਪੜਾਅ ਹੈ ਜਦੋਂ ਉਸਨੇ ਹੁਣੇ ਬੇਨਤੀ ਸਵੀਕਾਰ ਕੀਤੀ, ਜਦੋਂ ਉਸਨੇ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਅਤੇ ਜਦੋਂ ਉਸਨੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸਮੱਗਰੀ ਦਿੱਤੀ.

Nginx ਠੰਡਾ ਹੈ, ਪਰ ਇੱਕ ਸਮੱਸਿਆ ਹੈ: ਇਹ ਉਹਨਾਂ ਸਾਰੀਆਂ ਸ਼ਾਨਦਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ ਵੀ ਲਚਕਦਾਰ ਨਹੀਂ ਹੈ ਜੋ ਮੁੰਡਿਆਂ ਨੇ ਸੰਰਚਨਾ ਵਿੱਚ ਧੱਕੇ ਹਨ, ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਇਸਨੂੰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਇਹ ਸ਼ਕਤੀ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ। ਇਸ ਲਈ, ਤਾਓਬਾਓ ਦੇ ਮੁੰਡਿਆਂ ਨੇ ਇੱਕ ਵਾਰ, ਮੈਂ ਲਗਭਗ ਅੱਠ ਸਾਲ ਪਹਿਲਾਂ ਸੋਚਦਾ ਹਾਂ, ਇਸ ਵਿੱਚ ਲੂਆ ਬਣਾਇਆ ਸੀ। ਉਹ ਕੀ ਦਿੰਦਾ ਹੈ?

• ਦਾ ਆਕਾਰ. ਇਹ ਛੋਟਾ ਹੈ। LuaJIT ਕਿਤੇ ਕਿਤੇ ਲਗਭਗ 100-200 ਕਿਲੋਬਾਈਟ ਮੈਮੋਰੀ ਓਵਰਹੈੱਡ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਪ੍ਰਦਰਸ਼ਨ ਓਵਰਹੈੱਡ ਦਿੰਦਾ ਹੈ।
• ਸਪੀਡ. LuaJIT ਦੁਭਾਸ਼ੀਏ ਬਹੁਤ ਸਾਰੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ C ਦੇ ਨੇੜੇ ਹੈ, ਕੁਝ ਸਥਿਤੀਆਂ ਵਿੱਚ ਇਹ Java ਤੋਂ ਹਾਰ ਜਾਂਦਾ ਹੈ, ਕੁਝ ਵਿੱਚ ਇਹ ਇਸਨੂੰ ਪਛਾੜ ਦਿੰਦਾ ਹੈ। ਕੁਝ ਸਮੇਂ ਲਈ, ਇਸ ਨੂੰ ਕਲਾ ਦਾ ਰਾਜ ਮੰਨਿਆ ਜਾਂਦਾ ਸੀ, ਸਭ ਤੋਂ ਵਧੀਆ ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ। ਹੁਣ ਕੂਲਰ ਹਨ, ਪਰ ਉਹ ਬਹੁਤ ਭਾਰੀ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਉਹੀ V8. ਕੁਝ JS ਦੁਭਾਸ਼ੀਏ ਅਤੇ Java HotSpot ਕੁਝ ਬਿੰਦੂਆਂ 'ਤੇ ਤੇਜ਼ ਹੁੰਦੇ ਹਨ, ਪਰ ਫਿਰ ਵੀ ਕੁਝ ਬਿੰਦੂਆਂ 'ਤੇ ਹਾਰ ਜਾਂਦੇ ਹਨ।
• ਸਿੱਖਣ ਲਈ ਆਸਾਨ. ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਪਰਲ ਕੋਡਬੇਸ ਹੈ ਅਤੇ ਤੁਸੀਂ ਬੁਕਿੰਗ ਨਹੀਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਪਰਲ ਪ੍ਰੋਗਰਾਮਰ ਨਹੀਂ ਮਿਲਣਗੇ। ਕਿਉਂਕਿ ਉਹ ਉੱਥੇ ਨਹੀਂ ਹਨ, ਉਹ ਸਾਰੇ ਲੈ ਗਏ ਸਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਿਖਾਉਣਾ ਲੰਬਾ ਅਤੇ ਮੁਸ਼ਕਲ ਹੈ. ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਲਈ ਪ੍ਰੋਗਰਾਮਰ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਸਿਖਲਾਈ ਜਾਂ ਲੱਭਣਾ ਵੀ ਪੈ ਸਕਦਾ ਹੈ। ਲੁਆ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ. ਲੂਆ ਨੂੰ ਕੋਈ ਵੀ ਜੂਨੀਅਰ ਤਿੰਨ ਦਿਨਾਂ ਵਿੱਚ ਸਿੱਖ ਸਕਦਾ ਹੈ। ਇਹ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਮੈਨੂੰ ਲਗਭਗ ਦੋ ਘੰਟੇ ਲੱਗ ਗਏ। ਦੋ ਘੰਟੇ ਬਾਅਦ, ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਉਤਪਾਦਨ ਵਿੱਚ ਕੋਡ ਲਿਖ ਰਿਹਾ ਸੀ. ਲਗਭਗ ਇੱਕ ਹਫ਼ਤੇ ਬਾਅਦ, ਉਹ ਸਿੱਧਾ ਉਤਪਾਦਨ ਵਿੱਚ ਚਲਾ ਗਿਆ ਅਤੇ ਚਲਾ ਗਿਆ।

ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

ਇੱਥੇ ਬਹੁਤ ਕੁਝ ਹੈ। ਓਪਨਰੇਸਟੀ ਨੇ ਲੁਆਸ਼ ਅਤੇ ਇੰਜਣ ਦੋਨਾਂ, ਮੋਡੀਊਲਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਇਕੱਠਾ ਕੀਤਾ ਹੈ। ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਸਭ ਕੁਝ ਤਿਆਰ ਹੈ - ਤੈਨਾਤ ਅਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।

ਮਿਸਾਲ

ਕਾਫ਼ੀ ਬੋਲ, ਆਓ ਕੋਡ ਵੱਲ ਵਧੀਏ। ਇੱਥੇ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਹੈਲੋ ਵਰਲਡ ਹੈ:

ਉੱਥੇ ਕੀ ਹੈ? ਇਹ ਇੰਜਣ ਦੀ ਸਥਿਤੀ ਹੈ। ਅਸੀਂ ਚਿੰਤਾ ਨਾ ਕਰੋ, ਅਸੀਂ ਆਪਣੀ ਖੁਦ ਦੀ ਰੂਟਿੰਗ ਨਹੀਂ ਲਿਖਦੇ, ਅਸੀਂ ਕੁਝ ਤਿਆਰ-ਬਣਾਇਆ ਨਹੀਂ ਲੈਂਦੇ - ਸਾਡੇ ਕੋਲ ਇਹ ਪਹਿਲਾਂ ਹੀ NGINX ਵਿੱਚ ਹੈ, ਅਸੀਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਅਤੇ ਆਲਸ ਨਾਲ ਰਹਿੰਦੇ ਹਾਂ।

content_by_lua_block ਇੱਕ ਬਲਾਕ ਹੈ ਜੋ ਕਹਿੰਦਾ ਹੈ ਕਿ ਅਸੀਂ ਲੂਆ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਮੱਗਰੀ ਦੀ ਸੇਵਾ ਕਰ ਰਹੇ ਹਾਂ। ਅਸੀਂ ਇੱਕ ਇੰਜਨ ਵੇਰੀਏਬਲ ਲੈਂਦੇ ਹਾਂ remote_addr ਅਤੇ ਇਸ ਵਿੱਚ ਖਿਸਕ string.format. ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੀ ਹੈ sprintf, ਸਿਰਫ਼ ਲੁਆ ਵਿੱਚ, ਸਿਰਫ਼ ਸਹੀ। ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਗਾਹਕ ਨੂੰ ਦਿੰਦੇ ਹਾਂ.

ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

ਪਰ ਅਸਲ ਸੰਸਾਰ ਵਿੱਚ ਵਾਪਸ. ਉਤਪਾਦਨ ਵਿੱਚ, ਕੋਈ ਵੀ ਹੈਲੋ ਵਰਲਡ ਨੂੰ ਤਾਇਨਾਤ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਡੇਟਾਬੇਸ ਜਾਂ ਕਿਤੇ ਹੋਰ ਜਾਂਦੀ ਹੈ ਅਤੇ ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ ਇਹ ਜਵਾਬ ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ।

ਬਸ ਬੈਠਦਾ ਹੈ ਅਤੇ ਉਡੀਕ ਕਰਦਾ ਹੈ. ਇਹ ਬਹੁਤ ਵਧੀਆ ਨਹੀਂ ਹੈ। ਜਦੋਂ 100.000 ਉਪਭੋਗਤਾ ਆਉਂਦੇ ਹਨ, ਇਹ ਸਾਡੇ ਲਈ ਬਹੁਤ ਔਖਾ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ, ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਵਜੋਂ ਇੱਕ ਸਧਾਰਨ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੀਏ. ਅਸੀਂ ਤਸਵੀਰਾਂ ਲਈ ਦੇਖਾਂਗੇ, ਉਦਾਹਰਨ ਲਈ, ਬਿੱਲੀਆਂ। ਸਿਰਫ਼ ਅਸੀਂ ਸਿਰਫ਼ ਖੋਜ ਨਹੀਂ ਕਰਾਂਗੇ, ਅਸੀਂ ਕੀਵਰਡਾਂ ਦਾ ਵਿਸਤਾਰ ਕਰਾਂਗੇ ਅਤੇ, ਜੇਕਰ ਉਪਭੋਗਤਾ ਨੇ "ਬਿੱਲੀ ਦੇ ਬੱਚੇ" ਦੀ ਖੋਜ ਕੀਤੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਬਿੱਲੀਆਂ, ਫਲੱਫੀਆਂ ਅਤੇ ਹੋਰ ਵੀ ਲੱਭਾਂਗੇ। ਪਹਿਲਾਂ ਸਾਨੂੰ ਬੈਕਐਂਡ 'ਤੇ ਬੇਨਤੀ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:

ਦੋ ਲਾਈਨਾਂ ਤੁਹਾਨੂੰ GET ਪੈਰਾਮੀਟਰ ਚੁੱਕਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ, ਕੋਈ ਪੇਚੀਦਗੀਆਂ ਨਹੀਂ। ਫਿਰ ਅਸੀਂ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਨਿਯਮਤ SQL ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੀਵਰਡ ਅਤੇ ਐਕਸਟੈਂਸ਼ਨ ਦੁਆਰਾ ਇੱਕ ਟੇਬਲ ਵਾਲੇ ਇੱਕ ਡੇਟਾਬੇਸ ਤੋਂ ਇਹ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਹਰ ਚੀਜ਼ ਸਧਾਰਨ ਹੈ. ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:

ਅਸੀਂ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਜੋੜਦੇ ਹਾਂ resty.mysql, ਜੋ ਕਿ ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਕਿੱਟ ਵਿੱਚ ਹੈ। ਸਾਨੂੰ ਕੁਝ ਵੀ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਸਭ ਕੁਝ ਤਿਆਰ ਹੈ। ਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਕਿਵੇਂ ਕਨੈਕਟ ਕਰਨਾ ਹੈ ਅਤੇ ਇੱਕ SQL ਪੁੱਛਗਿੱਛ ਕਿਵੇਂ ਕਰਨੀ ਹੈ:

ਇਹ ਥੋੜਾ ਡਰਾਉਣਾ ਹੈ, ਪਰ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ। ਇੱਥੇ 10 ਸੀਮਾ ਹੈ। ਅਸੀਂ 10 ਰਿਕਾਰਡਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦੇ ਹਾਂ, ਅਸੀਂ ਆਲਸੀ ਹਾਂ, ਅਸੀਂ ਹੋਰ ਦਿਖਾਉਣਾ ਨਹੀਂ ਚਾਹੁੰਦੇ। SQL ਵਿੱਚ, ਮੈਂ ਸੀਮਾ ਬਾਰੇ ਭੁੱਲ ਗਿਆ.

ਫਿਰ ਅਸੀਂ ਸਾਰੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਲਈ ਚਿੱਤਰ ਲੱਭਦੇ ਹਾਂ। ਅਸੀਂ ਬੇਨਤੀਆਂ ਦਾ ਇੱਕ ਸਮੂਹ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਲੂਆ ਟੇਬਲ ਭਰਦੇ ਹਾਂ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ reqs, ਅਤੇ ਕਰੋ ngx.location.capture_multi.

ਇਹ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਸਮਾਨਾਂਤਰ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਜਵਾਬ ਸਾਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ. ਚੱਲਣ ਦਾ ਸਮਾਂ ਸਭ ਤੋਂ ਹੌਲੀ ਦੇ ਜਵਾਬ ਸਮੇਂ ਦੇ ਬਰਾਬਰ ਹੈ। ਜੇਕਰ ਅਸੀਂ ਸਾਰੇ 50 ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਵਾਪਸ ਸ਼ੂਟ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਸੌ ਬੇਨਤੀਆਂ ਭੇਜਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ 50 ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਇੱਕ ਜਵਾਬ ਮਿਲੇਗਾ।

ਕਿਉਂਕਿ ਅਸੀਂ ਆਲਸੀ ਹਾਂ ਅਤੇ HTTP ਹੈਂਡਲਿੰਗ ਅਤੇ ਕੈਚਿੰਗ ਨਹੀਂ ਲਿਖਣਾ ਚਾਹੁੰਦੇ, ਅਸੀਂ NGINX ਨੂੰ ਸਾਡੇ ਲਈ ਸਭ ਕੁਝ ਕਰਨ ਲਈ ਤਿਆਰ ਕਰਾਂਗੇ। ਜਿਵੇਂ ਤੁਸੀਂ ਦੇਖਿਆ ਸੀ, ਲਈ ਬੇਨਤੀ ਸੀ url/fetch, ਉਹ ਇੱਥੇ ਹੈ:

ਅਸੀਂ ਸਧਾਰਨ ਬਣਾਉਂਦੇ ਹਾਂ proxy_pass, ਨਿਰਧਾਰਿਤ ਕਰੋ ਕਿ ਕਿੱਥੇ ਕੈਸ਼ ਕਰਨਾ ਹੈ, ਇਸਨੂੰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਅਤੇ ਸਭ ਕੁਝ ਸਾਡੇ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ।

ਪਰ ਇਹ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ, ਸਾਨੂੰ ਅਜੇ ਵੀ ਉਪਭੋਗਤਾ ਨੂੰ ਡੇਟਾ ਦੇਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਸਭ ਤੋਂ ਸਰਲ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਹਰ ਚੀਜ਼ ਨੂੰ JSON ਲਈ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਨਾ, ਆਸਾਨੀ ਨਾਲ, ਦੋ ਲਾਈਨਾਂ ਵਿੱਚ। ਅਸੀਂ ਸਮੱਗਰੀ-ਕਿਸਮ ਦਿੰਦੇ ਹਾਂ, ਅਸੀਂ JSON ਦਿੰਦੇ ਹਾਂ।

ਪਰ ਇੱਕ ਮੁਸ਼ਕਲ ਹੈ: ਉਪਭੋਗਤਾ JSON ਨੂੰ ਪੜ੍ਹਨਾ ਨਹੀਂ ਚਾਹੁੰਦਾ ਹੈ. ਸਾਨੂੰ ਫਰੰਟ-ਐਂਡ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਆਕਰਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਕਦੇ-ਕਦੇ ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਅਜਿਹਾ ਕਰਨਾ ਪਸੰਦ ਨਹੀਂ ਕਰਦੇ। ਹਾਂ, ਅਤੇ ਐਸਈਓ ਮਾਹਰ ਇਹ ਕਹਿਣਗੇ ਕਿ ਜੇ ਅਸੀਂ ਤਸਵੀਰਾਂ ਲੱਭ ਰਹੇ ਹਾਂ, ਤਾਂ ਉਹ ਪਰਵਾਹ ਨਹੀਂ ਕਰਦੇ. ਅਤੇ ਜੇ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਕੁਝ ਸਮੱਗਰੀ ਦਿੰਦੇ ਹਾਂ, ਤਾਂ ਉਹ ਕਹਿਣਗੇ ਕਿ ਸਾਡੇ ਖੋਜ ਇੰਜਣ ਕੁਝ ਵੀ ਇੰਡੈਕਸ ਨਹੀਂ ਕਰਦੇ.

ਇਸ ਨਾਲ ਕੀ ਕਰਨਾ ਹੈ? ਬੇਸ਼ੱਕ, ਅਸੀਂ ਉਪਭੋਗਤਾ ਨੂੰ HTML ਦੇਵਾਂਗੇ. ਹੈਂਡਲਜ਼ ਨਾਲ ਤਿਆਰ ਕਰਨਾ ਗਲਤ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਟੈਂਪਲੇਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇਸਦੇ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ lua-resty-template.

ਤੁਸੀਂ ਤਿੰਨ ਭਿਆਨਕ ਅੱਖਰ ਓਪੀਐਮ ਦੇਖੇ ਹੋਣਗੇ। OpenResty ਇਸਦੇ ਆਪਣੇ ਪੈਕੇਜ ਮੈਨੇਜਰ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ, ਜਿਸ ਦੁਆਰਾ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਮੋਡੀਊਲਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਸਥਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਖਾਸ ਤੌਰ 'ਤੇ, lua-resty-template. ਇਹ ਇੱਕ ਸਧਾਰਨ ਟੈਂਪਲੇਟ ਇੰਜਣ ਹੈ ਜੋ Django ਟੈਂਪਲੇਟਸ ਵਰਗਾ ਹੈ। ਉੱਥੇ ਤੁਸੀਂ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਵੇਰੀਏਬਲ ਬਦਲ ਸਕਦੇ ਹੋ।

ਨਤੀਜੇ ਵਜੋਂ, ਸਭ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

ਅਸੀਂ ਡੇਟਾ ਲਿਆ ਅਤੇ ਟੈਂਪਲੇਟ ਨੂੰ ਦੋ ਲਾਈਨਾਂ ਵਿੱਚ ਦੁਬਾਰਾ ਰੈਂਡਰ ਕੀਤਾ। ਉਪਭੋਗਤਾ ਖੁਸ਼ ਹੈ, ਬਿੱਲੀਆਂ ਮਿਲੀਆਂ ਹਨ। ਕਿਉਂਕਿ ਅਸੀਂ ਬੇਨਤੀ ਦਾ ਵਿਸਤਾਰ ਕੀਤਾ ਹੈ, ਉਸ ਨੂੰ ਬਿੱਲੀ ਦੇ ਬੱਚਿਆਂ ਲਈ ਫਰ ਦੀ ਮੋਹਰ ਵੀ ਮਿਲੀ। ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਜਾਣਦੇ ਹੋ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਹ ਇਸਨੂੰ ਲੱਭ ਰਿਹਾ ਸੀ, ਪਰ ਉਹ ਆਪਣੀ ਬੇਨਤੀ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਤਿਆਰ ਨਹੀਂ ਕਰ ਸਕਿਆ.

ਸਭ ਕੁਝ ਵਧੀਆ ਹੈ, ਪਰ ਅਸੀਂ ਵਿਕਾਸ ਵਿੱਚ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਅਜੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਨਹੀਂ ਦਿਖਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਆਉ ਇੱਕ ਪ੍ਰਮਾਣਿਕਤਾ ਕਰੀਏ. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਆਓ ਦੇਖੀਏ ਕਿ ਕਿਵੇਂ NGINX ਓਪਨਰੇਸਟੀ ਦੇ ਰੂਪ ਵਿੱਚ ਬੇਨਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ:

• ਪਹਿਲਾ ਪੜਾਅ - ਪਹੁੰਚ, ਜਦੋਂ ਉਪਭੋਗਤਾ ਹੁਣੇ ਆਇਆ, ਅਤੇ ਅਸੀਂ ਉਸਨੂੰ ਸਿਰਲੇਖਾਂ ਦੁਆਰਾ, IP ਪਤੇ ਦੁਆਰਾ, ਹੋਰ ਡੇਟਾ ਦੁਆਰਾ ਦੇਖਿਆ। ਜੇਕਰ ਸਾਨੂੰ ਇਹ ਪਸੰਦ ਨਹੀਂ ਹੈ ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਤੁਰੰਤ ਕੱਟ ਸਕਦੇ ਹੋ। ਇਸਦੀ ਵਰਤੋਂ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਾਂ ਜੇਕਰ ਸਾਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਮਿਲਦੀਆਂ ਹਨ, ਤਾਂ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇਸ ਪੜਾਅ 'ਤੇ ਆਸਾਨੀ ਨਾਲ ਕੱਟ ਸਕਦੇ ਹਾਂ।
• ਮੁੜ ਲਿਖਣਾ. ਕੁਝ ਬੇਨਤੀ ਡੇਟਾ ਨੂੰ ਮੁੜ ਲਿਖਣਾ।
• ਸਮੱਗਰੀ ਨੂੰ. ਅਸੀਂ ਉਪਭੋਗਤਾ ਨੂੰ ਸਮੱਗਰੀ ਦਿੰਦੇ ਹਾਂ।
• ਸਿਰਲੇਖ ਫਿਲਟਰ. ਜਵਾਬ ਸਿਰਲੇਖ ਬਦਲੋ. ਜੇ ਅਸੀਂ ਵਰਤਿਆ proxy_pass, ਅਸੀਂ ਉਪਭੋਗਤਾ ਨੂੰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਸਿਰਲੇਖਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦੇ ਹਾਂ।
• ਸਰੀਰ ਫਿਲਟਰ. ਅਸੀਂ ਸਰੀਰ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਾਂ।
• ਲਾਗਇਨ - ਲਾਗਿੰਗ. ਬਿਨਾਂ ਕਿਸੇ ਵਾਧੂ ਲੇਅਰ ਦੇ elasticsearch ਵਿੱਚ ਲਾਗ ਲਿਖਣਾ ਸੰਭਵ ਹੈ।

ਸਾਡਾ ਅਧਿਕਾਰ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਾਂਗੇ location, ਜਿਸਦਾ ਅਸੀਂ ਪਹਿਲਾਂ ਵਰਣਨ ਕੀਤਾ ਹੈ, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਉੱਥੇ ਪਾ ਦਿੱਤਾ ਹੈ:

ਅਸੀਂ ਇਹ ਦੇਖਣ ਲਈ ਦੇਖਦੇ ਹਾਂ ਕਿ ਕੀ ਸਾਡੇ ਕੋਲ ਕੂਕੀ ਟੋਕਨ ਹੈ। ਜੇ ਨਹੀਂ, ਤਾਂ ਅਸੀਂ ਅਧਿਕਾਰ 'ਤੇ ਸੁੱਟ ਦਿੰਦੇ ਹਾਂ. ਉਪਭੋਗਤਾ ਚਲਾਕ ਹਨ ਅਤੇ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹਨ ਕਿ ਇੱਕ ਕੂਕੀ ਟੋਕਨ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ Redis ਵਿੱਚ ਵੀ ਪਾਵਾਂਗੇ:

Redis ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕੋਡ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਹੈ ਅਤੇ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਵੱਖਰਾ ਨਹੀਂ ਹੈ। ਉਸੇ ਸਮੇਂ, ਸਾਰੇ ਇਨਪੁਟ / ਆਉਟਪੁੱਟ, ਇੱਥੇ ਕੀ ਹੈ, ਇੱਥੇ ਕੀ ਹੈ, ਇਹ ਬਲਾਕ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ. ਜੇਕਰ ਤੁਸੀਂ ਸਮਕਾਲੀ ਕੋਡ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਇਹ ਅਸਿੰਕ੍ਰੋਨਸ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਜੈਵੈਂਟ ਦੇ ਨਾਲ, ਸਿਰਫ ਵਧੀਆ ਕੀਤਾ.

ਆਉ ਅਧਿਕਾਰ ਖੁਦ ਕਰੀਏ:

ਅਸੀਂ ਕਹਿੰਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਬੇਨਤੀ ਸਰੀਰ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਅਸੀਂ POST ਆਰਗੂਮੈਂਟਸ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਜਾਂਚ ਕਰੋ ਕਿ ਲੌਗਇਨ ਅਤੇ ਪਾਸਵਰਡ ਸਹੀ ਹਨ। ਜੇਕਰ ਗਲਤ ਹੈ, ਤਾਂ ਅਸੀਂ ਅਧਿਕਾਰ 'ਤੇ ਸੁੱਟ ਦਿੰਦੇ ਹਾਂ। ਅਤੇ ਜੇਕਰ ਉਹ ਸਹੀ ਹਨ, ਤਾਂ ਅਸੀਂ Redis ਨੂੰ ਟੋਕਨ ਲਿਖਦੇ ਹਾਂ:

ਕੂਕੀ ਨੂੰ ਸੈੱਟ ਕਰਨਾ ਨਾ ਭੁੱਲੋ, ਇਹ ਦੋ ਲਾਈਨਾਂ ਵਿੱਚ ਵੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

ਉਦਾਹਰਨ ਸਧਾਰਨ, ਅੰਦਾਜ਼ਾ ਹੈ. ਬੇਸ਼ੱਕ, ਅਸੀਂ ਅਜਿਹੀ ਸੇਵਾ ਨਹੀਂ ਕਰਾਂਗੇ ਜੋ ਲੋਕਾਂ ਨੂੰ ਬਿੱਲੀਆਂ ਦਿਖਾਉਂਦੀ ਹੋਵੇ। ਪਰ ਸਾਨੂੰ ਕੌਣ ਜਾਣਦਾ ਹੈ। ਇਸ ਲਈ ਆਓ ਦੇਖੀਏ ਕਿ ਉਤਪਾਦਨ ਵਿੱਚ ਕੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

• ਨਿਊਨਤਮ ਬੈਕਐਂਡ. ਕਈ ਵਾਰ ਸਾਨੂੰ ਬੈਕਐਂਡ ਨੂੰ ਬਹੁਤ ਸਾਰਾ ਡਾਟਾ ਦੇਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ: ਕਿਤੇ ਸਾਨੂੰ ਤਾਰੀਖ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਕਿਤੇ ਸਾਨੂੰ ਕਿਸੇ ਕਿਸਮ ਦੀ ਸੂਚੀ ਦਿਖਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਦੱਸੋ ਕਿ ਹੁਣ ਸਾਈਟ 'ਤੇ ਕਿੰਨੇ ਉਪਭੋਗਤਾ ਹਨ, ਕਾਊਂਟਰ ਜਾਂ ਅੰਕੜਿਆਂ 'ਤੇ ਪੇਚ ਕਰੋ। ਕੁਝ ਇੰਨਾ ਛੋਟਾ। ਕੁਝ ਘੱਟੋ-ਘੱਟ ਟੁਕੜੇ ਬਹੁਤ ਆਸਾਨੀ ਨਾਲ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ। ਇਹ ਤੇਜ਼, ਆਸਾਨ ਅਤੇ ਸ਼ਾਨਦਾਰ ਹੋਵੇਗਾ।
• ਡਾਟਾ ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ. ਕਈ ਵਾਰ ਅਸੀਂ ਆਪਣੇ ਪੰਨੇ ਵਿੱਚ ਇਸ਼ਤਿਹਾਰਾਂ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਇਹਨਾਂ ਵਿਗਿਆਪਨਾਂ ਨੂੰ API ਬੇਨਤੀਆਂ ਨਾਲ ਲੈਂਦੇ ਹਾਂ। ਇੱਥੇ ਇਹ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ। ਅਸੀਂ ਆਪਣੇ ਬੈਕਐਂਡ ਨੂੰ ਲੋਡ ਨਹੀਂ ਕਰਦੇ, ਜੋ ਪਹਿਲਾਂ ਹੀ ਸਖ਼ਤ ਮਿਹਨਤ ਕਰ ਰਿਹਾ ਹੈ. ਤੁਸੀਂ ਇੱਥੇ ਚੁੱਕ ਸਕਦੇ ਹੋ ਅਤੇ ਇਕੱਠਾ ਕਰ ਸਕਦੇ ਹੋ। ਅਸੀਂ ਕੁਝ JS ਨੂੰ ਮੋਲਡ ਕਰ ਸਕਦੇ ਹਾਂ ਜਾਂ, ਇਸਦੇ ਉਲਟ, ਅਨਸਟਿੱਕ, ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਕਰ ਸਕਦੇ ਹਾਂ।
• ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਲਈ ਨਕਾਬ. ਇਹ ਵੀ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਕੇਸ ਹੈ, ਮੈਂ ਇਸਨੂੰ ਲਾਗੂ ਕੀਤਾ. ਇਸ ਤੋਂ ਪਹਿਲਾਂ, ਮੈਂ ਟੈਂਜ਼ੋਰ ਲਈ ਕੰਮ ਕੀਤਾ, ਇੱਕ ਇਲੈਕਟ੍ਰਾਨਿਕ ਰਿਪੋਰਟਿੰਗ ਕੰਪਨੀ ਜੋ ਦੇਸ਼ ਵਿੱਚ ਲਗਭਗ ਅੱਧੀਆਂ ਕਾਨੂੰਨੀ ਸੰਸਥਾਵਾਂ ਲਈ ਰਿਪੋਰਟਿੰਗ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਅਸੀਂ ਇੱਕ ਸੇਵਾ ਬਣਾਈ ਹੈ, ਉੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਇੱਕੋ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ: ਰੂਟਿੰਗ, ਅਧਿਕਾਰ, ਅਤੇ ਹੋਰ।
  ਓਪਨਰੇਸਟੀ ਨੂੰ ਤੁਹਾਡੀਆਂ ਮਾਈਕਰੋਸੇਵਾਵਾਂ ਲਈ ਗੂੰਦ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਹਰ ਚੀਜ਼ ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਇੰਟਰਫੇਸ ਲਈ ਸਿੰਗਲ ਐਕਸੈਸ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾ ਸਕੇ। ਕਿਉਂਕਿ ਮਾਈਕ੍ਰੋਸਰਵਿਸਿਜ਼ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਇੱਥੇ Node.js ਹੈ, ਤੁਹਾਡੇ ਕੋਲ ਇੱਥੇ PHP ਹੈ, ਤੁਹਾਡੇ ਕੋਲ ਇੱਥੇ ਪਾਈਥਨ ਹੈ, ਇੱਥੇ ਕੁਝ ਅਰਲਾਂਗ ਚੀਜ਼ ਹੈ, ਅਸੀਂ ਸਮਝਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਹਰ ਥਾਂ ਇੱਕੋ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਲਿਖਣਾ ਚਾਹੁੰਦੇ। ਇਸ ਲਈ, ਓਪਨਰੇਸਟੀ ਨੂੰ ਫਰੰਟ ਵਿੱਚ ਪਲੱਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

• ਅੰਕੜੇ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ. ਆਮ ਤੌਰ 'ਤੇ NGINX ਪ੍ਰਵੇਸ਼ ਦੁਆਰ 'ਤੇ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਇਸ ਵਿੱਚੋਂ ਲੰਘਦੀਆਂ ਹਨ। ਇਹ ਇਸ ਥਾਂ 'ਤੇ ਹੈ ਕਿ ਇਹ ਇਕੱਠਾ ਕਰਨਾ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ. ਤੁਸੀਂ ਤੁਰੰਤ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਿਤੇ ਸੁੱਟ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਉਹੀ Elasticsearch, Logstash, ਜਾਂ ਸਿਰਫ਼ ਇਸਨੂੰ ਲੌਗ ਵਿੱਚ ਲਿਖੋ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਕਿਤੇ ਭੇਜੋ।
• ਮਲਟੀ-ਯੂਜ਼ਰ ਸਿਸਟਮ. ਉਦਾਹਰਨ ਲਈ, ਔਨਲਾਈਨ ਗੇਮਾਂ ਕਰਨ ਲਈ ਵੀ ਬਹੁਤ ਵਧੀਆ ਹਨ. ਅੱਜ ਕੇਪ ਟਾਊਨ ਵਿੱਚ ਅਲੈਗਜ਼ੈਂਡਰ ਗਲੇਡਿਸ਼ ਤੁਹਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਓਪਨਰੇਸਟੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਮਲਟੀਪਲੇਅਰ ਗੇਮ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਕਿਵੇਂ ਪ੍ਰੋਟੋਟਾਈਪ ਕਰਨਾ ਹੈ।
• ਫਿਲਟਰਿੰਗ ਦੀ ਬੇਨਤੀ (WAF). ਹੁਣ ਹਰ ਕਿਸਮ ਦੇ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਫਾਇਰਵਾਲ ਬਣਾਉਣਾ ਫੈਸ਼ਨਯੋਗ ਹੈ, ਬਹੁਤ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਹਨ ਜੋ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ. ਓਪਨਰੇਸਟੀ ਦੀ ਮਦਦ ਨਾਲ, ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਇੱਕ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਫਾਇਰਵਾਲ ਬਣਾ ਸਕਦੇ ਹੋ, ਜੋ ਤੁਹਾਡੀਆਂ ਜ਼ਰੂਰਤਾਂ ਦੇ ਅਨੁਸਾਰ ਆਸਾਨੀ ਨਾਲ ਅਤੇ ਆਸਾਨੀ ਨਾਲ ਬੇਨਤੀਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰੇਗਾ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਪਾਈਥਨ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਸਮਝਦੇ ਹੋ ਕਿ PHP ਨਿਸ਼ਚਤ ਤੌਰ 'ਤੇ ਤੁਹਾਡੇ ਲਈ ਟੀਕਾ ਨਹੀਂ ਲਗਾਇਆ ਜਾਵੇਗਾ, ਜਦੋਂ ਤੱਕ, ਬੇਸ਼ਕ, ਤੁਸੀਂ ਇਸ ਨੂੰ ਕੰਸੋਲ ਤੋਂ ਕਿਤੇ ਵੀ ਨਹੀਂ ਫੈਲਾਉਂਦੇ ਹੋ. ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਕੋਲ MySQL ਅਤੇ Python ਹੈ। ਸੰਭਵ ਤੌਰ 'ਤੇ, ਇੱਥੇ ਉਹ ਕਿਸੇ ਕਿਸਮ ਦੀ ਡਾਇਰੈਕਟਰੀ ਟ੍ਰਾਵਰਸਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੁਝ ਇੰਜੈਕਟ ਕਰ ਸਕਦੇ ਹਨ. ਇਸ ਲਈ, ਤੁਸੀਂ ਮੂਹਰਲੇ ਪਾਸੇ ਤੁਰੰਤ ਅਤੇ ਸਸਤੇ ਤੌਰ 'ਤੇ ਮੂੰਗੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ।
• ਕਮਿ Communityਨਿਟੀ. ਕਿਉਂਕਿ OpenResty NGINX 'ਤੇ ਅਧਾਰਤ ਹੈ, ਇਸ ਵਿੱਚ ਇੱਕ ਬੋਨਸ ਹੈ - ਇਹ ਹੈ NGINX ਕਮਿਊਨਿਟੀ. ਇਹ ਬਹੁਤ ਵੱਡਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਬਹੁਤ ਸਾਰੇ ਸਵਾਲਾਂ ਦਾ ਜਵਾਬ NGINX ਕਮਿਊਨਿਟੀ ਦੁਆਰਾ ਪਹਿਲਾਂ ਹੀ ਦਿੱਤਾ ਜਾ ਚੁੱਕਾ ਹੈ।

  Lua ਡਿਵੈਲਪਰ. ਕੱਲ੍ਹ ਮੈਂ ਹਾਈਲੋਡ ++ ਸਿਖਲਾਈ ਵਾਲੇ ਦਿਨ ਆਏ ਮੁੰਡਿਆਂ ਨਾਲ ਗੱਲ ਕੀਤੀ ਅਤੇ ਸੁਣਿਆ ਕਿ ਲੂਆ ਵਿੱਚ ਸਿਰਫ ਤਰਨਟੂਲ ਲਿਖਿਆ ਹੋਇਆ ਹੈ। ਅਜਿਹਾ ਨਹੀਂ ਹੈ, ਲੂਆ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਗੱਲਾਂ ਲਿਖੀਆਂ ਗਈਆਂ ਹਨ। ਉਦਾਹਰਨਾਂ: OpenResty, Prosody XMPP ਸਰਵਰ, Love2D ਗੇਮ ਇੰਜਣ, Lua ਨੂੰ Warcraft ਅਤੇ ਹੋਰ ਕਿਤੇ ਵੀ ਸਕ੍ਰਿਪਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਲੁਆ ਡਿਵੈਲਪਰ ਹਨ, ਉਹਨਾਂ ਕੋਲ ਇੱਕ ਵਿਸ਼ਾਲ ਅਤੇ ਜਵਾਬਦੇਹ ਭਾਈਚਾਰਾ ਹੈ। ਮੇਰੇ ਸਾਰੇ ਲੂਆ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਕੁਝ ਘੰਟਿਆਂ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਸਨ. ਜਦੋਂ ਤੁਸੀਂ ਮੇਲਿੰਗ ਸੂਚੀ ਵਿੱਚ ਲਿਖਦੇ ਹੋ, ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਜਵਾਬਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ, ਉਹ ਵਰਣਨ ਕਰਦੇ ਹਨ ਕਿ ਕੀ ਅਤੇ ਕਿਵੇਂ, ਕੀ ਹੈ. ਬਹੁਤ ਵਧਿਆ. ਬਦਕਿਸਮਤੀ ਨਾਲ, ਅਜਿਹਾ ਸੁਹਿਰਦ ਭਾਈਚਾਰਾ ਹਰ ਜਗ੍ਹਾ ਨਹੀਂ ਹੈ।
  OpenResty ਕੋਲ GitHub ਹੈ, ਜਿੱਥੇ ਤੁਸੀਂ ਕੋਈ ਮੁੱਦਾ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ ਜੇਕਰ ਕੁਝ ਟੁੱਟਦਾ ਹੈ. ਗੂਗਲ ਸਮੂਹਾਂ 'ਤੇ ਇੱਕ ਮੇਲਿੰਗ ਸੂਚੀ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਆਮ ਮੁੱਦਿਆਂ 'ਤੇ ਚਰਚਾ ਕਰ ਸਕਦੇ ਹੋ, ਚੀਨੀ ਵਿੱਚ ਇੱਕ ਮੇਲਿੰਗ ਸੂਚੀ ਹੈ - ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਜਾਣਦੇ ਹੋ, ਸ਼ਾਇਦ ਤੁਸੀਂ ਅੰਗਰੇਜ਼ੀ ਨਹੀਂ ਬੋਲਦੇ ਹੋ, ਪਰ ਤੁਹਾਨੂੰ ਚੀਨੀ ਭਾਸ਼ਾ ਦਾ ਗਿਆਨ ਹੈ।

ਨਤੀਜੇ

• ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੈਂ ਇਹ ਦੱਸਣ ਦੇ ਯੋਗ ਸੀ ਕਿ ਓਪਨਰੇਸਟੀ ਵੈੱਬ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਇੱਕ ਬਹੁਤ ਹੀ ਸੁਵਿਧਾਜਨਕ ਫਰੇਮਵਰਕ ਹੈ।
• ਇਸ ਵਿੱਚ ਦਾਖਲੇ ਦੀ ਇੱਕ ਘੱਟ ਥ੍ਰੈਸ਼ਹੋਲਡ ਹੈ, ਕਿਉਂਕਿ ਕੋਡ ਸਾਡੇ ਦੁਆਰਾ ਲਿਖੇ ਸਮਾਨ ਹੈ, ਭਾਸ਼ਾ ਕਾਫ਼ੀ ਸਰਲ ਅਤੇ ਨਿਊਨਤਮ ਹੈ।
• ਇਹ ਕਾਲਬੈਕਾਂ ਤੋਂ ਬਿਨਾਂ ਅਸਿੰਕ੍ਰੋਨਸ I/O ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਸਾਡੇ ਕੋਲ ਨੂਡਲਜ਼ ਨਹੀਂ ਹੋਣਗੇ ਕਿਉਂਕਿ ਅਸੀਂ ਕਈ ਵਾਰ NodeJS ਵਿੱਚ ਲਿਖ ਸਕਦੇ ਹਾਂ।
• ਇਸਦੀ ਇੱਕ ਆਸਾਨ ਤੈਨਾਤੀ ਹੈ, ਕਿਉਂਕਿ ਸਾਨੂੰ ਸਿਰਫ ਸਹੀ ਮੋਡੀਊਲ ਅਤੇ ਸਾਡੇ ਕੋਡ ਦੇ ਨਾਲ NGINX ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਸਭ ਕੁਝ ਤੁਰੰਤ ਕੰਮ ਕਰਦਾ ਹੈ।
• ਵੱਡਾ ਅਤੇ ਜਵਾਬਦੇਹ ਭਾਈਚਾਰਾ।

ਮੈਂ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਦੱਸਿਆ ਕਿ ਰੂਟਿੰਗ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਹ ਇੱਕ ਬਹੁਤ ਲੰਬੀ ਕਹਾਣੀ ਨਿਕਲੀ.

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ!

ਵਲਾਦੀਮੀਰ ਪ੍ਰੋਟਾਸੋਵ - ਓਪਨਰੇਸਟੀ: NGINX ਨੂੰ ਇੱਕ ਪੂਰੇ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ ਵਿੱਚ ਬਦਲਣਾ

ਸਰੋਤ: www.habr.com