ਅਸੀਂ ਬਿਨਾਂ ਪਲੱਗਇਨ, SMS ਜਾਂ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਦੇ GKE ਵਿੱਚ ਇੱਕ ਤੈਨਾਤੀ ਕਾਰਜ ਬਣਾਉਂਦੇ ਹਾਂ। ਆਉ ਜੇਨਕਿੰਸ ਦੀ ਜੈਕਟ ਦੇ ਹੇਠਾਂ ਇੱਕ ਝਾਤ ਮਾਰੀਏ

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

ਮੈਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਮੈਂ ਬਹੁਤ ਆਲਸੀ ਹਾਂ (ਕੀ ਮੈਂ ਇਹ ਪਹਿਲਾਂ ਸਵੀਕਾਰ ਨਹੀਂ ਕੀਤਾ ਸੀ? ਨਹੀਂ?), ਅਤੇ ਇਸ ਤੱਥ ਨੂੰ ਦੇਖਦੇ ਹੋਏ ਕਿ ਟੀਮ ਦੀ ਅਗਵਾਈ ਕਰਨ ਵਾਲਿਆਂ ਦੀ ਜੇਨਕਿੰਸ ਤੱਕ ਪਹੁੰਚ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਸਾਰੇ ਸੀਆਈ/ਸੀਡੀ ਹਨ, ਮੈਂ ਸੋਚਿਆ: ਉਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਤਾਇਨਾਤ ਕਰਨ ਦਿਓ ਜਿੰਨਾ ਉਹ ਚਾਹੁੰਦਾ ਹੈ! ਮੈਨੂੰ ਇੱਕ ਚੁਟਕਲਾ ਯਾਦ ਆਇਆ: ਇੱਕ ਆਦਮੀ ਨੂੰ ਇੱਕ ਮੱਛੀ ਦਿਓ ਅਤੇ ਉਹ ਇੱਕ ਦਿਨ ਲਈ ਖਾਵੇਗਾ; ਇੱਕ ਵਿਅਕਤੀ ਨੂੰ ਫੇਡ ਕਾਲ ਕਰੋ ਅਤੇ ਉਹ ਸਾਰੀ ਉਮਰ ਫੀਡ ਰਹੇਗਾ। ਅਤੇ ਚਲਾ ਗਿਆ ਨੌਕਰੀ 'ਤੇ ਚਾਲਾਂ ਖੇਡੋ, ਜੋ ਕੁਬੇਰ ਵਿੱਚ ਕਿਸੇ ਵੀ ਸਫਲਤਾਪੂਰਵਕ ਬਣਾਏ ਗਏ ਸੰਸਕਰਣ ਦੀ ਐਪਲੀਕੇਸ਼ਨ ਵਾਲੇ ਕੰਟੇਨਰ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੇਗਾ ਅਤੇ ਇਸ ਵਿੱਚ ਕੋਈ ਵੀ ਮੁੱਲ ਟ੍ਰਾਂਸਫਰ ਕਰ ਸਕਦਾ ਹੈ। ENV (ਮੇਰੇ ਦਾਦਾ, ਇੱਕ ਫਿਲੋਲੋਜਿਸਟ, ਇੱਕ ਅੰਗਰੇਜ਼ੀ ਅਧਿਆਪਕ, ਹੁਣ ਆਪਣੇ ਮੰਦਰ ਵਿੱਚ ਆਪਣੀ ਉਂਗਲ ਘੁਮਾਉਣਗੇ ਅਤੇ ਇਸ ਵਾਕ ਨੂੰ ਪੜ੍ਹ ਕੇ ਮੈਨੂੰ ਬਹੁਤ ਭਾਵਪੂਰਤ ਰੂਪ ਵਿੱਚ ਵੇਖਣਗੇ)।

ਇਸ ਲਈ, ਇਸ ਨੋਟ ਵਿੱਚ ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਮੈਂ ਕਿਵੇਂ ਸਿੱਖਿਆ:

1. ਜੇਨਕਿੰਸ ਵਿੱਚ ਨੌਕਰੀਆਂ ਤੋਂ ਜਾਂ ਹੋਰ ਨੌਕਰੀਆਂ ਤੋਂ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਅਪਡੇਟ ਕਰੋ;
2. ਜੇਨਕਿੰਸ ਏਜੰਟ ਨਾਲ ਨੋਡ ਤੋਂ ਕਲਾਉਡ ਕੰਸੋਲ (ਕਲਾਊਡ ਸ਼ੈੱਲ) ਨਾਲ ਜੁੜੋ;
3. Google Kubernetes Engine 'ਤੇ ਵਰਕਲੋਡ ਨੂੰ ਤੈਨਾਤ ਕਰੋ।

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

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

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

ਜੇਨਕਿੰਸ ਵਿੱਚ ਕੰਮ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਨੂੰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਅੱਪਡੇਟ ਕਰਨਾ

ਮੈਂ ਤੁਹਾਡੇ ਸਵਾਲ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹਾਂ: ਡਾਇਨਾਮਿਕ ਜੌਬ ਅਪਡੇਟ ਦਾ ਇਸ ਨਾਲ ਕੀ ਲੈਣਾ ਦੇਣਾ ਹੈ? ਸਤਰ ਪੈਰਾਮੀਟਰ ਦਾ ਮੁੱਲ ਹੱਥੀਂ ਦਰਜ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਜਾਓ!

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

ਯੋਜਨਾ ਇਹ ਹੈ: ਅਸੀਂ ਜੇਨਕਿੰਸ ਵਿੱਚ ਇੱਕ ਨੌਕਰੀ ਬਣਾਉਂਦੇ ਹਾਂ, ਜਿਸ ਵਿੱਚ, ਲਾਂਚ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਸੰਸਕਰਣ ਚੁਣ ਸਕਦੇ ਹਾਂ, ਕੰਟੇਨਰ ਨੂੰ ਪਾਸ ਕੀਤੇ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹਾਂ ENV, ਫਿਰ ਇਹ ਕੰਟੇਨਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਧੱਕਦਾ ਹੈ। ਫਿਰ ਉੱਥੋਂ ਕੰਟੇਨਰ ਨੂੰ ਕਿਊਬਰ ਦੇ ਰੂਪ ਵਿੱਚ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕੰਮ ਦਾ ਭਾਰ ਨੌਕਰੀ ਵਿੱਚ ਦਰਸਾਏ ਮਾਪਦੰਡਾਂ ਦੇ ਨਾਲ।

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

ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪ ਨਹੀਂ ਹਨ. ਦੋ ਗੱਲਾਂ ਤੁਰੰਤ ਮਨ ਵਿਚ ਆਈਆਂ:

• ਰਿਮੋਟ ਐਕਸੈਸ API ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੋ ਜੇਨਕਿੰਸ ਆਪਣੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ;
• ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਫੋਲਡਰ ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਲਈ ਬੇਨਤੀ ਕਰੋ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਇਹ JFrog ਆਰਟੀਫੈਕਟਰੀ ਹੈ, ਜੋ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ).

ਜੇਨਕਿੰਸ ਰਿਮੋਟ ਐਕਸੈਸ API

ਸਥਾਪਿਤ ਸ਼ਾਨਦਾਰ ਪਰੰਪਰਾ ਦੇ ਅਨੁਸਾਰ, ਮੈਂ ਲੰਬੇ ਵਿਆਖਿਆਵਾਂ ਤੋਂ ਬਚਣਾ ਪਸੰਦ ਕਰਾਂਗਾ.
ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਪਹਿਲੇ ਪੈਰੇ ਦੇ ਇੱਕ ਟੁਕੜੇ ਦੇ ਇੱਕ ਮੁਫਤ ਅਨੁਵਾਦ ਦੀ ਆਗਿਆ ਦੇਵਾਂਗਾ API ਦਸਤਾਵੇਜ਼ਾਂ ਦਾ ਪਹਿਲਾ ਪੰਨਾ:

ਜੇਨਕਿੰਸ ਇਸਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਲਈ ਰਿਮੋਟ ਮਸ਼ੀਨ-ਪੜ੍ਹਨਯੋਗ ਪਹੁੰਚ ਲਈ ਇੱਕ API ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। <…> ਰਿਮੋਟ ਐਕਸੈਸ ਇੱਕ REST ਵਰਗੀ ਸ਼ੈਲੀ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਈ ਕੋਈ ਸਿੰਗਲ ਐਂਟਰੀ ਬਿੰਦੂ ਨਹੀਂ ਹੈ, ਪਰ ਇਸਦੀ ਬਜਾਏ ਇੱਕ URL ਜਿਵੇਂ ".../api/", ਕਿੱਥੇ"..." ਦਾ ਅਰਥ ਹੈ ਉਹ ਵਸਤੂ ਜਿਸ 'ਤੇ API ਸਮਰੱਥਾਵਾਂ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ।

ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਜੇਕਰ ਤੈਨਾਤੀ ਕਾਰਜ ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਇਸ ਵੇਲੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ, ਇੱਥੇ ਉਪਲਬਧ ਹੈ http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build, ਫਿਰ ਇਸ ਕੰਮ ਲਈ API ਸੀਟੀਆਂ 'ਤੇ ਉਪਲਬਧ ਹਨ http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/

ਅੱਗੇ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਕਲਪ ਹੈ ਕਿ ਆਉਟਪੁੱਟ ਨੂੰ ਕਿਸ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਆਓ XML 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰੀਏ, ਕਿਉਂਕਿ API ਸਿਰਫ ਇਸ ਕੇਸ ਵਿੱਚ ਫਿਲਟਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਆਓ ਹੁਣੇ ਸਾਰੀਆਂ ਨੌਕਰੀਆਂ ਦੀਆਂ ਦੌੜਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਅਸੀਂ ਸਿਰਫ ਅਸੈਂਬਲੀ ਦੇ ਨਾਮ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ (ਦਿਖਾਇਆ ਹੋਇਆ ਨਾਮ) ਅਤੇ ਇਸਦਾ ਨਤੀਜਾ (ਇਸ ਦਾ ਨਤੀਜਾ):

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]

ਕੀ ਇਹ ਕੰਮ ਕੀਤਾ?

ਹੁਣ ਸਿਰਫ ਉਹਨਾਂ ਦੌੜਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੀਏ ਜੋ ਨਤੀਜੇ ਦੇ ਨਾਲ ਖਤਮ ਹੁੰਦੀਆਂ ਹਨ ਸਫਲਤਾ. ਆਓ ਦਲੀਲ ਦੀ ਵਰਤੋਂ ਕਰੀਏ &ਛੱਡੋ ਅਤੇ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਮੁੱਲ ਦਾ ਮਾਰਗ ਪਾਸ ਕਰਾਂਗੇ ਜਿਸ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ ਸਫਲਤਾ. ਹਾ ਹਾ. ਇੱਕ ਡਬਲ ਨਕਾਰਾਤਮਕ ਇੱਕ ਬਿਆਨ ਹੈ. ਅਸੀਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਬਾਹਰ ਰੱਖਦੇ ਹਾਂ ਜੋ ਸਾਡੀ ਦਿਲਚਸਪੀ ਨਹੀਂ ਰੱਖਦਾ:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS']

ਸਫਲ ਦੀ ਸੂਚੀ ਦਾ ਸਕ੍ਰੀਨਸ਼ੌਟ

ਖੈਰ, ਕੇਵਲ ਮਜ਼ੇ ਲਈ, ਆਓ ਇਹ ਯਕੀਨੀ ਕਰੀਏ ਕਿ ਫਿਲਟਰ ਨੇ ਸਾਨੂੰ ਧੋਖਾ ਨਹੀਂ ਦਿੱਤਾ (ਫਿਲਟਰ ਕਦੇ ਝੂਠ ਨਹੀਂ ਬੋਲਦੇ!) ਅਤੇ "ਅਸਫਲ" ਲੋਕਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਾਂ:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS']

ਗੈਰ-ਸਫਲ ਵਿਅਕਤੀਆਂ ਦੀ ਸੂਚੀ ਦਾ ਸਕ੍ਰੀਨਸ਼ੌਟ

ਰਿਮੋਟ ਸਰਵਰ 'ਤੇ ਫੋਲਡਰ ਤੋਂ ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ

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

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

curl -H "X-JFrog-Art-Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

ਜੇਨਕਿੰਸ ਵਿੱਚ ਨੌਕਰੀਆਂ ਅਤੇ ਨੌਕਰੀ ਦੀ ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਸੈਟ ਕਰਨਾ

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

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

ਅਤੇ ਹੁਣ ਮਜ਼ੇਦਾਰ ਹਿੱਸਾ. ਜੇਨਕਿੰਸ ਨੌਕਰੀ ਦੀਆਂ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਫਾਈਲਾਂ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ। XML ਫਾਰਮੈਟ ਵਿੱਚ. ਰਸਤੇ ਵਿੱਚ http://путь-до-задания/config.xml ਇਸ ਅਨੁਸਾਰ, ਤੁਸੀਂ ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ, ਇਸ ਨੂੰ ਲੋੜ ਅਨੁਸਾਰ ਸੰਪਾਦਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਵਾਪਸ ਪਾ ਸਕਦੇ ਹੋ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਇਹ ਮਿਲਿਆ ਹੈ.

ਯਾਦ ਰੱਖੋ, ਅਸੀਂ ਉੱਪਰ ਸਹਿਮਤ ਹੋਏ ਹਾਂ ਕਿ ਅਸੀਂ ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਬਣਾਵਾਂਗੇ BUILD_VERSION?

ਆਉ ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰੀਏ ਅਤੇ ਇਸਦੇ ਅੰਦਰ ਇੱਕ ਝਾਤ ਮਾਰੀਏ. ਸਿਰਫ਼ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਪੈਰਾਮੀਟਰ ਥਾਂ 'ਤੇ ਹੈ ਅਤੇ ਲੋੜੀਂਦੀ ਕਿਸਮ ਦਾ ਹੈ।

ਵਿਗਾੜਨ ਦੇ ਅਧੀਨ ਸਕ੍ਰੀਨਸ਼ੌਟ।

ਤੁਹਾਡਾ config.xml ਫਰੈਗਮੈਂਟ ਇੱਕੋ ਜਿਹਾ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਿਵਾਏ ਕਿ ਚੋਣਾਂ ਦੇ ਤੱਤ ਦੀ ਸਮੱਗਰੀ ਅਜੇ ਗੁੰਮ ਹੈ

ਤੁਹਾਨੂੰ ਪੂਰਾ ਵਿਸ਼ਵਾਸ ਹੈ? ਬੱਸ, ਆਓ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੀਏ ਜੋ ਬਿਲਡ ਸਫਲ ਹੋਣ 'ਤੇ ਚਲਾਇਆ ਜਾਵੇਗਾ।
ਸਕ੍ਰਿਪਟ ਸੰਸਕਰਣਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੇਗੀ, ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰੇਗੀ, ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ ਉਸ ਥਾਂ ਤੇ ਲਿਖ ਦੇਵੇਗੀ ਜਿਸਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਵਾਪਸ ਪਾ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਹਾਂ। ਇਹ ਠੀਕ ਹੈ. XML ਵਿੱਚ ਸੰਸਕਰਣਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਉਸ ਜਗ੍ਹਾ ਲਿਖੋ ਜਿੱਥੇ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ ਹੈ (ਭਵਿੱਖ ਵਿੱਚ, ਸਕ੍ਰਿਪਟ ਦੇ ਪਹਿਲੇ ਲਾਂਚ ਤੋਂ ਬਾਅਦ)। ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਸੰਸਾਰ ਵਿੱਚ ਅਜੇ ਵੀ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੇ ਕੱਟੜ ਪ੍ਰਸ਼ੰਸਕ ਹਨ. ਮੈਂ ਉਹਨਾਂ ਦਾ ਨਹੀਂ ਹਾਂ। ਕਿਰਪਾ ਕਰਕੇ ਇੰਸਟਾਲ ਕਰੋ xmlstarler ਮਸ਼ੀਨ ਨੂੰ ਜਿੱਥੇ ਸੰਰਚਨਾ ਨੂੰ ਸੰਪਾਦਿਤ ਕੀਤਾ ਜਾਵੇਗਾ. ਇਹ ਮੈਨੂੰ ਜਾਪਦਾ ਹੈ ਕਿ ਇਹ sed ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ ਭੁਗਤਾਨ ਕਰਨ ਲਈ ਇੰਨੀ ਵੱਡੀ ਕੀਮਤ ਨਹੀਂ ਹੈ.

ਵਿਗਾੜਨ ਦੇ ਅਧੀਨ, ਮੈਂ ਉਹ ਕੋਡ ਪੇਸ਼ ਕਰਦਾ ਹਾਂ ਜੋ ਉਪਰੋਕਤ ਕ੍ਰਮ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਰਦਾ ਹੈ.

ਰਿਮੋਟ ਸਰਵਰ ਉੱਤੇ ਇੱਕ ਫੋਲਡਰ ਤੋਂ ਸੰਰਚਨਾ ਵਿੱਚ ਸੰਸਕਰਣਾਂ ਦੀ ਸੂਚੀ ਲਿਖੋ

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Читаем в массив список версий из репозитория
readarray -t vers < <( curl -H "X-JFrog-Art-Api:Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

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

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

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Пишем в файл список версий из Jenkins
curl -g -X GET -u username:apiKey 'http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!=%22SUCCESS%22]&pretty=true' -o builds.xml

############## Читаем в массив список версий из XML
readarray vers < <(xmlstarlet sel -t -v "freeStyleProject/allBuild/displayName" builds.xml | awk -F":" '{print $2}')

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

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

ਸੰਸਕਰਣਾਂ ਦੀ ਸਹੀ ਢੰਗ ਨਾਲ ਪੂਰੀ ਕੀਤੀ ਗਈ ਸੂਚੀ

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

ਕਲਾਊਡ ਸ਼ੈੱਲ ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

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

ਮੈਂ ਫੈਸਲਾ ਕੀਤਾ: ਠੀਕ ਹੈ, ਕਿਉਂਕਿ ਕੰਟੇਨਰ "ਬਾਕਸ ਤੋਂ ਬਾਹਰ" ਕਲਾਉਡ ਕੰਸੋਲ ਵਿੱਚ ਇਕੱਠੇ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਫਿਰ ਕਿਉਂ ਪਰੇਸ਼ਾਨ ਹੋ? ਇਸ ਨੂੰ ਸਾਫ਼ ਰੱਖੋ, ਠੀਕ ਹੈ? ਮੈਂ ਕਲਾਉਡ ਕੰਸੋਲ ਵਿੱਚ ਜੇਨਕਿੰਸ ਕੰਟੇਨਰਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਉੱਥੋਂ ਕਿਊਬਰ ਵਿੱਚ ਲਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਗੂਗਲ ਕੋਲ ਇਸਦੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਬਹੁਤ ਅਮੀਰ ਚੈਨਲ ਹਨ, ਜਿਸਦਾ ਤੈਨਾਤੀ ਦੀ ਗਤੀ 'ਤੇ ਲਾਹੇਵੰਦ ਪ੍ਰਭਾਵ ਹੋਵੇਗਾ।

ਕਲਾਉਡ ਕੰਸੋਲ ਨਾਲ ਜੁੜਨ ਲਈ, ਤੁਹਾਨੂੰ ਦੋ ਚੀਜ਼ਾਂ ਦੀ ਲੋੜ ਹੈ: gcloud ਅਤੇ ਤੱਕ ਪਹੁੰਚ ਅਧਿਕਾਰ Google Cloud API VM ਉਦਾਹਰਨ ਲਈ ਜਿਸ ਨਾਲ ਇਹ ਉਹੀ ਕੁਨੈਕਸ਼ਨ ਬਣਾਇਆ ਜਾਵੇਗਾ।

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

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

ਅਧਿਕਾਰ ਦੇਣ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਵੈੱਬ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਹੈ।

1. VM ਉਦਾਹਰਣ ਨੂੰ ਰੋਕੋ ਜਿਸ ਤੋਂ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਕਲਾਉਡ ਕੰਸੋਲ ਨਾਲ ਕਨੈਕਟ ਕਰੋਗੇ।
2. ਉਦਾਹਰਨ ਵੇਰਵੇ ਖੋਲ੍ਹੋ ਅਤੇ ਕਲਿੱਕ ਕਰੋ ਸੋਧ.
3. ਪੰਨੇ ਦੇ ਬਿਲਕੁਲ ਹੇਠਾਂ, ਉਦਾਹਰਨ ਐਕਸੈਸ ਸਕੋਪ ਚੁਣੋ ਸਾਰੇ ਕਲਾਉਡ API ਤੱਕ ਪੂਰੀ ਪਹੁੰਚ.

   ਸਕ੍ਰੀਨਸ਼ੌਟ
   

4. ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ ਅਤੇ ਉਦਾਹਰਣ ਨੂੰ ਲਾਂਚ ਕਰੋ।

ਇੱਕ ਵਾਰ ਜਦੋਂ VM ਲੋਡ ਕਰਨਾ ਪੂਰਾ ਕਰ ਲੈਂਦਾ ਹੈ, ਤਾਂ ਇਸ ਨਾਲ SSH ਦੁਆਰਾ ਕਨੈਕਟ ਕਰੋ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੁਨੈਕਸ਼ਨ ਬਿਨਾਂ ਕਿਸੇ ਗਲਤੀ ਦੇ ਵਾਪਰਦਾ ਹੈ। ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ:

gcloud alpha cloud-shell ssh

ਇੱਕ ਸਫਲ ਕੁਨੈਕਸ਼ਨ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ

GKE 'ਤੇ ਤਾਇਨਾਤ ਕਰੋ

ਕਿਉਂਕਿ ਅਸੀਂ IaC (ਇੱਕ ਕੋਡ ਦੇ ਤੌਰ ਤੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ) ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਦਲਣ ਲਈ ਹਰ ਸੰਭਵ ਤਰੀਕੇ ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਾਂ, ਸਾਡੀਆਂ ਡੌਕਰ ਫਾਈਲਾਂ Git ਵਿੱਚ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਹ ਇੱਕ ਪਾਸੇ ਹੈ. ਅਤੇ kubernetes ਵਿੱਚ ਤੈਨਾਤੀ ਨੂੰ ਇੱਕ yaml ਫਾਈਲ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਸਿਰਫ ਇਸ ਕੰਮ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਖੁਦ ਵੀ ਕੋਡ ਵਾਂਗ ਹੈ। ਇਹ ਦੂਜੇ ਪਾਸੇ ਤੋਂ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, ਮੇਰਾ ਮਤਲਬ ਹੈ, ਯੋਜਨਾ ਇਹ ਹੈ:

1. ਅਸੀਂ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਲੈਂਦੇ ਹਾਂ BUILD_VERSION ਅਤੇ, ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ, ਵੇਰੀਏਬਲਾਂ ਦੇ ਮੁੱਲ ਜੋ ਪਾਸ ਕੀਤੇ ਜਾਣਗੇ ENV.
2. ਡੌਕਰਫਾਈਲ ਨੂੰ ਗਿੱਟ ਤੋਂ ਡਾਊਨਲੋਡ ਕਰੋ।
3. ਤੈਨਾਤੀ ਲਈ yaml ਬਣਾਓ।
4. ਅਸੀਂ ਇਹਨਾਂ ਦੋਵਾਂ ਫਾਈਲਾਂ ਨੂੰ scp ਰਾਹੀਂ ਕਲਾਉਡ ਕੰਸੋਲ ਉੱਤੇ ਅੱਪਲੋਡ ਕਰਦੇ ਹਾਂ।
5. ਅਸੀਂ ਉੱਥੇ ਇੱਕ ਕੰਟੇਨਰ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਧੱਕਦੇ ਹਾਂ
6. ਅਸੀਂ ਲੋਡ ਡਿਪਲਾਇਮੈਂਟ ਫਾਈਲ ਨੂੰ ਕਿਊਬਰ 'ਤੇ ਲਾਗੂ ਕਰਦੇ ਹਾਂ।

ਆਓ ਹੋਰ ਖਾਸ ਬਣੀਏ। ਇੱਕ ਵਾਰ ਅਸੀਂ ਗੱਲ ਕਰਨੀ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤੀ ENV, ਫਿਰ ਮੰਨ ਲਓ ਕਿ ਸਾਨੂੰ ਦੋ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: PARAM1 и PARAM2. ਅਸੀਂ ਉਹਨਾਂ ਦੇ ਕੰਮ ਨੂੰ ਤੈਨਾਤੀ ਲਈ ਜੋੜਦੇ ਹਾਂ, ਟਾਈਪ - ਸਟ੍ਰਿੰਗ ਪੈਰਾਮੀਟਰ.

ਸਕ੍ਰੀਨਸ਼ੌਟ

ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਰੀਡਾਇਰੈਕਸ਼ਨ ਨਾਲ yaml ਬਣਾਵਾਂਗੇ ਈਕੋ ਫਾਈਲ ਕਰਨ ਲਈ. ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਬੇਸ਼ਕ, ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੀ ਡੌਕਰਫਾਈਲ ਵਿੱਚ ਹੈ PARAM1 и PARAM2ਕਿ ਲੋਡ ਨਾਮ ਹੋਵੇਗਾ awesomeapp, ਅਤੇ ਨਿਰਧਾਰਿਤ ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ ਦੇ ਨਾਲ ਅਸੈਂਬਲ ਕੀਤੇ ਕੰਟੇਨਰ ਵਿੱਚ ਪਿਆ ਹੈ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਰਸਤੇ ਵਿਚ ਹਾਂ gcr.io/awesomeapp/awesomeapp-$BUILD_VERSIONਕਿੱਥੇ $BUILD_VERSION ਹੁਣੇ ਹੀ ਡ੍ਰੌਪ-ਡਾਉਨ ਸੂਚੀ ਵਿੱਚੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ।

ਟੀਮ ਸੂਚੀਕਰਨ

touch deploy.yaml
echo "apiVersion: apps/v1" >> deploy.yaml
echo "kind: Deployment" >> deploy.yaml
echo "metadata:" >> deploy.yaml
echo "  name: awesomeapp" >> deploy.yaml
echo "spec:" >> deploy.yaml
echo "  replicas: 1" >> deploy.yaml
echo "  selector:" >> deploy.yaml
echo "    matchLabels:" >> deploy.yaml
echo "      run: awesomeapp" >> deploy.yaml
echo "  template:" >> deploy.yaml
echo "    metadata:" >> deploy.yaml
echo "      labels:" >> deploy.yaml
echo "        run: awesomeapp" >> deploy.yaml
echo "    spec:" >> deploy.yaml
echo "      containers:" >> deploy.yaml
echo "      - name: awesomeapp" >> deploy.yaml
echo "        image: gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION:latest" >> deploy.yaml
echo "        env:" >> deploy.yaml
echo "        - name: PARAM1" >> deploy.yaml
echo "          value: $PARAM1" >> deploy.yaml
echo "        - name: PARAM2" >> deploy.yaml
echo "          value: $PARAM2" >> deploy.yaml

ਜੇਨਕਿਨਸ ਏਜੰਟ ਦੀ ਵਰਤੋਂ ਨਾਲ ਜੁੜਨ ਤੋਂ ਬਾਅਦ gcloud alpha cloud-shell ssh ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਉਪਲਬਧ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਲਾਉਡ ਕੰਸੋਲ ਨੂੰ ਕਮਾਂਡਾਂ ਭੇਜਦੇ ਹਾਂ --ਕਮਾਂਡ.

ਅਸੀਂ ਪੁਰਾਣੀ ਡੌਕਰਫਾਈਲ ਤੋਂ ਕਲਾਉਡ ਕੰਸੋਲ ਵਿੱਚ ਹੋਮ ਫੋਲਡਰ ਨੂੰ ਸਾਫ਼ ਕਰਦੇ ਹਾਂ:

gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"

scp ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਲਾਉਡ ਕੰਸੋਲ ਦੇ ਹੋਮ ਫੋਲਡਰ ਵਿੱਚ ਤਾਜ਼ੀ ਡਾਊਨਲੋਡ ਕੀਤੀ ਡੌਕਰਫਾਈਲ ਰੱਖੋ:

gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~

ਅਸੀਂ ਕੰਟੇਨਰ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ, ਟੈਗ ਕਰਦੇ ਹਾਂ ਅਤੇ ਕੰਟੇਨਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਪੁਸ਼ ਕਰਦੇ ਹਾਂ:

gcloud alpha cloud-shell ssh --command="docker build -t awesomeapp-$BUILD_VERSION ./ --build-arg BUILD_VERSION=$BUILD_VERSION --no-cache"
gcloud alpha cloud-shell ssh --command="docker tag awesomeapp-$BUILD_VERSION gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
gcloud alpha cloud-shell ssh --command="docker push gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"

ਅਸੀਂ ਤੈਨਾਤੀ ਫਾਈਲ ਨਾਲ ਵੀ ਅਜਿਹਾ ਹੀ ਕਰਦੇ ਹਾਂ। ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਮਾਂਡਾਂ ਕਲੱਸਟਰ ਦੇ ਫਰਜ਼ੀ ਨਾਂ ਵਰਤਦੀਆਂ ਹਨ ਜਿੱਥੇ ਤੈਨਾਤੀ ਹੁੰਦੀ ਹੈ (awsm-ਕਲੱਸਟਰ) ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦਾ ਨਾਮ (awesome-ਪ੍ਰੋਜੈਕਟ), ਜਿੱਥੇ ਕਲੱਸਟਰ ਸਥਿਤ ਹੈ।

gcloud alpha cloud-shell ssh --command="rm -f deploy.yaml"
gcloud alpha cloud-shell scp localhost:./deploy.yaml cloudshell:~
gcloud alpha cloud-shell ssh --command="gcloud container clusters get-credentials awsm-cluster --zone us-central1-c --project awesome-project && 
kubectl apply -f deploy.yaml"

ਅਸੀਂ ਕੰਮ ਚਲਾਉਂਦੇ ਹਾਂ, ਕੰਸੋਲ ਆਉਟਪੁੱਟ ਖੋਲ੍ਹਦੇ ਹਾਂ ਅਤੇ ਕੰਟੇਨਰ ਦੀ ਸਫਲ ਅਸੈਂਬਲੀ ਨੂੰ ਦੇਖਣ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹਾਂ।

ਸਕ੍ਰੀਨਸ਼ੌਟ

ਅਤੇ ਫਿਰ ਅਸੈਂਬਲਡ ਕੰਟੇਨਰ ਦੀ ਸਫਲ ਤੈਨਾਤੀ

ਸਕ੍ਰੀਨਸ਼ੌਟ

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

ਸਿੱਟੇ ਦੀ ਬਜਾਏ

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

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

ਸਰੋਤ: www.habr.com