ਮੈਂ ਅਧਿਕਾਰ ਅਤੇ S3 ਨਾਲ ਆਪਣੀ ਖੁਦ ਦੀ PyPI ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਈ ਹੈ। Nginx 'ਤੇ

ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਆਪਣੇ ਤਜ਼ਰਬੇ ਨੂੰ NJS ਨਾਲ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹਾਂਗਾ, Nginx Inc ਦੁਆਰਾ ਵਿਕਸਤ Nginx ਲਈ ਇੱਕ JavaScript ਦੁਭਾਸ਼ੀਏ, ਇੱਕ ਅਸਲ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਸਦੀਆਂ ਮੁੱਖ ਸਮਰੱਥਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋਏ। NJS JavaScript ਦਾ ਇੱਕ ਸਬਸੈੱਟ ਹੈ ਜੋ ਤੁਹਾਨੂੰ Nginx ਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਵਧਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਸਵਾਲ ਨੂੰ ਤੁਹਾਡਾ ਆਪਣਾ ਦੁਭਾਸ਼ੀਏ ਕਿਉਂ??? ਦਮਿੱਤਰੀ Volyntsev ਵਿਸਥਾਰ ਵਿੱਚ ਜਵਾਬ ਦਿੱਤਾ. ਸੰਖੇਪ ਵਿੱਚ: NJS nginx-way ਹੈ, ਅਤੇ JavaScript ਵਧੇਰੇ ਪ੍ਰਗਤੀਸ਼ੀਲ, "ਮੂਲ" ਅਤੇ GC ਤੋਂ ਬਿਨਾਂ, Lua ਦੇ ਉਲਟ ਹੈ।

ਬਹੁਤ ਚਿਰ ਪਹਿਲਾਂ…

ਮੇਰੀ ਆਖਰੀ ਨੌਕਰੀ 'ਤੇ, ਮੈਨੂੰ ਡੌਕਰ-ਕੰਪੋਜ਼, ਡਿੰਡ ਅਤੇ ਹੋਰ ਪ੍ਰਸੰਨਤਾਵਾਂ ਦੇ ਨਾਲ ਕਈ ਮੋਟਲੇ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਦੇ ਨਾਲ ਗਿਟਲੈਬ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲੀ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਕਨੀਕੋ ਰੇਲਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਗਿਆ ਸੀ। ਉਹ ਚਿੱਤਰ ਜੋ ਪਹਿਲਾਂ CI ਵਿੱਚ ਵਰਤੇ ਗਏ ਸਨ ਉਹਨਾਂ ਦੇ ਅਸਲ ਰੂਪ ਵਿੱਚ ਚਲੇ ਗਏ ਸਨ। ਉਨ੍ਹਾਂ ਨੇ ਉਸ ਦਿਨ ਤੱਕ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕੀਤਾ ਜਦੋਂ ਸਾਡਾ ਗਿਟਲੈਬ ਆਈਪੀ ਬਦਲ ਗਿਆ ਅਤੇ ਸੀਆਈ ਇੱਕ ਪੇਠਾ ਵਿੱਚ ਬਦਲ ਗਿਆ. ਸਮੱਸਿਆ ਇਹ ਸੀ ਕਿ ਸੀਆਈ ਵਿੱਚ ਹਿੱਸਾ ਲੈਣ ਵਾਲੇ ਡੌਕਰ ਚਿੱਤਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ git ਸੀ, ਜੋ ਪਾਈਥਨ ਮੋਡੀਊਲ ਨੂੰ ssh ਦੁਆਰਾ ਖਿੱਚਦਾ ਸੀ। ssh ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਦੀ ਲੋੜ ਹੈ ਅਤੇ... ਇਹ ਜਾਣਿਆ_ਹੋਸਟ ਦੇ ਨਾਲ ਚਿੱਤਰ ਵਿੱਚ ਸੀ। ਅਤੇ ਕੋਈ ਵੀ CI ਅਸਲ IP ਅਤੇ known_hosts ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਇੱਕ ਵਿੱਚ ਮੇਲ ਨਾ ਹੋਣ ਕਾਰਨ ਇੱਕ ਮੁੱਖ ਤਸਦੀਕ ਗਲਤੀ ਨਾਲ ਅਸਫਲ ਹੋਇਆ। ਮੌਜੂਦਾ ਡੌਕਫਾਈਲਾਂ ਤੋਂ ਇੱਕ ਨਵੀਂ ਚਿੱਤਰ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਇਕੱਠਾ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਵਿਕਲਪ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ StrictHostKeyChecking no. ਪਰ ਮਾੜਾ ਸੁਆਦ ਬਣਿਆ ਰਿਹਾ ਅਤੇ ਲਿਬਸ ਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ PyPI ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਲਿਜਾਣ ਦੀ ਇੱਛਾ ਸੀ। ਇੱਕ ਵਾਧੂ ਬੋਨਸ, ਪ੍ਰਾਈਵੇਟ PyPI 'ਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸਰਲ ਪਾਈਪਲਾਈਨ ਸੀ ਅਤੇ ਲੋੜਾਂ ਦਾ ਇੱਕ ਸਧਾਰਨ ਵਰਣਨ ਸੀ.txt

ਚੋਣ ਕੀਤੀ ਗਈ ਹੈ, ਸੱਜਣ!

ਅਸੀਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਕਲਾਉਡ ਅਤੇ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਚਲਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਅੰਤ ਵਿੱਚ ਅਸੀਂ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸੇਵਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ ਜੋ ਬਾਹਰੀ ਸਟੋਰੇਜ ਦੇ ਨਾਲ ਇੱਕ ਸਟੇਟਲੈੱਸ ਕੰਟੇਨਰ ਸੀ। ਖੈਰ, ਕਿਉਂਕਿ ਅਸੀਂ S3 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਇਸ ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ ਗਈ ਸੀ। ਅਤੇ, ਜੇ ਸੰਭਵ ਹੋਵੇ, gitlab ਵਿੱਚ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ ਨਾਲ (ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਜੋੜ ਸਕਦੇ ਹੋ)।

ਇੱਕ ਤੇਜ਼ ਖੋਜ ਨੇ ਕਈ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕੀਤੇ: s3pypi, pypicloud ਅਤੇ turnips ਲਈ html ਫਾਈਲਾਂ ਦੀ "ਮੈਨੂਅਲ" ਰਚਨਾ ਦੇ ਨਾਲ ਇੱਕ ਵਿਕਲਪ। ਆਖਰੀ ਵਿਕਲਪ ਆਪਣੇ ਆਪ ਅਲੋਪ ਹੋ ਗਿਆ.

s3pypi: ਇਹ S3 ਹੋਸਟਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਇੱਕ ਕਲੀ ਹੈ। ਅਸੀਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰਦੇ ਹਾਂ, html ਤਿਆਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਉਸੇ ਬਾਲਟੀ ਵਿੱਚ ਅਪਲੋਡ ਕਰਦੇ ਹਾਂ। ਘਰੇਲੂ ਵਰਤੋਂ ਲਈ ਢੁਕਵਾਂ।

pypicloud: ਇਹ ਇੱਕ ਦਿਲਚਸਪ ਪ੍ਰੋਜੈਕਟ ਦੀ ਤਰ੍ਹਾਂ ਜਾਪਦਾ ਸੀ, ਪਰ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ ਮੈਂ ਨਿਰਾਸ਼ ਹੋ ਗਿਆ ਸੀ। ਚੰਗੇ ਦਸਤਾਵੇਜ਼ਾਂ ਅਤੇ ਤੁਹਾਡੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਵਿਸਤਾਰ ਕਰਨ ਦੀ ਯੋਗਤਾ ਦੇ ਬਾਵਜੂਦ, ਅਸਲ ਵਿੱਚ ਇਹ ਬੇਲੋੜਾ ਅਤੇ ਕੌਂਫਿਗਰ ਕਰਨਾ ਮੁਸ਼ਕਲ ਸਾਬਤ ਹੋਇਆ। ਉਸ ਸਮੇਂ ਦੇ ਅਨੁਮਾਨਾਂ ਅਨੁਸਾਰ, ਤੁਹਾਡੇ ਕਾਰਜਾਂ ਦੇ ਅਨੁਕੂਲ ਕੋਡ ਨੂੰ ਠੀਕ ਕਰਨ ਵਿੱਚ 3-5 ਦਿਨ ਲੱਗ ਜਾਣਗੇ। ਸੇਵਾ ਨੂੰ ਇੱਕ ਡੇਟਾਬੇਸ ਦੀ ਵੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜੇ ਸਾਨੂੰ ਹੋਰ ਕੁਝ ਨਹੀਂ ਮਿਲਿਆ।

ਇੱਕ ਹੋਰ ਡੂੰਘਾਈ ਨਾਲ ਖੋਜ ਨੇ Nginx, ngx_aws_auth ਲਈ ਇੱਕ ਮੋਡੀਊਲ ਪ੍ਰਾਪਤ ਕੀਤਾ। ਉਸਦੀ ਜਾਂਚ ਦਾ ਨਤੀਜਾ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ XML ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਵਿੱਚ S3 ਬਾਲਟੀ ਦੀ ਸਮੱਗਰੀ ਦਿਖਾਈ ਗਈ ਸੀ। ਖੋਜ ਦੇ ਸਮੇਂ ਆਖਰੀ ਵਚਨਬੱਧਤਾ ਇੱਕ ਸਾਲ ਪਹਿਲਾਂ ਸੀ. ਭੰਡਾਰ ਛੱਡਿਆ ਹੋਇਆ ਦਿਖਾਈ ਦੇ ਰਿਹਾ ਸੀ।

ਸਰੋਤ ਤੇ ਜਾ ਕੇ ਪੜ੍ਹਨਾ ਪੀਈਪੀ -503 ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ XML ਨੂੰ ਫਲਾਈ 'ਤੇ HTML ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਪਾਈਪ ਨੂੰ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। Nginx ਅਤੇ S3 ਬਾਰੇ ਥੋੜਾ ਹੋਰ ਗੂਗਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ Nginx ਲਈ JS ਵਿੱਚ ਲਿਖੇ S3 ਵਿੱਚ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਮਿਲੀ. ਇਸ ਤਰ੍ਹਾਂ ਮੈਂ NJS ਨੂੰ ਮਿਲਿਆ।

ਇਸ ਉਦਾਹਰਨ ਨੂੰ ਆਧਾਰ ਵਜੋਂ ਲੈਂਦੇ ਹੋਏ, ਇੱਕ ਘੰਟੇ ਬਾਅਦ ਮੈਂ ਆਪਣੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਉਹੀ XML ਦੇਖਿਆ ਜਿਵੇਂ ਕਿ ngx_aws_auth ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਪਰ ਸਭ ਕੁਝ ਪਹਿਲਾਂ ਹੀ JS ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਸੀ.

ਮੈਨੂੰ ਸੱਚਮੁੱਚ nginx ਹੱਲ ਪਸੰਦ ਆਇਆ. ਪਹਿਲਾਂ, ਚੰਗੇ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ, ਦੂਜਾ, ਸਾਨੂੰ ਫਾਈਲਾਂ (ਬਾਕਸ ਤੋਂ ਬਾਹਰ) ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ Nginx ਦੀਆਂ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਮਿਲਦੀਆਂ ਹਨ, ਤੀਜਾ, ਕੋਈ ਵੀ ਜੋ ਜਾਣਦਾ ਹੈ ਕਿ Nginx ਲਈ ਸੰਰਚਨਾ ਕਿਵੇਂ ਲਿਖਣੀ ਹੈ, ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੇ ਯੋਗ ਹੋਵੇਗਾ ਕਿ ਕੀ ਹੈ. ਪਾਇਥਨ ਜਾਂ ਗੋ (ਜੇਕਰ ਸਕ੍ਰੈਚ ਤੋਂ ਲਿਖਿਆ ਗਿਆ ਹੈ) ਦੇ ਮੁਕਾਬਲੇ, ਗਠਜੋੜ ਦਾ ਜ਼ਿਕਰ ਨਾ ਕਰਨ ਲਈ, ਘੱਟੋ ਘੱਟਵਾਦ ਵੀ ਮੇਰੇ ਲਈ ਇੱਕ ਪਲੱਸ ਹੈ।

TL;DR 2 ਦਿਨਾਂ ਬਾਅਦ, PyPi ਦਾ ਟੈਸਟ ਵਰਜਨ ਪਹਿਲਾਂ ਹੀ CI ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਸੀ।

ਇਸ ਨੂੰ ਕੰਮ ਕਰਦਾ ਹੈ?

ਮੋਡੀਊਲ Nginx ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ ngx_http_js_module, ਅਧਿਕਾਰਤ ਡੌਕਰ ਚਿੱਤਰ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਅਸੀਂ ਡਾਇਰੈਕਟਿਵ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਆਯਾਤ ਕਰਦੇ ਹਾਂ js_importNginx ਸੰਰਚਨਾ ਲਈ. ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਨਿਰਦੇਸ਼ ਦੁਆਰਾ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ js_content. ਡਾਇਰੈਕਟਿਵ ਦੀ ਵਰਤੋਂ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ js_set, ਜੋ ਕਿ ਸਿਰਫ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਵਰਣਿਤ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ। ਪਰ ਅਸੀਂ ਸਿਰਫ Nginx ਦੀ ਵਰਤੋਂ ਕਰਕੇ NJS ਵਿੱਚ ਸਬਕਵੇਰੀਆਂ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹਾਂ, ਨਾ ਕਿ ਕੋਈ XMLHttpRequest. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਨੁਸਾਰੀ ਸਥਾਨ ਨੂੰ Nginx ਸੰਰਚਨਾ ਵਿੱਚ ਜੋੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ. ਅਤੇ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਟਿਕਾਣੇ ਲਈ ਸਬ-ਰਿਵੇਸਟ ਦਾ ਵਰਣਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। Nginx ਸੰਰਚਨਾ ਤੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਹੀ ਨਿਰਯਾਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ export default.

nginx.conf

load_module modules/ngx_http_js_module.so;
http {
  js_import   imported_name  from script.js;

server {
  listen 8080;
  ...
  location = /sub-query {
    internal;

    proxy_pass http://upstream;
  }

  location / {
    js_content imported_name.request;
  }
}

script.js

function request(r) {
  function call_back(resp) {
    // handler's code
    r.return(resp.status, resp.responseBody);
  }

  r.subrequest('/sub-query', { method: r.method }, call_back);
}

export default {request}

ਜਦੋਂ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਬੇਨਤੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ http://localhost:8080/ ਅਸੀਂ ਅੰਦਰ ਆਉਂਦੇ ਹਾਂ location /ਜਿਸ ਵਿੱਚ ਨਿਰਦੇਸ਼ js_content ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ request ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ script.js. ਬਦਲੇ ਵਿੱਚ, ਫੰਕਸ਼ਨ ਵਿੱਚ request ਲਈ ਇੱਕ ਸਬਕਵੇਰੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ location = /sub-query, ਇੱਕ ਵਿਧੀ ਨਾਲ (ਮੌਜੂਦਾ ਉਦਾਹਰਨ GET ਵਿੱਚ) ਆਰਗੂਮੈਂਟ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਗਈ ਹੈ (r), ਜਦੋਂ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। subrequest ਜਵਾਬ ਫੰਕਸ਼ਨ ਵਿੱਚ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਵੇਗੀ call_back.

S3 ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ

ਨਿੱਜੀ S3 ਸਟੋਰੇਜ ਲਈ ਬੇਨਤੀ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਲੋੜ ਹੈ:

ACCESS_KEY

SECRET_KEY

S3_BUCKET

ਵਰਤੀ ਗਈ http ਵਿਧੀ ਤੋਂ, ਮੌਜੂਦਾ ਮਿਤੀ/ਸਮਾਂ, S3_NAME ਅਤੇ URI, ਇੱਕ ਖਾਸ ਕਿਸਮ ਦੀ ਸਤਰ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ SECRET_KEY ਦੀ ਵਰਤੋਂ ਕਰਕੇ (HMAC_SHA1) ਸਾਈਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅੱਗੇ ਇੱਕ ਲਾਈਨ ਵਰਗੀ ਹੈ AWS $ACCESS_KEY:$HASH, ਅਧਿਕਾਰ ਸਿਰਲੇਖ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਉਹੀ ਮਿਤੀ/ਸਮਾਂ ਜੋ ਪਿਛਲੇ ਪੜਾਅ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਗਿਆ ਸੀ ਸਿਰਲੇਖ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ X-amz-date. ਕੋਡ ਵਿੱਚ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

nginx.conf

load_module modules/ngx_http_js_module.so;
http {
  js_import   s3      from     s3.js;

  js_set      $s3_datetime     s3.date_now;
  js_set      $s3_auth         s3.s3_sign;

server {
  listen 8080;
  ...
  location ~* /s3-query/(?<s3_path>.*) {
    internal;

    proxy_set_header    X-amz-date     $s3_datetime;
    proxy_set_header    Authorization  $s3_auth;

    proxy_pass          $s3_endpoint/$s3_path;
  }

  location ~ "^/(?<prefix>[w-]*)[/]?(?<postfix>[w-.]*)$" {
    js_content s3.request;
  }
}

s3.js(AWS ਸਾਈਨ v2 ਪ੍ਰਮਾਣੀਕਰਨ ਉਦਾਹਰਨ, ਨਾਪਸੰਦ ਸਥਿਤੀ ਵਿੱਚ ਬਦਲੀ ਗਈ)

var crypt = require('crypto');

var s3_bucket = process.env.S3_BUCKET;
var s3_access_key = process.env.S3_ACCESS_KEY;
var s3_secret_key = process.env.S3_SECRET_KEY;
var _datetime = new Date().toISOString().replace(/[:-]|.d{3}/g, '');

function date_now() {
  return _datetime
}

function s3_sign(r) {
  var s2s = r.method + 'nnnn';

  s2s += `x-amz-date:${date_now()}n`;
  s2s += '/' + s3_bucket;
  s2s += r.uri.endsWith('/') ? '/' : r.variables.s3_path;

  return `AWS ${s3_access_key}:${crypt.createHmac('sha1', s3_secret_key).update(s2s).digest('base64')}`;
}

function request(r) {
  var v = r.variables;

  function call_back(resp) {
    r.return(resp.status, resp.responseBody);
  }

  var _subrequest_uri = r.uri;
  if (r.uri === '/') {
    // root
    _subrequest_uri = '/?delimiter=/';

  } else if (v.prefix !== '' && v.postfix === '') {
    // directory
    var slash = v.prefix.endsWith('/') ? '' : '/';
    _subrequest_uri = '/?prefix=' + v.prefix + slash;
  }

  r.subrequest(`/s3-query${_subrequest_uri}`, { method: r.method }, call_back);
}

export default {request, s3_sign, date_now}

ਬਾਰੇ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਵਿਆਖਿਆ _subrequest_uri: ਇਹ ਇੱਕ ਵੇਰੀਏਬਲ ਹੈ ਜੋ, ਸ਼ੁਰੂਆਤੀ uri 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, S3 ਨੂੰ ਬੇਨਤੀ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ "ਰੂਟ" ਦੀ ਸਮਗਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਡੀਲੀਮੀਟਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਯੂਰੀ ਬੇਨਤੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। delimiter, ਜੋ ਕਿ ਡਾਇਰੈਕਟਰੀਆਂ (PyPI ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਾਰੇ ਪੈਕੇਜਾਂ ਦੀ ਸੂਚੀ) ਦੇ ਅਨੁਸਾਰੀ, ਸਾਰੇ CommonPrefixes xml ਤੱਤਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰੇਗਾ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਿਸੇ ਖਾਸ ਡਾਇਰੈਕਟਰੀ (ਸਾਰੇ ਪੈਕੇਜ ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ) ਵਿੱਚ ਸਮੱਗਰੀ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ uri ਬੇਨਤੀ ਵਿੱਚ ਡਾਇਰੈਕਟਰੀ (ਪੈਕੇਜ) ਦੇ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਅਗੇਤਰ ਖੇਤਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਸਲੈਸ਼ / ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, ਉਦਾਹਰਨ ਲਈ, ਡਾਇਰੈਕਟਰੀ ਦੀ ਸਮੱਗਰੀ ਦੀ ਬੇਨਤੀ ਕਰਨ ਵੇਲੇ ਟੱਕਰ ਸੰਭਵ ਹੈ। ਡਾਇਰੈਕਟਰੀਆਂ ਹਨ aiohttp-request ਅਤੇ aiohttp-requests ਅਤੇ ਜੇਕਰ ਬੇਨਤੀ ਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ /?prefix=aiohttp-request, ਫਿਰ ਜਵਾਬ ਵਿੱਚ ਦੋਵੇਂ ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸਮੱਗਰੀ ਸ਼ਾਮਲ ਹੋਵੇਗੀ। ਜੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਸਲੈਸ਼ ਹੈ, /?prefix=aiohttp-request/, ਫਿਰ ਜਵਾਬ ਵਿੱਚ ਸਿਰਫ਼ ਲੋੜੀਂਦੀ ਡਾਇਰੈਕਟਰੀ ਹੋਵੇਗੀ। ਅਤੇ ਜੇਕਰ ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਦੀ ਬੇਨਤੀ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਨਤੀਜਾ uri ਅਸਲ ਇੱਕ ਤੋਂ ਵੱਖਰਾ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

Nginx ਨੂੰ ਸੇਵ ਅਤੇ ਰੀਸਟਾਰਟ ਕਰੋ। ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਅਸੀਂ ਆਪਣੇ Nginx ਦਾ ਪਤਾ ਦਾਖਲ ਕਰਦੇ ਹਾਂ, ਬੇਨਤੀ ਦਾ ਨਤੀਜਾ XML ਹੋਵੇਗਾ, ਉਦਾਹਰਨ ਲਈ:

ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸੂਚੀ

<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Name>myback-space</Name>
  <Prefix></Prefix>
  <Marker></Marker>
  <MaxKeys>10000</MaxKeys>
  <Delimiter>/</Delimiter>
  <IsTruncated>false</IsTruncated>
  <CommonPrefixes>
    <Prefix>new/</Prefix>
  </CommonPrefixes>
  <CommonPrefixes>
    <Prefix>old/</Prefix>
  </CommonPrefixes>
</ListBucketResult>

ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸੂਚੀ ਵਿੱਚੋਂ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਤੱਤਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ CommonPrefixes.

ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਸਾਡੇ ਪਤੇ ਵਿੱਚ ਲੋੜੀਂਦੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਜੋੜ ਕੇ, ਅਸੀਂ XML ਰੂਪ ਵਿੱਚ ਇਸਦੀ ਸਮੱਗਰੀ ਵੀ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ:

ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਫਾਈਲਾਂ ਦੀ ਸੂਚੀ

<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Name> myback-space</Name>
  <Prefix>old/</Prefix>
  <Marker></Marker>
  <MaxKeys>10000</MaxKeys>
  <Delimiter></Delimiter>
  <IsTruncated>false</IsTruncated>
  <Contents>
    <Key>old/giphy.mp4</Key>
    <LastModified>2020-08-21T20:27:46.000Z</LastModified>
    <ETag>&#34;00000000000000000000000000000000-1&#34;</ETag>
    <Size>1350084</Size>
    <Owner>
      <ID>02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4</ID>
      <DisplayName></DisplayName>
    </Owner>
    <StorageClass>STANDARD</StorageClass>
  </Contents>
  <Contents>
    <Key>old/hsd-k8s.jpg</Key>
    <LastModified>2020-08-31T16:40:01.000Z</LastModified>
    <ETag>&#34;b2d76df4aeb4493c5456366748218093&#34;</ETag>
    <Size>93183</Size>
    <Owner>
      <ID>02d6176db174dc93cb1b899f7c6078f08654445fe8cf1b6ce98d8855f66bdbf4</ID>
      <DisplayName></DisplayName>
    </Owner>
    <StorageClass>STANDARD</StorageClass>
  </Contents>
</ListBucketResult>

ਫਾਈਲਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚੋਂ ਅਸੀਂ ਸਿਰਫ ਤੱਤ ਲਵਾਂਗੇ Key.

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸਮੱਗਰੀ-ਕਿਸਮ ਦੇ ਸਿਰਲੇਖ ਨੂੰ ਟੈਕਸਟ/html ਨਾਲ ਬਦਲ ਕੇ, ਨਤੀਜੇ ਵਜੋਂ XML ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ HTML ਦੇ ਰੂਪ ਵਿੱਚ ਭੇਜਣਾ ਬਾਕੀ ਹੈ।

function request(r) {
  var v = r.variables;

  function call_back(resp) {
    var body = resp.responseBody;

    if (r.method !== 'PUT' && resp.status < 400 && v.postfix === '') {
      r.headersOut['Content-Type'] = "text/html; charset=utf-8";
      body = toHTML(body);
    }

    r.return(resp.status, body);
  }
  
  var _subrequest_uri = r.uri;
  ...
}

function toHTML(xml_str) {
  var keysMap = {
    'CommonPrefixes': 'Prefix',
    'Contents': 'Key',
  };

  var pattern = `<k>(?<v>.*?)</k>`;
  var out = [];

  for(var group_key in keysMap) {
    var reS;
    var reGroup = new RegExp(pattern.replace(/k/g, group_key), 'g');

    while(reS = reGroup.exec(xml_str)) {
      var data = new RegExp(pattern.replace(/k/g, keysMap[group_key]), 'g');
      var reValue = data.exec(reS);
      var a_text = '';

      if (group_key === 'CommonPrefixes') {
        a_text = reValue.groups.v.replace(///g, '');
      } else {
        a_text = reValue.groups.v.split('/').slice(-1);
      }

      out.push(`<a href="/pa/${reValue.groups.v}">${a_text}</a>`);
    }
  }

  return '<html><body>n' + out.join('</br>n') + 'n</html></body>'
}

PyPI ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ

ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੰਮ ਕਰਨ ਲਈ ਜਾਣੇ ਜਾਂਦੇ ਪੈਕੇਜਾਂ 'ਤੇ ਕਿਤੇ ਵੀ ਕੁਝ ਨਹੀਂ ਟੁੱਟਦਾ ਹੈ।

# Создаем для тестов новое окружение
python3 -m venv venv
. ./venv/bin/activate

# Скачиваем рабочие пакеты.
pip download aiohttp

# Загружаем в приватную репу
for wheel in *.whl; do curl -T $wheel http://localhost:8080/${wheel%%-*}/$wheel; done

rm -f *.whl

# Устанавливаем из приватной репы
pip install aiohttp -i http://localhost:8080

ਅਸੀਂ ਆਪਣੇ ਲਿਬਸ ਨਾਲ ਦੁਹਰਾਉਂਦੇ ਹਾਂ।

# Создаем для тестов новое окружение
python3 -m venv venv
. ./venv/bin/activate

pip install setuptools wheel
python setup.py bdist_wheel
for wheel in dist/*.whl; do curl -T $wheel http://localhost:8080/${wheel%%-*}/$wheel; done

pip install our_pkg --extra-index-url http://localhost:8080

CI ਵਿੱਚ, ਇੱਕ ਪੈਕੇਜ ਬਣਾਉਣਾ ਅਤੇ ਲੋਡ ਕਰਨਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

pip install setuptools wheel
python setup.py bdist_wheel

curl -sSfT dist/*.whl -u "gitlab-ci-token:${CI_JOB_TOKEN}" "https://pypi.our-domain.com/${CI_PROJECT_NAME}"

ਪ੍ਰਮਾਣਿਕਤਾ

Gitlab ਵਿੱਚ ਬਾਹਰੀ ਸੇਵਾਵਾਂ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ/ਪ੍ਰਮਾਣੀਕਰਨ ਲਈ JWT ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ। Nginx ਵਿੱਚ auth_request ਡਾਇਰੈਕਟਿਵ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਪ੍ਰਮਾਣਿਕਤਾ ਡੇਟਾ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਰੱਖਣ ਵਾਲੀ ਸਬ-ਰਿਵੈਸਟ ਲਈ ਰੀਡਾਇਰੈਕਟ ਕਰਾਂਗੇ। ਸਕ੍ਰਿਪਟ Gitlab url ਲਈ ਇੱਕ ਹੋਰ ਸਬ-ਰਿਵੇਸਟ ਕਰੇਗੀ ਅਤੇ ਜੇਕਰ ਪ੍ਰਮਾਣਿਕਤਾ ਡੇਟਾ ਸਹੀ ਢੰਗ ਨਾਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਤਾਂ Gitlab ਕੋਡ 200 ਵਾਪਸ ਕਰੇਗਾ ਅਤੇ ਪੈਕੇਜ ਨੂੰ ਅੱਪਲੋਡ/ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਵੇਗੀ। ਕਿਉਂ ਨਾ ਇੱਕ ਸਬਕਵੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਤੁਰੰਤ Gitlab ਨੂੰ ਡੇਟਾ ਭੇਜੋ? ਕਿਉਂਕਿ ਤਦ ਸਾਨੂੰ Nginx ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਹਰ ਵਾਰ ਸੰਪਾਦਿਤ ਕਰਨਾ ਪਏਗਾ ਜਦੋਂ ਅਸੀਂ ਅਧਿਕਾਰ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਇਹ ਇੱਕ ਬਹੁਤ ਮੁਸ਼ਕਲ ਕੰਮ ਹੈ. ਨਾਲ ਹੀ, ਜੇਕਰ ਕੁਬਰਨੇਟਸ ਇੱਕ ਰੀਡ-ਓਨਲੀ ਰੂਟ ਫਾਈਲ ਸਿਸਟਮ ਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ nginx.conf ਨੂੰ configmap ਦੁਆਰਾ ਤਬਦੀਲ ਕਰਨ ਵੇਲੇ ਹੋਰ ਵੀ ਗੁੰਝਲਦਾਰਤਾ ਜੋੜਦਾ ਹੈ। ਅਤੇ ਇੱਕੋ ਸਮੇਂ ਵਾਲੀਅਮ (ਪੀਵੀਸੀ) ਅਤੇ ਰੀਡ-ਓਨਲੀ ਰੂਟ ਫਾਈਲ ਸਿਸਟਮ (ਇਹ ਵੀ ਹੁੰਦਾ ਹੈ) ਦੇ ਕੁਨੈਕਸ਼ਨ ਨੂੰ ਰੋਕਣ ਵਾਲੀਆਂ ਨੀਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੰਰਚਨਾਮੈਪ ਦੁਆਰਾ Nginx ਨੂੰ ਸੰਰਚਿਤ ਕਰਨਾ ਬਿਲਕੁਲ ਅਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ।

NJS ਇੰਟਰਮੀਡੀਏਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਨੂੰ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ nginx ਸੰਰਚਨਾ ਵਿੱਚ ਨਿਰਧਾਰਤ ਮਾਪਦੰਡਾਂ ਨੂੰ ਬਦਲਣ ਦਾ ਮੌਕਾ ਮਿਲਦਾ ਹੈ ਅਤੇ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੁਝ ਜਾਂਚਾਂ ਕਰਦੇ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਨਿਰਧਾਰਿਤ URL)।

nginx.conf

location = /auth-provider {
  internal;

  proxy_pass $auth_url;
}

location = /auth {
  internal;

  proxy_set_header Content-Length "";
  proxy_pass_request_body off;
  js_content auth.auth;
}

location ~ "^/(?<prefix>[w-]*)[/]?(?<postfix>[w-.]*)$" {
  auth_request /auth;

  js_content s3.request;
}

s3.js

var env = process.env;
var env_bool = new RegExp(/[Tt]rue|[Yy]es|[Oo]n|[TtYy]|1/);
var auth_disabled  = env_bool.test(env.DISABLE_AUTH);
var gitlab_url = env.AUTH_URL;

function url() {
  return `${gitlab_url}/jwt/auth?service=container_registry`
}

function auth(r) {
  if (auth_disabled) {
    r.return(202, '{"auth": "disabled"}');
    return null
  }

  r.subrequest('/auth-provider',
                {method: 'GET', body: ''},
                function(res) {
                  r.return(res.status, "");
                });
}

export default {auth, url}

ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਇਹ ਸਵਾਲ ਪੈਦਾ ਹੁੰਦਾ ਹੈ: -ਕਿਉਂ ਨਾ ਤਿਆਰ ਕੀਤੇ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰੋ? ਸਭ ਕੁਝ ਪਹਿਲਾਂ ਹੀ ਉੱਥੇ ਕੀਤਾ ਗਿਆ ਹੈ! ਉਦਾਹਰਨ ਲਈ, var AWS = require('aws-sdk') ਅਤੇ S3 ਪ੍ਰਮਾਣਿਕਤਾ ਨਾਲ "ਬਾਈਕ" ਲਿਖਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ!

ਆਉ ਨੁਕਸਾਨ ਵੱਲ ਵਧੀਏ

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

Nginx ਵਿੱਚ ਮੌਜੂਦਾ ਪ੍ਰੋਜੈਕਟ ਲਈ ਕੰਪਰੈਸ਼ਨ ਨੂੰ ਵੀ ਅਯੋਗ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ gzip off;

ਕਿਉਂਕਿ NJS ਵਿੱਚ ਕੋਈ gzip ਮੋਡੀਊਲ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਨੈਕਟ ਕਰਨਾ ਅਸੰਭਵ ਹੈ; ਇਸਲਈ, ਸੰਕੁਚਿਤ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਇਹ ਸੱਚ ਹੈ ਕਿ ਇਸ ਕੇਸ ਲਈ ਇਹ ਅਸਲ ਵਿੱਚ ਇੱਕ ਘਟਾਓ ਨਹੀਂ ਹੈ. ਇੱਥੇ ਬਹੁਤ ਸਾਰਾ ਟੈਕਸਟ ਨਹੀਂ ਹੈ, ਅਤੇ ਟ੍ਰਾਂਸਫਰ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਪਹਿਲਾਂ ਹੀ ਸੰਕੁਚਿਤ ਹਨ ਅਤੇ ਵਾਧੂ ਕੰਪਰੈਸ਼ਨ ਉਹਨਾਂ ਦੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮਦਦ ਨਹੀਂ ਕਰੇਗਾ. ਨਾਲ ਹੀ, ਇਹ ਅਜਿਹੀ ਲੋਡ ਕੀਤੀ ਜਾਂ ਨਾਜ਼ੁਕ ਸੇਵਾ ਨਹੀਂ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਸਮੱਗਰੀ ਨੂੰ ਕੁਝ ਮਿਲੀਸਕਿੰਟ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਪਰੇਸ਼ਾਨ ਹੋਣਾ ਪਏਗਾ।

ਸਕ੍ਰਿਪਟ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵਿੱਚ ਲੰਬਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ ਅਤੇ ਇਹ error.log ਵਿੱਚ "ਪ੍ਰਿੰਟਸ" ਰਾਹੀਂ ਹੀ ਸੰਭਵ ਹੈ। ਸੈੱਟ ਲੌਗਿੰਗ ਪੱਧਰ ਦੀ ਜਾਣਕਾਰੀ, ਚੇਤਾਵਨੀ ਜਾਂ ਗਲਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਕ੍ਰਮਵਾਰ 3 ਵਿਧੀਆਂ r.log, r.warn, r.error ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਮੈਂ Chrome (v8) ਜਾਂ njs ਕੰਸੋਲ ਟੂਲ ਵਿੱਚ ਕੁਝ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ, ਪਰ ਉੱਥੇ ਹਰ ਚੀਜ਼ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ. ਕੋਡ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵੇਲੇ, ਉਰਫ਼ ਫੰਕਸ਼ਨਲ ਟੈਸਟਿੰਗ, ਇਤਿਹਾਸ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

docker-compose restart nginx
curl localhost:8080/
docker-compose logs --tail 10 nginx

ਅਤੇ ਅਜਿਹੇ ਸੈਂਕੜੇ ਕ੍ਰਮ ਹੋ ਸਕਦੇ ਹਨ।

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

ES6 ਲਈ ਕੋਈ ਪੂਰਾ ਸਮਰਥਨ ਨਹੀਂ ਹੈ।

ਕੁਝ ਹੋਰ ਕਮੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਪਰ ਮੈਨੂੰ ਹੋਰ ਕੁਝ ਨਹੀਂ ਮਿਲਿਆ। ਜਾਣਕਾਰੀ ਸਾਂਝੀ ਕਰੋ ਜੇਕਰ ਤੁਹਾਨੂੰ NJS ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਨਕਾਰਾਤਮਕ ਅਨੁਭਵ ਹੈ।

ਸਿੱਟਾ

NJS ਇੱਕ ਹਲਕਾ ਓਪਨ-ਸੋਰਸ ਦੁਭਾਸ਼ੀਏ ਹੈ ਜੋ ਤੁਹਾਨੂੰ Nginx ਵਿੱਚ ਵੱਖ-ਵੱਖ JavaScript ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਸਦੇ ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ, ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਬਹੁਤ ਧਿਆਨ ਦਿੱਤਾ ਗਿਆ ਸੀ. ਬੇਸ਼ੱਕ, ਅਜੇ ਵੀ ਬਹੁਤ ਕੁਝ ਗੁੰਮ ਹੈ, ਪਰ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇੱਕ ਛੋਟੀ ਟੀਮ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਉਹ ਸਰਗਰਮੀ ਨਾਲ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋੜ ਰਹੇ ਹਨ ਅਤੇ ਬੱਗ ਫਿਕਸ ਕਰ ਰਹੇ ਹਨ. ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਕਿਸੇ ਦਿਨ NJS ਤੁਹਾਨੂੰ ਬਾਹਰੀ ਮੈਡਿਊਲਾਂ ਨੂੰ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ, ਜੋ ਕਿ Nginx ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਲਗਭਗ ਬੇਅੰਤ ਬਣਾ ਦੇਵੇਗਾ. ਪਰ ਇੱਥੇ NGINX ਪਲੱਸ ਹੈ ਅਤੇ ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਕੋਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਹੀਂ ਹੋਣਗੀਆਂ!

ਲੇਖ ਲਈ ਪੂਰੇ ਕੋਡ ਨਾਲ ਰਿਪੋਜ਼ਟਰੀ

njs-pypi AWS ਸਾਈਨ v4 ਸਹਿਯੋਗ ਨਾਲ

ngx_http_js_module ਮੋਡੀਊਲ ਦੇ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਵੇਰਵਾ

ਅਧਿਕਾਰਤ NJS ਰਿਪੋਜ਼ਟਰੀ и ਦਸਤਾਵੇਜ਼

ਦਮਿੱਤਰੀ ਵੋਲਿੰਟਸੇਵ ਤੋਂ NJS ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਨਾਂ

njs - nginx ਵਿੱਚ ਮੂਲ JavaScript ਸਕ੍ਰਿਪਟਿੰਗ / ਸੇਂਟ ਹਾਈਲੋਡ++ 2019 ਵਿਖੇ ਦਮਿੱਤਰੀ ਵੋਲਨੀਵ ਦੁਆਰਾ ਭਾਸ਼ਣ

ਉਤਪਾਦਨ ਵਿੱਚ NJS / ਹਾਈਲੋਡ++ 2019 'ਤੇ ਵੈਸੀਲੀ ਸੋਸ਼ਨੀਕੋਵ ਦੁਆਰਾ ਭਾਸ਼ਣ

AWS ਵਿੱਚ REST ਬੇਨਤੀਆਂ 'ਤੇ ਹਸਤਾਖਰ ਕਰਨਾ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ

ਸਰੋਤ: www.habr.com