Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੁਬਰਨੇਟਸ ਲਈ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਵਿਕਾਸ ਕਰਨਾ

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

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

ਰਵਾਇਤੀ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ

ਰਵਾਇਤੀ ਵਿਕਾਸ ਦੀ ਪ੍ਰਕਿਰਿਆ ਜਾਵਾ (ਚਿੱਤਰ 1) ਵਿੱਚ ਡਿਵੈਲਪਰ ਕੋਡ ਲਿਖਣਾ, ਫਿਰ JAR ਜਾਂ WAR ਫਾਈਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਪਲਾਇਮੈਂਟ ਯੂਨਿਟ ਬਣਾਉਣਾ, ਅਤੇ ਫਿਰ ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਵੈਬ ਜਾਂ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ 'ਤੇ ਤੈਨਾਤ ਕਰਨਾ ਅਤੇ ਚਲਾਉਣਾ ਸ਼ਾਮਲ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਦਾ ਮੁੱਖ ਤਰੀਕਾ ਹੈ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਮਾਵੇਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕੋਡ ਅਤੇ ਪੈਕੇਜ ਕਰਨ ਲਈ IntelliJ ਜਾਂ Eclipse ਵਰਗੇ IDE ਦੀ ਵਰਤੋਂ ਕਰਨਾ। ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਕੋਡ ਬਦਲਣ ਅਤੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਵਿੱਚ ਜਮ੍ਹਾਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਚੀਜ਼ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਚੌਲ. 1. ਰਵਾਇਤੀ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ।

ਕਲਾਉਡ ਲਈ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ

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

ਕਲਾਉਡ ਵਿੱਚ ਤਬਦੀਲੀ ਵਿੱਚ ਪਰੰਪਰਾਗਤ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦਾ ਰੂਪਾਂਤਰ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। 2.

ਚੌਲ. 2. ਕਲਾਉਡ ਲਈ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ।

ਗ੍ਰਹਿਣ JKube

ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਹੋਰ ਸੰਚਾਲਨ ਪਰਤ ਜੋੜਦਾ ਹੈ, ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਇਸ ਬਾਰੇ ਘਬਰਾ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨ ਦੀ ਬਜਾਏ ਉਹਨਾਂ ਦੇ ਮੁੱਖ ਕੰਮ - ਐਪਲੀਕੇਸ਼ਨ ਤਰਕ - ਉੱਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ। ਅਤੇ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਇਹ ਖੇਡ ਵਿੱਚ ਆਉਂਦਾ ਹੈ. ਗ੍ਰਹਿਣ JKube, ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਪਲੱਗਇਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (JKube ਕਿੱਟ ਇਕੱਠੇ ਮਿਲ ਕੇ ਕੁਬਰਨੇਟਸ ਮਾਵੇਨ ਪਲੱਗਇਨ ਜ OpenShift Maven ਪਲੱਗਇਨ) ਚਿੱਤਰ ਵਿੱਚ ਚਿੱਤਰ ਦੀ ਪਾਲਣਾ ਕਰਕੇ ਕੰਟੇਨਰ ਅਤੇ ਕੁਬਰਨੇਟਸ-ਸਬੰਧਤ ਕਾਰਵਾਈਆਂ ਨੂੰ ਅਸਾਨੀ ਨਾਲ ਕਰਨ ਲਈ। 2.

ਇਸ ਲੇਖ ਦੇ ਬਾਕੀ ਹਿੱਸੇ ਵਿੱਚ, ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕੁਬਰਨੇਟਸ ਮਾਵੇਨ ਪਲੱਗਇਨ ਨਾਲ Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਬਰਨੇਟਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਵੇਂ ਸਰਲ ਬਣਾਇਆ ਜਾਵੇ।

Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਲਾਉਡ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ

ਆਉ ਚਿੱਤਰ 2 ਤੋਂ ਕਲਾਉਡ ਲਈ ਇੱਕ ਥੋੜੀ ਸੋਧੀ ਜਾਵਾ ਵਿਕਾਸ ਸਕੀਮ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ, ਇਸ ਵਿੱਚ Eclipse JKube ਅਤੇ Kubernetes Maven Plugin ਨੂੰ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। 3.

ਚੌਲ. 3. Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਲਾਉਡ ਲਈ ਜਾਵਾ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ।

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

ਟੇਬਲ 1. Eclipse JKube ਡਿਫੌਲਟ ਕਾਰਜ।

ਉਦੇਸ਼
ਸਟੇਜ
ਵੇਰਵਾ

k8s:ਬਿਲਡ
PRE_INTEGRATION_TEST
ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣਾ

k8s: ਧੱਕਾ
INSTALL
ਰਜਿਸਟਰੀ ਵਿੱਚ ਡੌਕਰ ਚਿੱਤਰਾਂ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨਾ

k8s: ਸਰੋਤ
PROCESS_RESOURCES
K8s ਮੈਨੀਫੈਸਟ ਬਣਾਉਣਾ

k8s: ਲਾਗੂ ਕਰੋ
ਕੰਪਾਇਲ ਕਰੋ
K8s 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਮੈਨੀਫੈਸਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

k8s: undeploy
ਅਣਡਿਪਲੋਏ
K8s ਸਰੋਤਾਂ ਨੂੰ ਹਟਾਉਣਾ ਜੋ k8s:apply ਅਤੇ k8s:deploy ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੈਨਾਤ ਕੀਤੇ ਗਏ ਸਨ

ਨੋਟ: ਜੇਕਰ ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਕੰਮ ਇਹਨਾਂ ਵਿਚਾਰਧਾਰਕ ਡਿਫੌਲਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਲਈ ਇਕਲਿਪਸ ਜੇਕਿਊਬ ਨੂੰ ਹੱਥੀਂ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ, ਕਿਉਂਕਿ ਇਹ ਇਸ ਦੁਆਰਾ ਸੰਰਚਨਾ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ XML и ਸਰੋਤ.

ਆਉ ਹੁਣ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ Eclipse JKube ਅਤੇ Kubernetes Maven Plugin ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਦੇਖੀਏ।

Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Kubernetes 'ਤੇ ਇੱਕ Java ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਨਾ

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਕਲੱਸਟਰ 'ਤੇ ਤਾਇਨਾਤ ਕਰਾਂਗੇ ਮਿਨੀਕੂਬੇ Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ. Kubernetes Maven ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਸੰਰਚਨਾ ਨੂੰ ਲਿਖਣ ਦੇ ਤੈਨਾਤੀ ਮਾਪਦੰਡ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ।

ਇੱਕ ਉਦਾਹਰਨ ਐਪਲੀਕੇਸ਼ਨ ਵਜੋਂ ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਸਧਾਰਨ ਬੇਤਰਤੀਬ ਨੰਬਰ ਜਨਰੇਟਰ, ਜੋ /ਰੈਂਡਮ ਐਂਡਪੁਆਇੰਟ 'ਤੇ JSON ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ:

~/work/repos/eclipse-jkube-demo-project : $ curl localhost:8080/random | jq .
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100    45    0    45    0     0    818      0 --:--:-- --:--:-- --:--:--   818
{
  "id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}

ਕਦਮ 1. Kubernetes Maven ਪਲੱਗਇਨ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ

Kubernetes Maven ਪਲੱਗਇਨ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਹੈ ਮਾਵੇਨ ਸੈਂਟਰਲ ਰਿਪੋਜ਼ਟਰੀ. Eclipse JKube ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਕੁਬਰਨੇਟਸ ਮਾਵੇਨ ਪਲੱਗਇਨ ਨੂੰ ਆਪਣੇ pom.xml ਵਿੱਚ ਇੱਕ ਨਿਰਭਰਤਾ ਵਜੋਂ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ:

<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>kubernetes-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>

ਜੇਕਰ ਸ਼ੁੱਧ ਕੁਬਰਨੇਟਸ ਦੀ ਬਜਾਏ OpenShift ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ pom.xml ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸੋਧਿਆ ਜਾਂਦਾ ਹੈ:

<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>openshift-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>

ਕਦਮ 2. ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਓ

ਐਪਲੀਕੇਸ਼ਨ ਦੀ JAR ਫਾਈਲ ਨੂੰ mvn ਪੈਕੇਜ ਕਮਾਂਡ ਨਾਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਫਿਰ mvn ਗੋਲ ਟਾਸਕ k8s:build ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਅਸੀਂ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਨਾਲ ਡਿਫੌਲਟ ਚਿੱਤਰ ਨਾਮ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਦਿੱਤਾ ਹੈ:

<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>

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

$ eval $(minikube docker-env)

ਫਿਰ ਅਸੀਂ mvn k8s:build ਕਮਾਂਡ ਦਾਖਲ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਇਹ ਉਹ ਹੈ ਜੋ ਅਸੀਂ Eclipse JKube ਬਿਲਡ ਟਾਸਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣ ਵੇਲੇ ਸਕ੍ਰੀਨ 'ਤੇ ਦੇਖਾਂਗੇ:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Running in Kubernetes mode
[INFO] k8s: Building Docker image in Kubernetes mode
[INFO] k8s: Running generator spring-boot
[INFO] k8s: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Created docker-build.tar in 251 milliseconds
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Built image sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  5.053 s
[INFO] Finished at: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $

ਕਦਮ 3. ਚਿੱਤਰ ਨੂੰ ਡੌਕਰ ਰਜਿਸਟਰੀ ਵਿੱਚ ਅੱਪਲੋਡ ਕਰੋ

ਜਦੋਂ ਅਸੀਂ ਡੌਕਰ ਚਿੱਤਰ ਨੂੰ ਪੁਸ਼ ਰਜਿਸਟਰੀ ਦੀ ਸੰਰਚਨਾ ਨਾਲ ਬਣਾਇਆ ਹੈ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਇਹ docker.io ਹੈ), ਅਸੀਂ ਇਸ ਚਿੱਤਰ ਨੂੰ ਰਜਿਸਟਰੀ ਨੂੰ ਭੇਜ ਸਕਦੇ ਹਾਂ। ਇਹ ਉਹ ਹੈ ਜੋ ਸਾਡੇ ਦੁਆਰਾ Eclipse JKube ਨੂੰ mvn k8s:ਪੁਸ਼ ਪੁਸ਼ ਟਾਸਕ ਕਰਨ ਲਈ ਕਹਿਣ ਤੋਂ ਬਾਅਦ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Running in Kubernetes mode
[INFO] k8s: Building Docker image in Kubernetes mode
[INFO] k8s: Running generator spring-boot
[INFO] k8s: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] k8s: The push refers to repository [docker.io/rohankanojia/random-generator]
5dcd9556710f: Layer already exists 
b7139ad07aa8: Layer already exists 
b6f081e4b2b6: Layer already exists 
d8e1f35641ac: Layer already exists 
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d size: 1162
[INFO] k8s: Pushed docker.io/rohankanojia/random-generator:0.0.1 in 7 seconds 
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.222 s
[INFO] Finished at: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ 

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

ਚੌਲ. 4. ਰਜਿਸਟਰੀ ਨੂੰ ਭੇਜੀ ਗਈ ਤਸਵੀਰ ਡੌਕਰ ਹੱਬ ਵਿੱਚ ਦਿਖਾਈ ਦਿੱਤੀ।

ਕਦਮ 4. ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਕੁਬਰਨੇਟਸ ਸਰੋਤ ਮੈਨੀਫੈਸਟ ਤਿਆਰ ਕਰੋ

ਇਸ ਲਈ, ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰ ਲਿਆ ਹੈ, ਹੁਣ ਸਾਨੂੰ ਕੁਬਰਨੇਟਸ ਮੈਨੀਫੈਸਟ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, Eclipse JKube ਕੋਲ ਇੱਕ ਕੰਮ ਹੈ ਜੋ ਅੰਡਰਲਾਈੰਗ Java ਫਰੇਮਵਰਕ (ਬਸੰਤ ਬੂਟ, ਕਵਾਕਰਸ, Vert.x ਜਾਂ ਕੁਝ ਹੋਰ)। ਤੁਸੀਂ ਇੱਕ XML ਸੰਰਚਨਾ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਫੋਲਡਰ src/main/jkube ਵਿੱਚ ਕੱਚੇ ਟੁਕੜੇ (ਲੋੜੀਂਦੇ ਸਰੋਤ ਮੈਨੀਫੈਸਟ ਦੇ ਟੁਕੜੇ) ਰੱਖ ਕੇ ਵੀ ਮੈਨੀਫੈਸਟ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਹਾਡੀ ਸੰਰਚਨਾ ਨੂੰ ਤਿਆਰ ਕੀਤੇ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਅੱਪਲੋਡ ਕੀਤਾ ਜਾਵੇਗਾ।

ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਸਭ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਛੱਡ ਦਿੰਦੇ ਹਾਂ, ਅਤੇ ਇਸਲਈ Eclipse JKube ਡਿਫਾਲਟ ਤੈਨਾਤੀ ਲਈ ਅਤੇ ClusterIP ਕਿਸਮ ਵਾਲੀ ਸੇਵਾ ਲਈ ਇੱਕ ਮੈਨੀਫੈਸਟ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਅਤੇ ਕੇਵਲ ਤਦ ਹੀ ਅਸੀਂ ਸੇਵਾ ਦੀ ਕਿਸਮ ਨੂੰ NodePort ਵਿੱਚ ਬਦਲਣ ਲਈ ਸੇਵਾ ਮੈਨੀਫੈਸਟ ਨੂੰ ਸੋਧਦੇ ਹਾਂ। ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਿਫੌਲਟ ਵਿਵਹਾਰ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦੇ ਹੋ:

<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>

Eclipse JKube ਨੂੰ mvn k8s:resource ਸਰੋਤ ਕਾਰਜ ਕਰਨ ਲਈ ਕਹਿਣ ਤੋਂ ਬਾਅਦ ਸਕਰੀਨ ਆਉਟਪੁੱਟ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Running generator spring-boot
[INFO] k8s: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] k8s: jkube-controller: Adding a default Deployment
[INFO] k8s: jkube-service: Adding a default service 'random-generator' with ports [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Adding readiness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 10 seconds
[INFO] k8s: jkube-healthcheck-spring-boot: Adding liveness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 180 seconds
[INFO] k8s: jkube-revision-history: Adding revision history limit to 2
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  3.344 s
[INFO] Finished at: 2020-08-10T11:38:11+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ ls target/classes/META-INF/jkube/kubernetes
random-generator-deployment.yml  random-generator-service.yml
~/work/repos/eclipse-jkube-demo-project : $ cat target/classes/META-INF/jkube/kubernetes/random-generator-deployment.yml | head -n10
---
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    jkube.io/git-url: [email protected]:rohanKanojia/eclipse-jkube-demo-project.git
    jkube.io/git-commit: 1ef9ef2ef7a6fcbf8eb64c293f26f9c42d026512
    jkube.io/git-branch: master
    jkube.io/scm-url: https://github.com/spring-projects/spring-boot/spring-boot-starter-parent/random-generator
    jkube.io/scm-tag: HEAD
~/work/repos/eclipse-jkube-demo-project : $

ਕਦਮ 5. ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ ਤੈਨਾਤ ਕਰੋ

ਹੁਣ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਤਿਆਰ ਹਾਂ: ਅਸੀਂ ਇਸਦਾ ਚਿੱਤਰ ਤਿਆਰ ਕੀਤਾ ਹੈ ਅਤੇ ਫਿਰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਰੋਤ ਮੈਨੀਫੈਸਟ ਤਿਆਰ ਕੀਤੇ ਹਨ। ਹੁਣ ਇਹ ਸਭ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਬਾਕੀ ਹੈ। ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਬੇਸ਼ਕ, kubectl apply -f ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਪਲੱਗਇਨ ਸਾਡੇ ਲਈ ਅਜਿਹਾ ਕਰ ਸਕਦੀ ਹੈ। ਇਹ ਉਹ ਹੈ ਜੋ ਸਕ੍ਰੀਨ 'ਤੇ ਦਿਖਾਈ ਦੇਵੇਗਾ ਜਦੋਂ ਅਸੀਂ Eclipse JKube ਨੂੰ mvn k8s:apply apply task ਨੂੰ ਚਲਾਉਣ ਲਈ ਕਹਾਂਗੇ:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Using Kubernetes at https://192.168.39.145:8443/ in namespace default with manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml 
[INFO] k8s: Using namespace: default
[INFO] k8s: Creating a Service from kubernetes.yml namespace default name random-generator
[INFO] k8s: Created Service: target/jkube/applyJson/default/service-random-generator.json
[INFO] k8s: Creating a Deployment from kubernetes.yml namespace default name random-generator
[INFO] k8s: Created Deployment: target/jkube/applyJson/default/deployment-random-generator.json
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  7.306 s
[INFO] Finished at: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
NAME                                                     READY   STATUS             RESTARTS   AGE
random-generator-58b7847d7f-9m9df                        0/1     Running            0          7s
random-generator-58b7847d7f-9m9df                        1/1     Running            0          17s
^C~/work/repos/eclipse-jkube-demo-project : $ kubectl get svc
NAME                                    TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)           AGE
io-openliberty-sample-getting-started   NodePort    10.110.4.104    <none>        9080:30570/TCP    44h
kubernetes                              ClusterIP   10.96.0.1       <none>        443/TCP           18d
random-generator                        NodePort    10.97.172.147   <none>        8080:32186/TCP    22s
~/work/repos/eclipse-jkube-demo-project : $ curl `minikube ip`:32186/random | jq .
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100    45    0    45    0     0   1800      0 --:--:-- --:--:-- --:--:--  1875
{
  "id": "42e5571f-a20f-44b3-8184-370356581d10"
}

ਕਦਮ 6. ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਤੋਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਹਟਾਓ

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਨਡਿਪਲਾਇ ਟਾਸਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਸਿਰਫ਼ ਪਿਛਲੇ ਪਗ ਵਿੱਚ ਲਾਗੂ ਕੀਤੇ ਗਏ ਸਾਰੇ ਸਰੋਤਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਭਾਵ, ਜਦੋਂ ਕਾਰਜ ਕਾਰਜ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਉਹ ਹੈ ਜੋ ਅਸੀਂ ਸਕ੍ਰੀਨ 'ਤੇ ਦੇਖਾਂਗੇ ਜਦੋਂ ਅਸੀਂ Eclipse JKube ਨੂੰ mvn k8s:undeploy undeploy ਟਾਸਕ ਕਰਨ ਲਈ ਕਹਾਂਗੇ:

~/work/repos/eclipse-jkube-demo-project : $ kubectl get all
NAME                                    READY   STATUS    RESTARTS   AGE
pod/random-generator-58b7847d7f-9m9df   1/1     Running   0          5m21s

NAME                       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/kubernetes         ClusterIP   10.96.0.1       <none>        443/TCP          18d
service/random-generator   NodePort    10.97.172.147   <none>        8080:32186/TCP   5m21s

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/random-generator   1/1     1            1           5m21s

NAME                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/random-generator-58b7847d7f   1         1         1       5m21s
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:undeploy
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Using Kubernetes at https://192.168.39.145:8443/ in namespace default with manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml 
[INFO] k8s: Using namespace: default
[INFO] k8s: Deleting resource Deployment default/random-generator
[INFO] k8s: Deleting resource Service default/random-generator
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  3.412 s
[INFO] Finished at: 2020-08-10T11:46:22+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
^C~/work/repos/eclipse-jkube-demo-project : $ kubectl get all
NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   18d
~/work/repos/eclipse-jkube-demo-project : $

ਤੁਸੀਂ Eclipse JKube ਨਾਲ ਹੋਰ ਕੀ ਕਰ ਸਕਦੇ ਹੋ

ਇਸ ਲਈ, ਅਸੀਂ Eclipse JKube ਅਤੇ Kubernetes Maven Plugin ਦੇ ਮੁੱਖ ਟੀਚੇ ਦੇ ਕੰਮਾਂ ਨੂੰ ਦੇਖਿਆ, ਜੋ ਕਿ ਕੁਬਰਨੇਟਸ ਪਲੇਟਫਾਰਮ ਲਈ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਵਿਕਾਸ ਦੀ ਸਹੂਲਤ ਦਿੰਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਕਾਰਜਾਂ ਨੂੰ ਕੀ-ਬੋਰਡ ਤੋਂ ਲਗਾਤਾਰ ਦਾਖਲ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਪਲੱਗਇਨ ਸੰਰਚਨਾ ਵਿੱਚ ਲਿਖ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਇਸ ਤਰ੍ਹਾਂ:

<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>kubernetes-maven-plugin</artifactId>
     <version>${project.version}</version>
     <executions>
         <execution>
             <goals>
                  <goal>build</goal>
                  <goal>resource</goal>
                  <goal>apply</goal>
             </goals>
         </execution>
     </executions>
</plugin>

ਇਹ ਕਿਹਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਉਹਨਾਂ ਸਾਰੇ ਟੀਚੇ ਕਾਰਜਾਂ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ ਹੈ ਜੋ Eclipse JKube ਅਤੇ Kubernetes Maven Plugin ਵਿੱਚ ਹਨ, ਇਸ ਲਈ ਅਸੀਂ ਟੇਬਲ 2 ਵਿੱਚ ਵਾਧੂ ਕਾਰਜਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਵੀ ਹੋ ਸਕਦੇ ਹਨ।

ਟੇਬਲ 2. ਵਾਧੂ ਗ੍ਰਹਿਣ JKube ਟੀਚਾ ਕਾਰਜ।

ਉਦੇਸ਼
ਸਟੇਜ
ਵੇਰਵਾ

k8s:log
ਪੜਤਾਲ
ਕੁਬਰਨੇਟਸ 'ਤੇ ਚੱਲ ਰਹੀ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਲੌਗ ਪ੍ਰਾਪਤ ਕਰਨਾ।

k8s:ਡੀਬੱਗ
ਪੈਕੇਜ
ਇੱਕ ਡੀਬੱਗ ਪੋਰਟ ਖੋਲ੍ਹੋ ਤਾਂ ਜੋ ਤੁਸੀਂ IDE ਤੋਂ ਸਿੱਧੇ Kubernetes 'ਤੇ ਚੱਲ ਰਹੀ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਡੀਬੱਗ ਕਰ ਸਕੋ।

k8s: deploy
INSTALL
ਇੰਸਟੌਲ ਟਾਸਕ ਲਈ ਫੋਰਕ ਬਣਾਉਣਾ ਅਤੇ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਮੈਨੀਫੈਸਟ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕਰਨਾ ਜਿਵੇਂ ਕਿ ਕਾਰਜ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਹੁੰਦਾ ਹੈ।

k8s: ਵਾਚ
ਪੈਕੇਜ
ਕਿਸੇ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਨੇਮਸਪੇਸ ਨੂੰ ਟਰੈਕ ਕਰਕੇ ਆਟੋਮੈਟਿਕ ਗਰਮ ਤੈਨਾਤੀ।

OpenShift Maven ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ Red Hat OpenShift ਉੱਤੇ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਸਾਡੇ ਉਦਾਹਰਨ ਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ Red Hat OpenShift ਪਲੇਟਫਾਰਮ 'ਤੇ ਤੈਨਾਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ OpenShift Maven. ਫਰਕ ਸਿਰਫ ਇਹ ਹੋਵੇਗਾ ਕਿ ਟਾਸਕ ਪ੍ਰੀਫਿਕਸ k8s ਤੋਂ oc ਵਿੱਚ ਬਦਲ ਜਾਵੇਗਾ। ਮੂਲ ਰੂਪ ਵਿੱਚ Kubernetes Maven ਪਲੱਗਇਨ ਕਰਦਾ ਹੈ ਡੌਕਰਅਸੈਂਬਲੀਆਂ, ਅਤੇ ਓਪਨਸ਼ਿਫਟ ਮੇਵੇਨ ਪਲੱਗਇਨ - ਅਸੈਂਬਲੀਆਂ S2I. ਅਸੀਂ jkube.generator.name ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਹਟਾਉਣ ਤੋਂ ਇਲਾਵਾ, ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਕਰ ਰਹੇ ਹਾਂ, ਕਿਉਂਕਿ ਰਜਿਸਟਰੀ ਵੱਲ ਧੱਕਣ ਵੇਲੇ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ (ਬਿਲਡ ਪੜਾਅ ਦੇ ਦੌਰਾਨ, OpenShift ਚਿੱਤਰ ਨੂੰ ਆਪਣੀ ਅੰਦਰੂਨੀ ਰਜਿਸਟਰੀ ਵਿੱਚ ਰੱਖਦਾ ਹੈ)। ਅਤੇ ਇਹ ਉਹੀ ਹੈ ਜੋ ਸਕ੍ਰੀਨ 'ਤੇ ਦਿਖਾਈ ਦੇਵੇਗਾ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਉਦਾਹਰਣ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ, ਜਿਸ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਨਹੀਂ, ਬਲਕਿ ਸਾਰੇ ਟੀਚੇ ਦੇ ਕੰਮ ਕਰਦੇ ਹਾਂ:

~/work/repos/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Scanning for projects...
[INFO] 
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Using OpenShift build with strategy S2I
[INFO] oc: Running in OpenShift mode
[INFO] oc: Running generator spring-boot
[INFO] oc: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Created docker source tar /home/rohaan/work/repos/eclipse-jkube-demo-project/target/docker/random-generator/0.0.1/tmp/docker-build.tar
[INFO] oc: Adding to Secret pullsecret-jkube
[INFO] oc: Using Secret pullsecret-jkube
[INFO] oc: Creating BuildServiceConfig random-generator-s2i for Source build
[INFO] oc: Creating ImageStream random-generator
[INFO] oc: Starting Build random-generator-s2i
[INFO] oc: Waiting for build random-generator-s2i-1 to complete...
[INFO] oc: Caching blobs under "/var/cache/blobs".
[INFO] oc: Getting image source signatures
[INFO] oc: Copying blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copying blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copying blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copying config sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: Generating dockerfile with builder image quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: STEP 1: FROM quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: STEP 2: LABEL "io.openshift.build.source-location"="/tmp/build/inputs"       "io.openshift.build.image"="quay.io/jkube/jkube-java-binary-s2i:0.0.7"
[INFO] oc: STEP 3: ENV JAVA_APP_DIR="/deployments"     OPENSHIFT_BUILD_NAME="random-generator-s2i-1"     OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: STEP 4: USER root
[INFO] oc: STEP 5: COPY upload/src /tmp/src
[INFO] oc: STEP 6: RUN chown -R 1000:0 /tmp/src
[INFO] oc: STEP 7: USER 1000
[INFO] oc: STEP 8: RUN /usr/local/s2i/assemble
[INFO] oc: INFO S2I source build with plain binaries detected
[INFO] oc: INFO S2I binary build from fabric8-maven-plugin detected
[INFO] oc: INFO Copying binaries from /tmp/src/deployments to /deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Copying deployments from deployments to /deployments...
[INFO] oc: '/tmp/src/deployments/random-generator-0.0.1.jar' -> '/deployments/random-generator-0.0.1.jar'
[INFO] oc: STEP 9: CMD /usr/local/s2i/run
[INFO] oc: STEP 10: COMMIT temp.builder.openshift.io/default/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image operating system mismatch: image uses "", expecting "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image architecture mismatch: image uses "", expecting "amd64""
[INFO] oc: Getting image source signatures
[INFO] oc: Copying blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Copying blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Copying blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Copying blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copying config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Getting image source signatures
[INFO] oc: 
[INFO] oc: Pushing image image-registry.openshift-image-registry.svc:5000/default/random-generator:0.0.1 ...
[INFO] oc: Copying blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copying blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copying blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copying blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copying config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: Successfully pushed image-registry.openshift-image-registry.svc:5000/default/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Push successful
[INFO] oc: Build random-generator-s2i-1 in status Complete
[INFO] oc: Found tag on ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator written to /home/rohaan/work/repos/eclipse-jkube-demo-project/target/random-generator-is.yml
[INFO] 
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] oc: Using docker image name of namespace: default
[INFO] oc: Running generator spring-boot
[INFO] oc: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] oc: jkube-controller: Adding a default DeploymentConfig
[INFO] oc: jkube-service: Adding a default service 'random-generator' with ports [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Adding readiness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 10 seconds
[INFO] oc: jkube-healthcheck-spring-boot: Adding liveness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 180 seconds
[INFO] oc: jkube-revision-history: Adding revision history limit to 2
[INFO] 
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Using OpenShift at https://api.crc.testing:6443/ in namespace default with manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/openshift.yml 
[INFO] oc: OpenShift platform detected
[INFO] oc: Using project: default
[INFO] oc: Creating a Service from openshift.yml namespace default name random-generator
[INFO] oc: Created Service: target/jkube/applyJson/default/service-random-generator.json
[INFO] oc: Creating a DeploymentConfig from openshift.yml namespace default name random-generator
[INFO] oc: Created DeploymentConfig: target/jkube/applyJson/default/deploymentconfig-random-generator.json
[INFO] oc: Creating Route default:random-generator host: null
[INFO] oc: HINT: Use the command `oc get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  01:07 min
[INFO] Finished at: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ oc get pods -w
NAME                           READY     STATUS      RESTARTS   AGE
random-generator-1-deploy      1/1       Running     0          14s
random-generator-1-vnrm9       0/1       Running     0          11s
random-generator-s2i-1-build   0/1       Completed   0          1m
random-generator-1-vnrm9   1/1       Running   0         24s
random-generator-1-deploy   0/1       Completed   0         28s
~/work/repos/eclipse-jkube-demo-project : $ oc get routes
NAME                HOST/PORT                                    PATH      SERVICES            PORT      TERMINATION   WILDCARD
random-generator    random-generator-default.apps-crc.testing              random-generator    8080                    None
~/work/repos/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing/random 
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
Dload  Upload   Total   Spent    Left  Speed
100    45    0    45    0     0   1666      0 --:--:-- --:--:-- --:--:--  1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~/work/repos/eclipse-jkube-demo-project : $

ਵੀਡੀਓ ਸਬਕ

Eclipse JKube ਨਾਲ ਕੁਬਰਨੇਟਸ ਦੇ ਵਿਕਾਸ ਨੂੰ ਆਸਾਨ ਬਣਾਉਣ ਬਾਰੇ ਹੋਰ ਜਾਣਨ ਲਈ, ਇਸ ਵੀਡੀਓ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਦੇਖੋ ਕਿ ਕਿਵੇਂ ਮਿਨੀਕਿਊਬ 'ਤੇ ਸਧਾਰਨ ਸਪਰਿੰਗ ਬੂਟ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਲਾਗੂ ਕਰਨਾ ਹੈ:

ਸਿੱਟਾ

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

ਸਰੋਤ: www.habr.com