ਮੈਨੂੰ ਮਾਫ਼ ਕਰਨਾ, OpenShift, ਅਸੀਂ ਤੁਹਾਡੀ ਕਾਫ਼ੀ ਕਦਰ ਨਹੀਂ ਕੀਤੀ ਅਤੇ ਤੁਹਾਨੂੰ ਸਮਝ ਲਿਆ

ਇਹ ਪੋਸਟ ਇਸ ਲਈ ਲਿਖੀ ਗਈ ਸੀ ਕਿਉਂਕਿ ਸਾਡੇ ਕਰਮਚਾਰੀਆਂ ਨੇ Kubernetes 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਮੈਂਟ ਅਤੇ OpenShift 'ਤੇ ਅਜਿਹੇ ਵਿਕਾਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਗਾਹਕਾਂ ਨਾਲ ਕਾਫੀ ਗੱਲਬਾਤ ਕੀਤੀ ਸੀ।

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

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

ਫਿਰ ਅਸੀਂ ਸਭ ਤੋਂ ਸਰਲ "ਹੈਲੋ ਵਰਲਡ" ਲੈਣ ਦੀ ਯੋਜਨਾ ਬਣਾਈ ਹੈ ਅਤੇ ਇਹ ਦਿਖਾਉਣ ਲਈ ਇਸਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਕਿ ਆਮ ਕੀ ਹੈ ਅਤੇ KUC ਅਤੇ Red Hat ਓਪਨਸ਼ਿਫਟ ਕੰਟੇਨਰ ਪਲੇਟਫਾਰਮ (ਇਸ ਤੋਂ ਬਾਅਦ, OCP ਜਾਂ ਬਸ ਓਪਨਸ਼ਿਫਟ) ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ।

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

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

ਕਲੱਸਟਰ

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

KUK-e 'ਤੇ ਅਸੈਂਬਲੀ

ਤਾਂ ਚਲੋ ਚੱਲੀਏ।

ਕਦਮ 1 - ਸਾਡੇ ਕੰਟੇਨਰ ਚਿੱਤਰ ਨੂੰ ਬਣਾਉਣਾ

ਆਉ ਮਿਨੀਕਿਊਬ ਵਿੱਚ ਸਾਡੀ "ਹੈਲੋ ਵਰਲਡ" ਨੂੰ ਤੈਨਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੀਏ। ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜ ਹੋਵੇਗੀ:

1. 1. ਡੌਕਰ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ।
2. 2. Git ਇੰਸਟਾਲ ਹੈ।
3. 3. ਮਾਵੇਨ ਸਥਾਪਿਤ ਕੀਤਾ (ਅਸਲ ਵਿੱਚ, ਇਹ ਪ੍ਰੋਜੈਕਟ mvnw ਬਾਈਨਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਸ ਤੋਂ ਬਿਨਾਂ ਕਰ ਸਕੋ)।
4. 4. ਅਸਲ ਵਿੱਚ, ਸਰੋਤ ਖੁਦ, i.e. ਰਿਪੋਜ਼ਟਰੀ ਕਲੋਨ github.com/gcolman/quarkus-hello-world.git

ਪਹਿਲਾ ਕਦਮ ਇੱਕ ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕਦੇ Quarkus.io ਨਾਲ ਕੰਮ ਨਹੀਂ ਕੀਤਾ ਹੈ ਤਾਂ ਘਬਰਾਓ ਨਾ - ਇਹ ਆਸਾਨ ਹੈ। ਤੁਸੀਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਭਾਗਾਂ ਨੂੰ ਚੁਣਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ (RestEasy, Hibernate, Amazon SQS, Camel, etc.), ਅਤੇ ਫਿਰ ਕੁਆਰਕਸ ਖੁਦ, ਤੁਹਾਡੀ ਕਿਸੇ ਵੀ ਭਾਗੀਦਾਰੀ ਤੋਂ ਬਿਨਾਂ, ਮਾਵੇਨ ਆਰਕੀਟਾਈਪ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦਾ ਹੈ ਅਤੇ ਹਰ ਚੀਜ਼ ਨੂੰ ਗਿਥਬ 'ਤੇ ਰੱਖਦਾ ਹੈ। ਭਾਵ, ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਮਾਊਸ ਦੀ ਇੱਕ ਕਲਿੱਕ ਅਤੇ ਤੁਸੀਂ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਅਸੀਂ ਕੁਆਰਕਸ ਨੂੰ ਪਿਆਰ ਕਰਦੇ ਹਾਂ।

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

./mvnw quarkus:add-extension -Dextensions=”container-image-docker”

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

./mvnw -X clean package -Dquarkus.container-image.build=true

ਬੱਸ, ਹੁਣ ਤੁਸੀਂ ਡੌਕਰ ਰਨ ਕਮਾਂਡ ਨਾਲ ਕੰਟੇਨਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ, ਸਾਡੀ ਸੇਵਾ ਨੂੰ ਪੋਰਟ 8080 'ਤੇ ਮੈਪ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕੇ।

docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world

ਕੰਟੇਨਰ ਉਦਾਹਰਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਜੋ ਕੁਝ ਰਹਿੰਦਾ ਹੈ ਉਹ ਕਰਲ ਕਮਾਂਡ ਨਾਲ ਜਾਂਚ ਕਰਨਾ ਹੈ ਕਿ ਸਾਡੀ ਸੇਵਾ ਚੱਲ ਰਹੀ ਹੈ:

ਇਸ ਲਈ ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਅਸਲ ਵਿੱਚ ਆਸਾਨ ਅਤੇ ਸਧਾਰਨ ਸੀ.

ਕਦਮ 2 - ਸਾਡੇ ਕੰਟੇਨਰ ਨੂੰ ਕੰਟੇਨਰ ਚਿੱਤਰ ਭੰਡਾਰ ਵਿੱਚ ਭੇਜੋ

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

ਇਹ ਵੀ ਬਹੁਤ ਸਧਾਰਨ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਡੌਕਰਹਬ ਖਾਤੇ ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਲਈ, ਅਸੀਂ ਡੌਕਰਹਬ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਉੱਥੇ ਆਪਣੀ ਤਸਵੀਰ ਭੇਜਦੇ ਹਾਂ.

ਕਦਮ 3 - ਕੁਬਰਨੇਟਸ ਲਾਂਚ ਕਰੋ

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

ਪਹਿਲਾਂ, ਆਓ ਮਿਨੀਕੂਬ ਕਲੱਸਟਰ ਨੂੰ ਲਾਂਚ ਕਰੀਏ:

minikube start

ਕਦਮ 4 - ਸਾਡੇ ਕੰਟੇਨਰ ਚਿੱਤਰ ਨੂੰ ਤੈਨਾਤ ਕਰੋ

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

kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT

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

ਕਦਮ 5 – ਸਾਡੀ ਸੇਵਾ ਤੱਕ ਪਹੁੰਚ ਖੋਲ੍ਹੋ

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

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

kubectl expose deployment hello-quarkus — type=NodePort — port=8080

ਆਉ ਐਕਸਪੋਜ਼ ਕਮਾਂਡ ਦੇ "-type" ਵਿਕਲਪ ਨੂੰ ਵੇਖਣ ਲਈ ਇੱਕ ਪਲ ਕੱਢੀਏ।

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

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

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

ਕਦਮ 6 - ਇੱਕ ਲੋਡ ਬੈਲੇਂਸਰ ਸਥਾਪਿਤ ਕਰੋ

minikube ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਪਲੇਟਫਾਰਮ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਬਾਹਰੀ ਤੌਰ 'ਤੇ ਪਹੁੰਚਯੋਗ ਭਾਗਾਂ ਨੂੰ ਬਣਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਪ੍ਰਵੇਸ਼ ਕੰਟਰੋਲਰ। Minikube Nginx ਇਨਗਰੇਸ ਕੰਟਰੋਲਰ ਦੇ ਨਾਲ ਬੰਡਲ ਆਉਂਦਾ ਹੈ, ਅਤੇ ਸਾਨੂੰ ਬੱਸ ਇਸਨੂੰ ਸਮਰੱਥ ਕਰਨਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਹੈ।

minikube addons enable ingress

ਹੁਣ ਅਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਇੱਕ Nginx ਇੰਗਰੈਸ ਕੰਟਰੋਲਰ ਬਣਾਵਾਂਗੇ, ਜੋ ਸਾਡੇ ਮਿਨੀਕਿਊਬ ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ ਕੰਮ ਕਰੇਗਾ:

ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m

ਕਦਮ 7 - ਪ੍ਰਵੇਸ਼ ਸਥਾਪਤ ਕਰਨਾ

ਹੁਣ ਸਾਨੂੰ Nginx ingress ਕੰਟਰੋਲਰ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਇਹ ਹੈਲੋ-ਕੁਆਰਕਸ ਬੇਨਤੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰੇ।

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਸਾਨੂੰ ਇਸ ਸੰਰਚਨਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ.

kubectl apply -f ingress.yml

ਕਿਉਂਕਿ ਅਸੀਂ ਇਹ ਸਭ ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਕਰ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਆਪਣੇ ਨੋਡ ਦੇ IP ਐਡਰੈੱਸ ਨੂੰ /etc/ ਮੇਜ਼ਬਾਨ ਫਾਈਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ ਤਾਂ ਕਿ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸਾਡੇ ਮਿਨੀਕਿਊਬ ਨੂੰ NGINX ਲੋਡ ਬੈਲੈਂਸਰ ਤੱਕ ਪਹੁੰਚਾਇਆ ਜਾ ਸਕੇ।

192.168.99.100 hello-quarkus.info

ਬੱਸ, ਹੁਣ ਸਾਡੀ ਮਿਨੀਕਿਊਬ ਸੇਵਾ Nginx ਪ੍ਰਵੇਸ਼ ਕੰਟਰੋਲਰ ਦੁਆਰਾ ਬਾਹਰੀ ਤੌਰ 'ਤੇ ਪਹੁੰਚਯੋਗ ਹੈ।

ਖੈਰ, ਇਹ ਆਸਾਨ ਸੀ, ਠੀਕ ਹੈ? ਜਾਂ ਇੰਨਾ ਜ਼ਿਆਦਾ ਨਹੀਂ?

OpenShift (ਕੋਡ ਤਿਆਰ ਕੰਟੇਨਰ) 'ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ

ਹੁਣ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਸਭ Red Hat OpenShift ਕੰਟੇਨਰ ਪਲੇਟਫਾਰਮ (OCP) 'ਤੇ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਮਿਨੀਕਿਊਬ ਦੇ ਨਾਲ, ਅਸੀਂ ਕੋਡ ਰੈਡੀ ਕੰਟੇਨਰ (CRC) ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ-ਨੋਡ ਓਪਨਸ਼ਿਫਟ ਕਲੱਸਟਰ ਡਿਜ਼ਾਈਨ ਚੁਣਦੇ ਹਾਂ। ਪਹਿਲਾਂ, ਇਸਨੂੰ ਮਿਨੀਸ਼ਿਫਟ ਕਿਹਾ ਜਾਂਦਾ ਸੀ ਅਤੇ ਇਹ ਓਪਨਸ਼ਿਫਟ ਓਰੀਜਿਨ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਅਧਾਰਤ ਸੀ, ਪਰ ਹੁਣ ਇਹ CRC ਹੈ ਅਤੇ Red Hat ਦੇ ਓਪਨਸ਼ਿਫਟ ਕੰਟੇਨਰ ਪਲੇਟਫਾਰਮ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ।

ਇੱਥੇ ਅਸੀਂ, ਮਾਫ਼ ਕਰਨਾ, ਮਦਦ ਨਹੀਂ ਕਰ ਸਕਦੇ ਪਰ ਕਹਿ ਸਕਦੇ ਹਾਂ: "ਓਪਨਸ਼ਿਫਟ ਸ਼ਾਨਦਾਰ ਹੈ!"

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

ਚਲੋ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚੋਂ ਲੰਘੀਏ ਅਤੇ ਵੇਖੀਏ ਕਿ ਸਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

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

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

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

ਕਦਮ 1 - ਆਪਣਾ ਓਪਨਸ਼ਿਫਟ ਕਲੱਸਟਰ ਲਾਂਚ ਕਰੋ

ਅਸੀਂ Red Hat ਤੋਂ ਕੋਡ ਰੈਡੀ ਕੰਟੇਨਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜੋ ਕਿ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਉਹੀ ਮਿਨੀਕਿਊਬ ਹੈ, ਪਰ ਸਿਰਫ਼ ਇੱਕ ਪੂਰੇ ਸਿੰਗਲ-ਨੋਡ ਓਪਨਸ਼ਿਫਟ ਕਲੱਸਟਰ ਨਾਲ।

crc start

ਕਦਮ 2 - ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਓਪਨਸ਼ਿਫਟ ਕਲੱਸਟਰ ਵਿੱਚ ਬਣਾਓ ਅਤੇ ਲਾਗੂ ਕਰੋ

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

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

ਅਸੀਂ ਓਪਨਸ਼ਿਫਟ ਦੀ ਸਰੋਤ 2 ਚਿੱਤਰ (S2I) ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਸਾਡੇ ਸਰੋਤ (ਕੋਡ ਜਾਂ ਬਾਈਨਰੀਜ਼) ਨੂੰ ਲੈਣ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਕੰਟੇਨਰਾਈਜ਼ਡ ਚਿੱਤਰ ਵਿੱਚ ਬਦਲਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ ਜੋ ਇੱਕ OpenShift ਕਲੱਸਟਰ 'ਤੇ ਚੱਲਦਾ ਹੈ।

ਅਜਿਹਾ ਕਰਨ ਲਈ ਸਾਨੂੰ ਦੋ ਚੀਜ਼ਾਂ ਦੀ ਲੋੜ ਹੈ:

• ਸਾਡਾ ਸਰੋਤ ਕੋਡ git ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਹੈ
• ਬਿਲਡਰ ਚਿੱਤਰ ਜਿਸ ਦੇ ਆਧਾਰ 'ਤੇ ਨਿਰਮਾਣ ਕੀਤਾ ਜਾਵੇਗਾ।

Red Hat ਅਤੇ ਕਮਿਊਨਿਟੀ ਪੱਧਰ 'ਤੇ ਅਜਿਹੇ ਬਹੁਤ ਸਾਰੇ ਚਿੱਤਰ ਹਨ, ਅਤੇ ਅਸੀਂ ਓਪਨਜੇਡੀਕੇ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਮੈਂ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾ ਰਿਹਾ ਹਾਂ।

ਤੁਸੀਂ ਓਪਨਸ਼ਿਫਟ ਡਿਵੈਲਪਰ ਗ੍ਰਾਫਿਕਲ ਕੰਸੋਲ ਅਤੇ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ S2I ਬਿਲਡ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ। ਅਸੀਂ ਨਵੀਂ-ਐਪ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਇਹ ਦੱਸਦੇ ਹੋਏ ਕਿ ਬਿਲਡਰ ਚਿੱਤਰ ਅਤੇ ਸਾਡਾ ਸਰੋਤ ਕੋਡ ਕਿੱਥੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ।

oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git

ਬੱਸ, ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਈ ਗਈ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਵਿੱਚ, S2I ਪ੍ਰਕਿਰਿਆ ਨੇ ਹੇਠ ਲਿਖੀਆਂ ਗੱਲਾਂ ਕੀਤੀਆਂ:

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

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

ਜੇਕਰ ਤੁਸੀਂ ਕੰਸੋਲ ਵਿੱਚ S2I ਦੇ ਲਾਂਚ ਦੀ ਦ੍ਰਿਸ਼ਟੀਗਤ ਤੌਰ 'ਤੇ ਨਿਗਰਾਨੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਬਿਲਡ ਪੂਰਾ ਹੋਣ 'ਤੇ ਬਿਲਡ ਪੌਡ ਕਿਵੇਂ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

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

ਬੱਸ, ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਪੂਰੀ ਹੋ ਗਈ ਹੈ। ਹੁਣ ਇਹ ਯਕੀਨੀ ਕਰੀਏ ਕਿ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਪੌਡ ਅਤੇ ਸੇਵਾਵਾਂ ਕਲੱਸਟਰ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਹਨ।

oc get service

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

ਕਦਮ 3 - ਬਾਹਰੋਂ ਪਹੁੰਚ ਲਈ ਸੇਵਾ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰੋ

ਜਿਵੇਂ ਕਿ KUC ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਓਪਨਸ਼ਿਫਟ ਪਲੇਟਫਾਰਮ 'ਤੇ ਸਾਡੇ "ਹੈਲੋ ਵਰਲਡ" ਨੂੰ ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ ਸੇਵਾ ਲਈ ਬਾਹਰੀ ਟ੍ਰੈਫਿਕ ਨੂੰ ਨਿਰਦੇਸ਼ਤ ਕਰਨ ਲਈ ਇੱਕ ਰਾਊਟਰ ਦੀ ਵੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। OpenShift ਇਸਨੂੰ ਬਹੁਤ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ, HAProxy ਰੂਟਿੰਗ ਕੰਪੋਨੈਂਟ ਮੂਲ ਰੂਪ ਵਿੱਚ ਕਲੱਸਟਰ ਵਿੱਚ ਸਥਾਪਤ ਹੁੰਦਾ ਹੈ (ਇਸ ਨੂੰ ਉਸੇ NGINX ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ)। ਦੂਸਰਾ, ਰੂਟਸ ਨਾਮਕ ਵਿਸ਼ੇਸ਼ ਅਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਅਨੁਕੂਲਿਤ ਸਰੋਤ ਹਨ ਅਤੇ ਉਹ ਚੰਗੇ ਪੁਰਾਣੇ ਕੁਬਰਨੇਟਸ (ਅਸਲ ਵਿੱਚ, ਓਪਨਸ਼ਿਫਟ ਦੇ ਰੂਟਾਂ ਨੇ ਇੰਗਰੈਸ ਆਬਜੈਕਟਸ ਦੇ ਡਿਜ਼ਾਈਨ ਨੂੰ ਬਹੁਤ ਪ੍ਰਭਾਵਿਤ ਕੀਤਾ, ਜੋ ਹੁਣ ਓਪਨਸ਼ਿਫਟ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ), ਪਰ ਸਾਡੇ "ਹੈਲੋ ਵਰਲਡ" ਲਈ। , ਅਤੇ ਲਗਭਗ ਸਾਰੇ ਹੋਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਮਿਆਰੀ ਰੂਟ ਸਾਡੇ ਲਈ ਵਾਧੂ ਸੰਰਚਨਾ ਤੋਂ ਬਿਨਾਂ ਕਾਫੀ ਹੈ।

"ਹੈਲੋ ਵਰਲਡ" ਲਈ ਇੱਕ ਰੂਟੇਬਲ FQDN ਬਣਾਉਣ ਲਈ (ਹਾਂ, ਸੇਵਾ ਦੇ ਨਾਮਾਂ ਦੁਆਰਾ ਰੂਟਿੰਗ ਲਈ ਓਪਨਸ਼ਿਫਟ ਦਾ ਆਪਣਾ DNS ਹੈ), ਅਸੀਂ ਬਸ ਸਾਡੀ ਸੇਵਾ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਾਂਗੇ:

oc expose service quarkus-hello-world

ਜੇ ਤੁਸੀਂ ਨਵੇਂ ਬਣੇ ਰੂਟ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉੱਥੇ FQDN ਅਤੇ ਹੋਰ ਰੂਟਿੰਗ ਜਾਣਕਾਰੀ ਲੱਭ ਸਕਦੇ ਹੋ:

oc get route

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਸਾਡੀ ਸੇਵਾ ਤੱਕ ਪਹੁੰਚ ਕਰਦੇ ਹਾਂ:

ਪਰ ਹੁਣ ਇਹ ਅਸਲ ਵਿੱਚ ਆਸਾਨ ਸੀ!

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

ਅਸੀਂ ਆਸ ਕਰਦੇ ਹਾਂ ਕਿ ਇਹ ਲੇਖ ਤੁਹਾਡੇ ਲਈ ਦਿਲਚਸਪ ਅਤੇ ਲਾਭਦਾਇਕ ਸੀ. ਤੁਸੀਂ ਪੋਰਟਲ 'ਤੇ OpenShift ਪਲੇਟਫਾਰਮ 'ਤੇ ਵਿਕਾਸ ਲਈ ਲਾਭਦਾਇਕ ਵਾਧੂ ਸਰੋਤ, ਸਮੱਗਰੀ ਅਤੇ ਹੋਰ ਚੀਜ਼ਾਂ ਲੱਭ ਸਕਦੇ ਹੋ Red Hat ਡਿਵੈਲਪਰ.

ਸਰੋਤ: www.habr.com