ਕੁਬਰਨੇਟਸ ਟਿਊਟੋਰਿਅਲ ਭਾਗ 1: ਐਪਲੀਕੇਸ਼ਨ, ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼, ਅਤੇ ਕੰਟੇਨਰ

ਸਾਡੀ ਬੇਨਤੀ 'ਤੇ, ਹਾਬਰ ਨੇ ਇੱਕ ਹੱਬ ਬਣਾਇਆ ਕਬਰਨੇਟਿਸ ਅਤੇ ਅਸੀਂ ਇਸ ਵਿੱਚ ਪਹਿਲਾ ਪ੍ਰਕਾਸ਼ਨ ਰੱਖ ਕੇ ਖੁਸ਼ ਹਾਂ। ਗਾਹਕ ਬਣੋ!

ਕੁਬਰਨੇਟਸ ਆਸਾਨ ਹੈ। ਬੈਂਕ ਮੈਨੂੰ ਇਸ ਖੇਤਰ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਬਹੁਤ ਸਾਰਾ ਪੈਸਾ ਕਿਉਂ ਦਿੰਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਕੋਈ ਵੀ ਇਸ ਤਕਨਾਲੋਜੀ ਵਿੱਚ ਕੁਝ ਘੰਟਿਆਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਸਕਦਾ ਹੈ?

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

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

ਹੁਣ, ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ, ਆਓ ਕੰਮ 'ਤੇ ਚੱਲੀਏ ਅਤੇ ਉਸ ਐਪਲੀਕੇਸ਼ਨ ਬਾਰੇ ਗੱਲ ਕਰੀਏ ਜਿਸ ਨਾਲ ਅਸੀਂ ਕੰਮ ਕਰਾਂਗੇ।

ਪ੍ਰਯੋਗਾਤਮਕ ਐਪ

ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਸਿਰਫ ਇੱਕ ਫੰਕਸ਼ਨ ਕਰੇਗੀ। ਇਹ, ਇਨਪੁਟ ਦੇ ਤੌਰ ਤੇ, ਇੱਕ ਵਾਕ ਲੈਂਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ, ਪਾਠ ਵਿਸ਼ਲੇਸ਼ਣ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਖਾਸ ਵਸਤੂ ਪ੍ਰਤੀ ਵਾਕ ਦੇ ਲੇਖਕ ਦੇ ਭਾਵਨਾਤਮਕ ਰਵੱਈਏ ਦਾ ਮੁਲਾਂਕਣ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋਏ, ਇਸ ਵਾਕ ਦਾ ਇੱਕ ਭਾਵਨਾਤਮਕ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।

ਇਸ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਮੁੱਖ ਵਿੰਡੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

ਭਾਵਨਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ

ਤਕਨੀਕੀ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਤਿੰਨ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਹੁੰਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਕੰਮ ਦੇ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੂਹ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ:

• SA-Frontend ਇੱਕ Nginx ਵੈੱਬ ਸਰਵਰ ਹੈ ਜੋ ਰੀਐਕਟ ਸਟੈਟਿਕ ਫਾਈਲਾਂ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ।
• SA-WebApp ਜਾਵਾ ਵਿੱਚ ਲਿਖੀ ਇੱਕ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਹੈ ਜੋ ਫਰੰਟਐਂਡ ਤੋਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।
• SA-Logic ਇੱਕ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਹੈ ਜੋ ਟੈਕਸਟ ਭਾਵਨਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੀ ਹੈ।

ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਇਕੱਲਤਾ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹਨ। ਉਹ "ਫ਼ਰਜ਼ਾਂ ਨੂੰ ਵੱਖ ਕਰਨ" ਦੇ ਵਿਚਾਰ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ, ਪਰ ਉਹਨਾਂ ਨੂੰ, ਉਸੇ ਸਮੇਂ, ਇੱਕ ਦੂਜੇ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ.

ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਡੇਟਾ ਦਾ ਪ੍ਰਵਾਹ

ਉਪਰੋਕਤ ਚਿੱਤਰ ਵਿੱਚ, ਤੁਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਡੇਟਾ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹੋਏ, ਸਿਸਟਮ ਦੇ ਨੰਬਰ ਵਾਲੇ ਪੜਾਅ ਦੇਖ ਸਕਦੇ ਹੋ। ਆਓ ਉਹਨਾਂ ਨੂੰ ਤੋੜੀਏ:

1. ਬ੍ਰਾਊਜ਼ਰ ਸਰਵਰ ਤੋਂ ਇੱਕ ਫਾਈਲ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ index.html (ਜੋ ਬਦਲੇ ਵਿੱਚ React ਐਪ ਪੈਕੇਜ ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ)।
2. ਉਪਭੋਗਤਾ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦਾ ਹੈ, ਇਸ ਨਾਲ ਸਪਰਿੰਗ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਾਲ ਹੁੰਦੀ ਹੈ।
3. ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਟੈਕਸਟ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਬੇਨਤੀ ਨੂੰ ਪਾਇਥਨ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਭੇਜਦੀ ਹੈ।
4. ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਟੈਕਸਟ ਦੀ ਭਾਵਨਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੀ ਹੈ ਅਤੇ ਬੇਨਤੀ ਦੇ ਜਵਾਬ ਵਜੋਂ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦੀ ਹੈ।
5. ਸਪਰਿੰਗ ਐਪਲੀਕੇਸ਼ਨ ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਜਵਾਬ ਭੇਜਦੀ ਹੈ (ਜੋ ਬਦਲੇ ਵਿੱਚ, ਉਪਭੋਗਤਾ ਨੂੰ ਪਾਰਸ ਕੀਤੇ ਟੈਕਸਟ ਦਾ ਨਤੀਜਾ ਦਿਖਾਉਂਦਾ ਹੈ)।

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

ਸਥਾਨਕ ਮਸ਼ੀਨ 'ਤੇ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ 'ਤੇ ਆਧਾਰਿਤ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾ ਰਿਹਾ ਹੈ

ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਕੰਮ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਤਿੰਨੋਂ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਆਉ ਉਹਨਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਸੁੰਦਰ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ - ਫਰੰਟ-ਐਂਡ ਐਪਲੀਕੇਸ਼ਨ।

▍ਸਥਾਨਕ ਵਿਕਾਸ ਲਈ ਪ੍ਰਤੀਕਿਰਿਆ ਸਥਾਪਤ ਕਰਨਾ

ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ Node.js ਫਰੇਮਵਰਕ ਅਤੇ NPM ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਭ ਇੰਸਟਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਟਰਮੀਨਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਜਾਓ sa-frontend ਅਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ:

npm install

ਫੋਲਡਰ ਵਿੱਚ ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਦੁਆਰਾ node_modules React ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਨਿਰਭਰਤਾ ਲੋਡ ਕੀਤੀ ਜਾਵੇਗੀ, ਜਿਸ ਦੇ ਰਿਕਾਰਡ ਫਾਈਲ ਵਿੱਚ ਹਨ package.json. ਉਸੇ ਫੋਲਡਰ ਵਿੱਚ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ:

npm start

ਇਹ ਸਭ ਹੈ. React ਐਪ ਹੁਣ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਪਤੇ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰਕੇ ਇਸ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ localhost:3000. ਤੁਸੀਂ ਉਸਦੇ ਕੋਡ ਵਿੱਚ ਕੁਝ ਬਦਲ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਤੁਰੰਤ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਦਾ ਪ੍ਰਭਾਵ ਦੇਖੋਗੇ। ਇਹ ਮੋਡੀਊਲ ਦੇ ਅਖੌਤੀ "ਗਰਮ" ਬਦਲਣ ਲਈ ਸੰਭਵ ਧੰਨਵਾਦ ਹੈ. ਇਸਦੇ ਲਈ ਧੰਨਵਾਦ, ਫਰੰਟ-ਐਂਡ ਵਿਕਾਸ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਮਜ਼ੇਦਾਰ ਅਨੁਭਵ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ.

▍ਉਤਪਾਦਨ ਲਈ ਪ੍ਰਤੀਕਿਰਿਆ ਐਪ ਤਿਆਰ ਕਰਨਾ

ਅਸਲ ਵਿੱਚ ਇੱਕ ਰੀਐਕਟ ਐਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ, ਸਾਨੂੰ ਇਸਨੂੰ ਸਥਿਰ ਫਾਈਲਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਬਦਲਣ ਅਤੇ ਇੱਕ ਵੈਬ ਸਰਵਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗਾਹਕਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀ ਸੇਵਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

React ਐਪ ਬਣਾਉਣ ਲਈ, ਦੁਬਾਰਾ ਟਰਮੀਨਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਫੋਲਡਰ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰੋ sa-frontend ਅਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ:

npm run build

ਇਹ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾਏਗਾ build. ਇਸ ਵਿੱਚ ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਕੰਮ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀਆਂ ਸਾਰੀਆਂ ਸਥਿਰ ਫਾਈਲਾਂ ਸ਼ਾਮਲ ਹੋਣਗੀਆਂ।

▍ Nginx ਨਾਲ ਸਥਿਰ ਫਾਈਲਾਂ ਦੀ ਸੇਵਾ ਕਰਨਾ

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ Nginx ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ. ਇਹ ਇਸ ਲਈ ਹੈ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਨਿਰਦੇਸ਼ ਲੱਭ ਸਕਦੇ ਹੋ। ਫਿਰ ਤੁਹਾਨੂੰ ਫੋਲਡਰ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਕਾਪੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ sa-frontend/build ਫੋਲਡਰ ਵਿੱਚ [your_nginx_installation_dir]/html.

ਇਸ ਪਹੁੰਚ ਨਾਲ, ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਅਸੈਂਬਲੀ ਦੌਰਾਨ ਤਿਆਰ ਕੀਤੀ ਗਈ ਫਾਈਲ index.html 'ਤੇ ਉਪਲਬਧ ਹੋਵੇਗਾ [your_nginx_installation_dir]/html/index.html. ਇਹ ਉਹ ਫਾਈਲ ਹੈ ਜੋ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, Nginx ਸਰਵਰ ਇਸ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਵੇਲੇ ਸਮੱਸਿਆਵਾਂ ਕਰਦੀ ਹੈ। ਸਰਵਰ ਨੂੰ ਪੋਰਟ 'ਤੇ ਸੁਣਨ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਹੈ 80, ਪਰ ਤੁਸੀਂ ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਕੇ ਇਸਨੂੰ ਆਪਣੀ ਮਰਜ਼ੀ ਅਨੁਸਾਰ ਅਨੁਕੂਲਿਤ ਕਰ ਸਕਦੇ ਹੋ [your_nginx_installation_dir]/conf/nginx.conf.

ਹੁਣ ਆਪਣਾ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸ 'ਤੇ ਜਾਓ localhost:80. ਤੁਸੀਂ React ਐਪ ਪੇਜ ਦੇਖੋਗੇ।

Nginx ਸਰਵਰ ਦੁਆਰਾ ਸੇਵਾ ਕੀਤੀ ਐਪ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰੋ

ਜੇਕਰ ਤੁਸੀਂ ਹੁਣ ਖੇਤਰ ਵਿੱਚ ਕੁਝ ਦਾਖਲ ਕਰਦੇ ਹੋ Type your sentence ਅਤੇ ਬਟਨ ਦਬਾਓ Send -ਕੁਝ ਨਹੀਂ ਹੋਵੇਗਾ। ਪਰ, ਜੇਕਰ ਤੁਸੀਂ ਕੰਸੋਲ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉੱਥੇ ਗਲਤੀ ਸੁਨੇਹੇ ਦੇਖ ਸਕਦੇ ਹੋ। ਇਹ ਸਮਝਣ ਲਈ ਕਿ ਇਹ ਗਲਤੀਆਂ ਕਿੱਥੇ ਹੁੰਦੀਆਂ ਹਨ, ਆਓ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ।

▍ ਫਰੰਟ-ਐਂਡ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਕੋਡ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਫਾਈਲ ਦਾ ਕੋਡ ਦੇਖ ਰਿਹਾ ਹੈ App.js, ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਨਾ Send ਇੱਕ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ analyzeSentence(). ਇਸ ਵਿਧੀ ਲਈ ਕੋਡ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। ਉਸੇ ਸਮੇਂ, ਇਸ ਤੱਥ ਵੱਲ ਧਿਆਨ ਦਿਓ ਕਿ ਹਰੇਕ ਲਾਈਨ ਲਈ ਜਿਸ ਵਿੱਚ ਫਾਰਮ ਦੀ ਇੱਕ ਟਿੱਪਣੀ ਹੈ # Номер, ਕੋਡ ਦੇ ਹੇਠਾਂ ਇੱਕ ਵਿਆਖਿਆ ਦਿੱਤੀ ਗਈ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਹੋਰ ਕੋਡ ਦੇ ਟੁਕੜਿਆਂ ਨੂੰ ਪਾਰਸ ਕਰਾਂਗੇ।

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. ਉਹ URL ਜਿਸ 'ਤੇ POST ਬੇਨਤੀ ਕੀਤੀ ਗਈ ਹੈ। ਇਹ ਪਤਾ ਅਜਿਹੀਆਂ ਬੇਨਤੀਆਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

2.ਬੇਨਤੀ ਸੰਸਥਾ ਨੇ ਅਰਜ਼ੀ 'ਤੇ ਭੇਜੀ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਬੇਨਤੀ ਬਾਡੀ ਹੈ:

{
    sentence: "I like yogobella!"
}

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

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

ਕੋਡ ਕਾਫ਼ੀ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਜਾਪਦਾ ਹੈ. ਇੱਥੇ ਕੀ ਗਲਤ ਹੈ, ਫਿਰ ਵੀ? ਜੇਕਰ ਤੁਸੀਂ ਇਹ ਮੰਨਦੇ ਹੋ ਕਿ ਜਿਸ ਪਤੇ 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਇੱਕ POST ਬੇਨਤੀ ਭੇਜਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੀ ਹੈ, ਉੱਥੇ ਅਜੇ ਤੱਕ ਅਜਿਹਾ ਕੁਝ ਨਹੀਂ ਹੈ ਜੋ ਇਸ ਬੇਨਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਬਿਲਕੁਲ ਸਹੀ ਹੋਵੋਗੇ। ਅਰਥਾਤ, ਪਤੇ 'ਤੇ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ http://localhost:8080/sentiment, ਸਾਨੂੰ ਬਸੰਤ 'ਤੇ ਆਧਾਰਿਤ ਇੱਕ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ।

ਸਾਨੂੰ ਇੱਕ ਬਸੰਤ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਇੱਕ POST ਬੇਨਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਸਕੇ

▍ਬਸੰਤ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਸੈਟ ਅਪ ਕਰਨਾ

ਇੱਕ ਸਪਰਿੰਗ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ JDK8 ਅਤੇ Maven ਅਤੇ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਰਚਿਤ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਭ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖ ਸਕਦੇ ਹੋ।

▍ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਜਾਰ ਫਾਈਲ ਵਿੱਚ ਪੈਕ ਕਰਨਾ

ਟਰਮੀਨਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਫੋਲਡਰ ਵਿੱਚ ਨੈਵੀਗੇਟ ਕਰੋ sa-webapp ਅਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦਿਓ:

mvn install

ਫੋਲਡਰ ਵਿੱਚ ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ sa-webapp ਡਾਇਰੈਕਟਰੀ ਬਣਾਈ ਜਾਵੇਗੀ target. ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ Java ਐਪਲੀਕੇਸ਼ਨ ਸਥਿਤ ਹੋਵੇਗੀ, ਇੱਕ ਜਾਰ ਫਾਈਲ ਵਿੱਚ ਪੈਕ ਕੀਤੀ ਜਾਵੇਗੀ, ਜੋ ਕਿ ਫਾਈਲ ਦੁਆਰਾ ਦਰਸਾਈ ਗਈ ਹੈ sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਕਰਨਾ

ਫੋਲਡਰ ਤੇ ਜਾਓ target ਅਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਓ:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਦੌਰਾਨ ਇੱਕ ਗਲਤੀ ਆਵੇਗੀ। ਇਸਨੂੰ ਠੀਕ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਟੈਕ ਟਰੇਸ ਡੇਟਾ ਵਿੱਚ ਅਪਵਾਦ ਵੇਰਵਿਆਂ ਨੂੰ ਪਾਰਸ ਕਰ ਸਕਦੇ ਹਾਂ:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

ਸਾਡੇ ਲਈ, ਇੱਥੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਅਰਥ ਸਪੱਸ਼ਟ ਕਰਨ ਦੀ ਅਸੰਭਵਤਾ ਦਾ ਜ਼ਿਕਰ ਹੈ sa.logic.api.url. ਆਉ ਕੋਡ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ ਜਿੱਥੇ ਗਲਤੀ ਹੁੰਦੀ ਹੈ।

▍ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿਸ਼ਲੇਸ਼ਣ

ਇੱਥੇ ਕੋਡ ਸਨਿੱਪਟ ਹੈ ਜਿੱਥੇ ਗਲਤੀ ਹੁੰਦੀ ਹੈ।

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

1. ਵਿਚ ਐੱਸentimentController ਇੱਕ ਖੇਤਰ ਹੈ saLogicApiUrl. ਇਸਦਾ ਮੁੱਲ ਸੰਪਤੀ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ sa.logic.api.url.
2. ਲਾਈਨ saLogicApiUrl ਮੁੱਲ ਨਾਲ ਜੋੜਦਾ ਹੈ /analyse/sentiment. ਉਹ ਇਕੱਠੇ ਮਿਲ ਕੇ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਇੱਕ ਪਤਾ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਟੈਕਸਟ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।

▍ਪ੍ਰਾਪਰਟੀ ਦਾ ਮੁੱਲ ਸੈੱਟ ਕਰਨਾ

ਬਸੰਤ ਵਿੱਚ, ਸੰਪੱਤੀ ਮੁੱਲਾਂ ਦਾ ਮੂਲ ਸਰੋਤ ਇੱਕ ਫਾਈਲ ਹੈ application.properties'ਤੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ sa-webapp/src/main/resources. ਪਰ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਪੱਤੀ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦਾ ਇੱਕੋ ਇੱਕ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਇਹ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਵੀ ਕਰ ਸਕਦੇ ਹੋ:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

ਇਸ ਸੰਪਤੀ ਦਾ ਮੁੱਲ ਸਾਡੀ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਪਤੇ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਇਸਨੂੰ ਕੌਂਫਿਗਰ ਕਰਕੇ, ਅਸੀਂ ਸਪਰਿੰਗ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦੱਸਦੇ ਹਾਂ ਕਿ ਟੈਕਸਟ ਪਾਰਸਿੰਗ ਬੇਨਤੀਆਂ ਕਰਨ ਲਈ ਇਸਨੂੰ ਕਿੱਥੇ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਾਡੀਆਂ ਜ਼ਿੰਦਗੀਆਂ ਨੂੰ ਗੁੰਝਲਦਾਰ ਨਾ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਫੈਸਲਾ ਕਰਾਂਗੇ ਕਿ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਇੱਥੇ ਉਪਲਬਧ ਹੋਵੇਗੀ localhost:5000 ਅਤੇ ਇਸ ਬਾਰੇ ਭੁੱਲ ਨਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ. ਨਤੀਜੇ ਵਜੋਂ, ਸਪਰਿੰਗ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਕਮਾਂਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

ਸਾਡੇ ਸਿਸਟਮ ਵਿੱਚ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਗੁੰਮ ਹੈ

ਹੁਣ ਸਾਨੂੰ ਪਾਇਥਨ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ ਹੈ ਅਤੇ ਸਿਸਟਮ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰੇਗਾ।

▍ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਸੈਟ ਅਪ ਕਰਨਾ

ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਹਾਡੇ ਕੋਲ Python 3 ਅਤੇ Pip ਇੰਸਟਾਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਢੁਕਵੇਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈੱਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।

▍ਨਿਰਭਰਤਾ ਸਥਾਪਤ ਕਰੋ

ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ 'ਤੇ ਜਾਓ sa-logic/sa ਅਤੇ ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਚਲਾਓ:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍ਐਪ ਲਾਂਚ

ਨਿਰਭਰਤਾ ਸਥਾਪਿਤ ਹੋਣ ਦੇ ਨਾਲ, ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹਾਂ:

python sentiment_analysis.py

ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਹੇਠ ਲਿਖਿਆਂ ਦੱਸਿਆ ਜਾਵੇਗਾ:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ 'ਤੇ ਬੇਨਤੀਆਂ ਦੀ ਉਡੀਕ ਕਰ ਰਹੀ ਹੈ localhost:5000/

▍ਕੋਡ ਖੋਜ

ਆਉ ਇਹ ਸਮਝਣ ਲਈ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਵੇਖੀਏ ਕਿ ਇਹ ਬੇਨਤੀਆਂ ਦਾ ਕਿਵੇਂ ਜਵਾਬ ਦਿੰਦਾ ਹੈ:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

1. ਆਬਜੈਕਟ ਸ਼ੁਰੂਆਤੀ Flask.
2. ਇਸ ਨੂੰ POST ਬੇਨਤੀਆਂ ਕਰਨ ਲਈ ਪਤਾ ਨਿਰਧਾਰਤ ਕਰਨਾ।
3. ਕਿਸੇ ਜਾਇਦਾਦ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ sentence ਬੇਨਤੀ ਸੰਸਥਾ ਤੋਂ.
4. ਅਗਿਆਤ ਵਸਤੂ ਦੀ ਸ਼ੁਰੂਆਤ TextBlob ਅਤੇ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨਾ polarity ਬੇਨਤੀ ਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਪ੍ਰਾਪਤ ਹੋਏ ਪਹਿਲੇ ਪ੍ਰਸਤਾਵ ਲਈ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਇੱਕੋ ਇੱਕ ਪ੍ਰਸਤਾਵ ਹੈ)।
5. ਇੱਕ ਜਵਾਬ ਵਾਪਸ ਕਰਨਾ, ਜਿਸਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਪੇਸ਼ਕਸ਼ ਦਾ ਪਾਠ ਅਤੇ ਇਸਦੇ ਲਈ ਗਿਣਿਆ ਗਿਆ ਸੂਚਕ ਹੁੰਦਾ ਹੈ polarity.
6. ਫਲਾਸਕ ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ, ਜੋ ਕਿ ਇੱਥੇ ਉਪਲਬਧ ਹੋਵੇਗੀ 0.0.0.0:5000 (ਤੁਸੀਂ ਫਾਰਮ ਦੇ ਨਿਰਮਾਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੀ ਇਸ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ localhost:5000).

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

ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਵਾਲੀਆਂ ਸਾਰੀਆਂ ਮਾਈਕਰੋਸਰਵਿਸਾਂ ਨੂੰ ਇੱਕ ਸਿਹਤਮੰਦ ਸਥਿਤੀ ਵਿੱਚ ਲਿਆਂਦਾ ਜਾਂਦਾ ਹੈ

ਹੁਣ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਜਾਰੀ ਰੱਖੀਏ, ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ React ਐਪ ਖੋਲ੍ਹੋ ਅਤੇ ਇਸਦੇ ਨਾਲ ਕੁਝ ਵਾਕਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਜੇ ਸਭ ਕੁਝ ਸਹੀ ਢੰਗ ਨਾਲ ਕੀਤਾ ਗਿਆ ਹੈ - ਬਟਨ ਨੂੰ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ Send ਤੁਸੀਂ ਟੈਕਸਟ ਬਾਕਸ ਦੇ ਹੇਠਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਨਤੀਜੇ ਵੇਖੋਗੇ।

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

ਡੌਕਰ ਕੰਟੇਨਰ

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

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

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੰਟੇਨਰ ਕਿਸੇ ਵੀ ਕੰਪਿਊਟਰ 'ਤੇ ਚਲਾਏ ਜਾ ਸਕਦੇ ਹਨ, ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਡਕਸ਼ਨ ਸਰਵਰ ਵੀ ਸ਼ਾਮਲ ਹਨ, ਅਤੇ ਕਿਸੇ ਵੀ ਵਾਤਾਵਰਣ ਵਿੱਚ, ਉਹਨਾਂ ਵਿੱਚ ਨੱਥੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਨਗੀਆਂ।

ਕੰਟੇਨਰਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਚਲਾਉਣ ਦੇ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਉਹਨਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ, ਆਉ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਅਤੇ ਇੱਕ ਕੰਟੇਨਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਸੇਵਾ ਕਰਨ ਦੀ ਉਦਾਹਰਨ ਵੇਖੀਏ।

▍ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਸਥਿਰ ਫਾਈਲਾਂ ਦੀ ਸੇਵਾ ਕਰਨਾ

ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਥਿਰ ਫਾਈਲਾਂ ਦੇ ਰੱਖ-ਰਖਾਅ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋਏ, ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਨੁਕਸਾਨਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ:

1. ਸਰੋਤਾਂ ਦੀ ਅਕੁਸ਼ਲ ਵਰਤੋਂ, ਕਿਉਂਕਿ ਹਰੇਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਇੱਕ ਸੰਪੂਰਨ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਹੈ।
2. ਪਲੇਟਫਾਰਮ ਨਿਰਭਰਤਾ। ਜੋ ਕੁਝ ਸਥਾਨਕ ਕੰਪਿਊਟਰਾਂ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਤਪਾਦਨ ਸਰਵਰ 'ਤੇ ਕੰਮ ਨਾ ਕਰੇ।
3. ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੱਲ ਦੀ ਹੌਲੀ ਅਤੇ ਸੰਸਾਧਨ ਤੀਬਰ ਸਕੇਲਿੰਗ।

Nginx ਵੈੱਬ ਸਰਵਰ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਸਥਿਰ ਫਾਈਲਾਂ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ

ਜੇ ਕੰਟੇਨਰਾਂ ਦੀ ਵਰਤੋਂ ਸਮਾਨ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ, ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਮੁਕਾਬਲੇ, ਹੇਠ ਲਿਖੀਆਂ ਸ਼ਕਤੀਆਂ ਨੂੰ ਨੋਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

1. ਸਰੋਤਾਂ ਦੀ ਕੁਸ਼ਲ ਵਰਤੋਂ: ਡੌਕਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨਾਲ ਕੰਮ ਕਰੋ।
2. ਪਲੇਟਫਾਰਮ ਦੀ ਸੁਤੰਤਰਤਾ। ਇੱਕ ਕੰਟੇਨਰ ਜਿਸ ਨੂੰ ਇੱਕ ਡਿਵੈਲਪਰ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ, ਕਿਤੇ ਵੀ ਚੱਲੇਗਾ।
3. ਚਿੱਤਰ ਲੇਅਰਾਂ ਦੀ ਵਰਤੋਂ ਰਾਹੀਂ ਹਲਕਾ ਤੈਨਾਤੀ।

Nginx ਵੈੱਬ ਸਰਵਰ ਇੱਕ ਕੰਟੇਨਰ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਸਥਿਰ ਫਾਈਲਾਂ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ

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

▍ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਐਪ ਲਈ ਇੱਕ ਕੰਟੇਨਰ ਚਿੱਤਰ ਬਣਾਉਣਾ

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

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਫਾਈਲ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੀਏ Dockerfile, ਯਾਦ ਰੱਖੋ ਕਿ ਅਸੀਂ Nginx ਸਰਵਰ 'ਤੇ ਅਪਲੋਡ ਕਰਨ ਲਈ ਰੀਐਕਟ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਫਾਈਲਾਂ ਤਿਆਰ ਕਰਨ ਲਈ ਕੀ ਕੀਤਾ:

1. ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਐਪ ਪੈਕੇਜ ਬਣਾਉਣਾ (npm run build).
2. Nginx ਸਰਵਰ ਸ਼ੁਰੂ ਕਰ ਰਿਹਾ ਹੈ।
3. ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਦੀ ਸਮੱਗਰੀ ਦੀ ਨਕਲ build ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਤੋਂ sa-frontend ਸਰਵਰ ਫੋਲਡਰ ਵਿੱਚ nginx/html.

ਹੇਠਾਂ ਤੁਸੀਂ ਇੱਕ ਕੰਟੇਨਰ ਬਣਾਉਣ ਅਤੇ ਸਥਾਨਕ ਕੰਪਿਊਟਰ 'ਤੇ ਕੀਤੀਆਂ ਉਪਰੋਕਤ ਕਾਰਵਾਈਆਂ ਵਿਚਕਾਰ ਸਮਾਨਤਾਵਾਂ ਦੇਖ ਸਕਦੇ ਹੋ।

▍ SA-ਫਰੰਟਐਂਡ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਡੌਕਰਫਾਈਲ ਤਿਆਰ ਕਰਨਾ

ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣ ਦੀਆਂ ਹਦਾਇਤਾਂ Dockerfile ਐਪਲੀਕੇਸ਼ਨ ਲਈ SA-Frontend, ਸਿਰਫ਼ ਦੋ ਕਮਾਂਡਾਂ ਦੇ ਹੁੰਦੇ ਹਨ। ਤੱਥ ਇਹ ਹੈ ਕਿ Nginx ਵਿਕਾਸ ਟੀਮ ਨੇ ਇੱਕ ਬੁਨਿਆਦੀ ਤਿਆਰ ਕੀਤਾ ਹੈ ਇੱਕ ਚਿੱਤਰ Nginx ਲਈ, ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਆਪਣੀ ਤਸਵੀਰ ਬਣਾਉਣ ਲਈ ਕਰਾਂਗੇ. ਇੱਥੇ ਦੋ ਕਦਮ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਸਾਨੂੰ ਵਰਣਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਤੁਹਾਨੂੰ Nginx ਚਿੱਤਰ ਨੂੰ ਚਿੱਤਰ ਦਾ ਆਧਾਰ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ.
2. ਫੋਲਡਰ ਸਮੱਗਰੀ sa-frontend/build ਚਿੱਤਰ ਫੋਲਡਰ ਵਿੱਚ ਕਾਪੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ nginx/html.

ਜੇ ਅਸੀਂ ਇਸ ਵਰਣਨ ਤੋਂ ਫਾਈਲ ਤੱਕ ਜਾਂਦੇ ਹਾਂ Dockerfile, ਫਿਰ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

FROM nginx
COPY build /usr/share/nginx/html

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਇੱਥੇ ਸਭ ਕੁਝ ਬਹੁਤ ਸਾਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਵੀ ਕਾਫ਼ੀ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸਮਝਣ ਯੋਗ ਹੁੰਦੀ ਹੈ. ਇਹ ਫਾਈਲ ਸਿਸਟਮ ਨੂੰ ਚਿੱਤਰ ਲੈਣ ਲਈ ਕਹਿੰਦੀ ਹੈ nginx ਹਰ ਚੀਜ਼ ਦੇ ਨਾਲ ਜੋ ਇਸ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਹੈ, ਅਤੇ ਡਾਇਰੈਕਟਰੀ ਦੀ ਸਮੱਗਰੀ ਦੀ ਨਕਲ ਕਰੋ build ਡਾਇਰੈਕਟਰੀ ਨੂੰ nginx/html.

ਇੱਥੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਸਵਾਲ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਮੈਂ ਕਿਵੇਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਫੋਲਡਰ ਵਿੱਚੋਂ ਫਾਈਲਾਂ ਨੂੰ ਕਿੱਥੇ ਕਾਪੀ ਕਰਨਾ ਹੈ build, ਯਾਨੀ ਕਿ ਰਸਤਾ ਕਿੱਥੋਂ ਆਇਆ ਹੈ /usr/share/nginx/html. ਵਾਸਤਵ ਵਿੱਚ, ਇੱਥੇ ਕੁਝ ਵੀ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ. ਤੱਥ ਇਹ ਹੈ ਕਿ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਵਰਣਨ ਚਿੱਤਰ।

▍ ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਅੱਪਲੋਡ ਕਰਨਾ

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

1. ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਡੌਕਰ.
2. ਡੌਕਰ ਹੱਬ ਸਾਈਟ 'ਤੇ ਰਜਿਸਟਰ ਕਰੋ।
3. ਟਰਮੀਨਲ ਵਿੱਚ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾ ਕੇ ਆਪਣੇ ਖਾਤੇ ਵਿੱਚ ਲੌਗ ਇਨ ਕਰੋ:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

ਹੁਣ ਤੁਹਾਨੂੰ ਟਰਮੀਨਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ sa-frontend ਅਤੇ ਉੱਥੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਚਲਾਓ:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

ਇੱਥੇ ਅਤੇ ਹੇਠਾਂ ਸਮਾਨ ਕਮਾਂਡਾਂ ਵਿੱਚ $DOCKER_USER_ID Docker Hub 'ਤੇ ਤੁਹਾਡੇ ਉਪਭੋਗਤਾ ਨਾਮ ਨਾਲ ਬਦਲਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕਮਾਂਡ ਦਾ ਇਹ ਹਿੱਸਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ: rinormaloku/sentiment-analysis-frontend.

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਸ ਕਮਾਂਡ ਨੂੰ ਇਸ ਤੋਂ ਹਟਾ ਕੇ ਛੋਟਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ -f Dockerfile, ਕਿਉਂਕਿ ਜਿਸ ਫੋਲਡਰ ਵਿੱਚ ਅਸੀਂ ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਉਸ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇਹ ਫਾਈਲ ਹੈ।

ਮੁਕੰਮਲ ਚਿੱਤਰ ਨੂੰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਭੇਜਣ ਲਈ, ਸਾਨੂੰ ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਦੀ ਲੋੜ ਹੈ:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

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

▍ਇੱਕ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰਨਾ

ਹੁਣ ਕੋਈ ਵੀ ਵਜੋਂ ਜਾਣੇ ਜਾਂਦੇ ਚਿੱਤਰ ਨੂੰ ਡਾਊਨਲੋਡ ਅਤੇ ਚਲਾ ਸਕਦਾ ਹੈ $DOCKER_USER_ID/sentiment-analysis-frontend. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕਮਾਂਡਾਂ ਦੇ ਹੇਠ ਲਿਖੇ ਕ੍ਰਮ ਨੂੰ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

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

• ਪਹਿਲਾ ਨੰਬਰ 80 ਹੋਸਟ ਦਾ ਪੋਰਟ ਨੰਬਰ ਹੈ (ਜੋ ਕਿ ਸਥਾਨਕ ਕੰਪਿਊਟਰ ਹੈ)।
• ਦੂਜਾ ਨੰਬਰ 80 ਕੰਟੇਨਰ ਦਾ ਪੋਰਟ ਹੈ ਜਿਸ 'ਤੇ ਬੇਨਤੀ ਨੂੰ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਉੱਤੇ ਗੌਰ ਕਰੋ।

ਪੋਰਟ ਫਾਰਵਰਡਿੰਗ

ਸਿਸਟਮ ਪੋਰਟ ਤੋਂ ਬੇਨਤੀਆਂ ਨੂੰ ਅੱਗੇ ਭੇਜਦਾ ਹੈ <hostPort> ਬੰਦਰਗਾਹ ਨੂੰ <containerPort>. ਯਾਨੀ ਪੋਰਟ ਤੱਕ ਪਹੁੰਚਣਾ 80 ਕੰਪਿਊਟਰ ਨੂੰ ਇੱਕ ਪੋਰਟ ਤੇ ਰੀਡਾਇਰੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ 80 ਕੰਟੇਨਰ

ਬੰਦਰਗਾਹ ਤੋਂ 80 ਸਥਾਨਕ ਕੰਪਿਊਟਰ 'ਤੇ ਖੋਲ੍ਹਿਆ ਗਿਆ ਹੈ, ਤੁਸੀਂ ਇਸ ਕੰਪਿਊਟਰ ਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ localhost:80. ਜੇਕਰ ਤੁਹਾਡਾ ਸਿਸਟਮ ਡੌਕਰ ਨੂੰ ਸਪੋਰਟ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਡੌਕਰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ 'ਤੇ ਚਲਾ ਸਕਦੇ ਹੋ, ਜਿਸਦਾ ਪਤਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ। <docker-machine ip>:80. ਡੌਕਰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ IP ਪਤਾ ਲੱਭਣ ਲਈ, ਤੁਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ docker-machine ip.

ਇਸ ਬਿੰਦੂ 'ਤੇ, ਇੱਕ ਵਾਰ ਫਰੰਟ-ਐਂਡ ਐਪ ਕੰਟੇਨਰ ਸਫਲਤਾਪੂਰਵਕ ਲਾਂਚ ਹੋ ਗਿਆ ਹੈ, ਤੁਹਾਨੂੰ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇਸਦਾ ਪੰਨਾ ਖੋਲ੍ਹਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

▍.dockerignore ਫਾਈਲ

ਐਪਲੀਕੇਸ਼ਨ ਚਿੱਤਰ ਬਣਾਉਣਾ SA-Frontend, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਇਹ ਪ੍ਰਕਿਰਿਆ ਬਹੁਤ ਹੌਲੀ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਚਿੱਤਰ ਬਣਾਉਣ ਦਾ ਸੰਦਰਭ ਡੌਕਰ ਡੈਮਨ ਨੂੰ ਭੇਜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਡਾਇਰੈਕਟਰੀ ਜੋ ਬਿਲਡ ਸੰਦਰਭ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਕਮਾਂਡ ਨੂੰ ਆਖਰੀ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਿੱਤੀ ਗਈ ਹੈ docker build. ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਸ ਕਮਾਂਡ ਦੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਬਿੰਦੀ ਹੈ. ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅਸੈਂਬਲੀ ਸੰਦਰਭ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਢਾਂਚੇ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

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

node_modules
src
public

ਫਾਇਲ .dockerignore ਫਾਇਲ ਦੇ ਰੂਪ ਵਿੱਚ ਉਸੇ ਫੋਲਡਰ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ Dockerfile. ਹੁਣ ਚਿੱਤਰ ਦੀ ਅਸੈਂਬਲੀ ਕੁਝ ਸਕਿੰਟ ਲਵੇਗੀ.

ਆਉ ਹੁਣ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਚਿੱਤਰ ਨਾਲ ਨਜਿੱਠਦੇ ਹਾਂ।

▍ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਕੰਟੇਨਰ ਚਿੱਤਰ ਬਣਾਉਣਾ

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

ਫਾਈਲ ਖੋਲ੍ਹੋ Dockerfile, ਜੋ ਕਿ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਸਥਿਤ ਹੈ sa-webapp. ਜੇ ਤੁਸੀਂ ਇਸ ਫਾਈਲ ਦਾ ਟੈਕਸਟ ਪੜ੍ਹਦੇ ਹੋ, ਤਾਂ ਇਸ ਵਿੱਚ ਤੁਹਾਨੂੰ ਸਿਰਫ ਦੋ ਨਵੇਂ ਨਿਰਮਾਣ ਮਿਲ ਜਾਣਗੇ ਜੋ ਕੀਵਰਡਸ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

ਕੀਵਰਡ ENV ਤੁਹਾਨੂੰ ਡੌਕਰ ਕੰਟੇਨਰਾਂ ਦੇ ਅੰਦਰ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਤੁਹਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਦੇ API ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇੱਕ URL ਸੈਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਟੈਕਸਟ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।

ਕੀਵਰਡ EXPOSE ਤੁਹਾਨੂੰ ਡੌਕਰ ਨੂੰ ਇੱਕ ਪੋਰਟ ਖੋਲ੍ਹਣ ਲਈ ਦੱਸਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇਸ ਪੋਰਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ। ਇੱਥੇ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ Dockerfile ਐਪਲੀਕੇਸ਼ਨ ਲਈ SA-Frontend ਅਜਿਹਾ ਕੋਈ ਹੁਕਮ ਨਹੀਂ ਹੈ। ਇਹ ਸਿਰਫ਼ ਦਸਤਾਵੇਜ਼ੀ ਉਦੇਸ਼ਾਂ ਲਈ ਹੈ, ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਹ ਰਚਨਾ ਪਾਠਕ ਲਈ ਹੈ Dockerfile.

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

▍ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਕੰਟੇਨਰ ਚਿੱਤਰ ਬਣਾਉਣਾ

ਜੇ ਤੁਸੀਂ ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰਦੇ ਹੋ Dockerfile ਫੋਲਡਰ ਵਿੱਚ sa-logicਤੁਹਾਨੂੰ ਉੱਥੇ ਕੁਝ ਵੀ ਨਵਾਂ ਨਹੀਂ ਮਿਲੇਗਾ। ਚਿੱਤਰ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਇਸ ਨੂੰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਧੱਕਣ ਲਈ ਕਮਾਂਡਾਂ ਤੁਹਾਡੇ ਲਈ ਪਹਿਲਾਂ ਹੀ ਜਾਣੂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ, ਪਰ, ਜਿਵੇਂ ਕਿ ਸਾਡੀਆਂ ਹੋਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਉਹ ਫਾਈਲ ਵਿੱਚ ਲੱਭੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ. README.md ਫੋਲਡਰ ਵਿੱਚ sa-logic.

▍ਕਟੇਨਰਾਈਜ਼ਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ

ਕੀ ਤੁਸੀਂ ਕਿਸੇ ਅਜਿਹੀ ਚੀਜ਼ 'ਤੇ ਭਰੋਸਾ ਕਰ ਸਕਦੇ ਹੋ ਜਿਸਦੀ ਤੁਸੀਂ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਹੈ? ਮੈਂ ਵੀ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਆਉ ਸਾਡੇ ਕੰਟੇਨਰਾਂ ਦੀ ਜਾਂਚ ਕਰੀਏ।

1. ਆਓ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰੀਏ sa-logic ਅਤੇ ਇਸਨੂੰ ਪੋਰਟ 'ਤੇ ਸੁਣਨ ਲਈ ਕੌਂਫਿਗਰ ਕਰੋ 5050:

   docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic

2. ਆਓ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰੀਏ sa-webapp ਅਤੇ ਇਸਨੂੰ ਪੋਰਟ 'ਤੇ ਸੁਣਨ ਲਈ ਕੌਂਫਿਗਰ ਕਰੋ 8080. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਾਨੂੰ ਉਸ ਪੋਰਟ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ 'ਤੇ ਪਾਈਥਨ ਐਪਲੀਕੇਸ਼ਨ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ ਨੂੰ ਮੁੜ ਨਿਰਧਾਰਤ ਕਰਕੇ Java ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਬੇਨਤੀਆਂ ਸੁਣੇਗੀ। SA_LOGIC_API_URL:

   $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app

ਇੱਕ ਕੰਟੇਨਰ ਜਾਂ ਡੌਕਰ VM ਦਾ IP ਪਤਾ ਕਿਵੇਂ ਲੱਭਣਾ ਹੈ, ਇਹ ਸਿੱਖਣ ਲਈ, ਫਾਈਲ ਵੇਖੋ README.

ਆਓ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰੀਏ sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ਹੁਣ ਸਭ ਕੁਝ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਪਤੇ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰਨ ਲਈ ਤਿਆਰ ਹੈ localhost:80 ਅਤੇ ਐਪ ਦੀ ਜਾਂਚ ਕਰੋ।

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਲਈ ਪੋਰਟ ਬਦਲਦੇ ਹੋ sa-webapp, ਜਾਂ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ Docker VM ਚਲਾ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਫ਼ਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ App.js ਫੋਲਡਰ ਤੋਂ sa-frontendਵਿਧੀ ਵਿੱਚ IP ਐਡਰੈੱਸ ਜਾਂ ਪੋਰਟ ਨੰਬਰ ਬਦਲ ਕੇ analyzeSentence()ਪੁਰਾਣੇ ਡੇਟਾ ਦੀ ਬਜਾਏ ਮੌਜੂਦਾ ਜਾਣਕਾਰੀ ਨੂੰ ਬਦਲ ਕੇ। ਉਸ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਚਿੱਤਰ ਨੂੰ ਦੁਬਾਰਾ ਜੋੜਨ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਸਾਡਾ ਐਪਲੀਕੇਸ਼ਨ ਡਾਇਗ੍ਰਾਮ ਹੁਣ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਮਾਈਕਰੋ ਸੇਵਾਵਾਂ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਚਲਦੀਆਂ ਹਨ

ਸੰਖੇਪ: ਸਾਨੂੰ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਦੀ ਕਿਉਂ ਲੋੜ ਹੈ?

ਅਸੀਂ ਹੁਣੇ ਫਾਈਲਾਂ ਦੀ ਸਮੀਖਿਆ ਕੀਤੀ ਹੈ Dockerfile, ਚਿੱਤਰਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਡੌਕਰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕਿਵੇਂ ਧੱਕਣਾ ਹੈ ਬਾਰੇ ਗੱਲ ਕੀਤੀ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਸਿੱਖਿਆ ਕਿ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਚਿੱਤਰਾਂ ਦੀ ਅਸੈਂਬਲੀ ਨੂੰ ਕਿਵੇਂ ਤੇਜ਼ ਕਰਨਾ ਹੈ .dockerignore. ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡੀਆਂ ਮਾਈਕਰੋ ਸੇਵਾਵਾਂ ਹੁਣ ਡੌਕਰ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਹਨ। ਇੱਥੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜਾਇਜ਼ ਸਵਾਲ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਸਾਨੂੰ ਕੁਬਰਨੇਟਸ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ। ਇਸ ਸਵਾਲ ਦਾ ਜਵਾਬ ਇਸ ਸਮੱਗਰੀ ਦੇ ਦੂਜੇ ਭਾਗ ਨੂੰ ਸਮਰਪਿਤ ਕੀਤਾ ਜਾਵੇਗਾ. ਇਸ ਦੌਰਾਨ, ਹੇਠਾਂ ਦਿੱਤੇ ਸਵਾਲ 'ਤੇ ਵਿਚਾਰ ਕਰੋ:
ਚਲੋ ਇਹ ਮੰਨ ਲਓ ਕਿ ਸਾਡੀ ਟੈਕਸਟ ਵਿਸ਼ਲੇਸ਼ਣ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਦੁਨੀਆ ਭਰ ਵਿੱਚ ਪ੍ਰਸਿੱਧ ਹੋ ਗਈ ਹੈ। ਉਸ ਨੂੰ ਹਰ ਮਿੰਟ ਲੱਖਾਂ ਬੇਨਤੀਆਂ ਆਉਂਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ sa-webapp и sa-logic ਬਹੁਤ ਜ਼ਿਆਦਾ ਤਣਾਅ ਵਿੱਚ ਰਹੇਗਾ। ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਚਲਾਉਣ ਵਾਲੇ ਕੰਟੇਨਰਾਂ ਨੂੰ ਕਿਵੇਂ ਸਕੇਲ ਕਰਨਾ ਹੈ?

ਸਰੋਤ: www.habr.com