ਓਪਨਸ਼ਿਫਟ 'ਤੇ ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ, ਭਾਗ 3: ਇੱਕ ਵਿਕਾਸ ਵਾਤਾਵਰਨ ਅਤੇ ਓਪਨਸ਼ਿਫਟ ਪਾਈਪਲਾਈਨਾਂ ਵਜੋਂ ਓਪਨਸ਼ਿਫਟ

ਇਸ ਬਲੌਗ 'ਤੇ ਸਾਰਿਆਂ ਨੂੰ ਹੈਲੋ! ਇਹ ਲੜੀ ਵਿੱਚ ਤੀਜੀ ਪੋਸਟ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਉਂਦੇ ਹਾਂ ਕਿ Red Hat OpenShift ਉੱਤੇ ਆਧੁਨਿਕ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ।

ਪਿਛਲੀਆਂ ਦੋ ਪੋਸਟਾਂ ਵਿੱਚ, ਅਸੀਂ ਇਹ ਕਵਰ ਕੀਤਾ ਹੈ ਕਿ ਆਧੁਨਿਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕੁਝ ਕਦਮਾਂ ਵਿੱਚ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ ਅਤੇ ਇੱਕ ਨਵੇਂ S2I ਚਿੱਤਰ ਨੂੰ ਇੱਕ ਪ੍ਰੀ-ਬਿਲਟ HTTP ਸਰਵਰ ਚਿੱਤਰ ਦੇ ਨਾਲ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ ਜਿਵੇਂ ਕਿ ਉਤਪਾਦਨ ਤੈਨਾਤੀ ਲਈ ਚੇਨਡ ਬਿਲਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ NGINX।

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

ਇੱਕ ਵਿਕਾਸ ਵਾਤਾਵਰਣ ਦੇ ਤੌਰ ਤੇ OpenShift

ਵਿਕਾਸ ਕਾਰਜ ਪ੍ਰਵਾਹ

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

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

ਸਥਾਨਕ ਉਦਾਹਰਨ

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

$ npm run start

ਫਿਰ ਟਰਮੀਨਲ ਵਿੰਡੋ ਵਿੱਚ ਅਸੀਂ ਕੁਝ ਅਜਿਹਾ ਵੇਖਾਂਗੇ:

ਅਤੇ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਡਿਫੌਲਟ ਬ੍ਰਾਉਜ਼ਰ ਵਿੱਚ ਖੁੱਲੇਗੀ:

ਹੁਣ, ਜੇਕਰ ਅਸੀਂ ਫਾਈਲ ਵਿੱਚ ਬਦਲਾਅ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਰਿਫ੍ਰੈਸ਼ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਠੀਕ ਹੈ, ਸਥਾਨਕ ਮੋਡ ਵਿੱਚ ਵਿਕਾਸ ਦੇ ਨਾਲ, ਸਭ ਕੁਝ ਸਪੱਸ਼ਟ ਹੈ, ਪਰ ਓਪਨਸ਼ਿਫਟ 'ਤੇ ਇਹ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ?

OpenShift 'ਤੇ ਵਿਕਾਸ ਸਰਵਰ

ਜੇਕਰ ਤੁਹਾਨੂੰ ਵਿੱਚ ਯਾਦ ਹੈ ਪਿਛਲੀ ਪੋਸਟ, ਅਸੀਂ S2I ਚਿੱਤਰ ਦੇ ਅਖੌਤੀ ਰਨ ਪੜਾਅ (ਰਨ ਪੜਾਅ) ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕੀਤਾ ਅਤੇ ਦੇਖਿਆ ਕਿ, ਮੂਲ ਰੂਪ ਵਿੱਚ, ਸਾਡੀ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਰਵ ਮੋਡੀਊਲ ਦੁਆਰਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

ਹਾਲਾਂਕਿ, ਜੇ ਤੁਸੀਂ ਇੱਕ ਡੂੰਘੀ ਨਜ਼ਰ ਮਾਰੋ ਸਕ੍ਰਿਪਟ ਚਲਾਓ ਉਸ ਉਦਾਹਰਨ ਤੋਂ, ਫਿਰ ਇਸ ਵਿੱਚ $NPM_RUN ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਆਪਣੀ ਕਮਾਂਡ ਚਲਾਉਣ ਲਈ ਸਹਾਇਕ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਨੋਡਸ਼ਿਫਟ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ:

$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app

ਨੋਟ: ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਆਮ ਵਿਚਾਰ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਸੰਖੇਪ ਕੀਤੀ ਗਈ ਹੈ।

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

ਜੇਕਰ ਤੁਸੀਂ ਚੱਲ ਰਹੇ ਪੌਡ ਦੇ ਲੌਗ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੋਵੇਗਾ:

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

ਰਿਮੋਟ ਅਤੇ ਸਥਾਨਕ ਕੋਡ ਦਾ ਸਮਕਾਲੀਕਰਨ

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

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

$ npx nodeshift watch

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

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

ਤਸਵੀਰ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਆਓ ਦਿਖਾਉਂਦੇ ਹਾਂ ਕਿ ਇਹ ਕਮਾਂਡਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਿਵੇਂ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ:

$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000

$ npx nodeshift watch --strictSSL=false

ਵਾਚ ਕਮਾਂਡ oc rsync ਕਮਾਂਡ ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਐਬਸਟਰੈਕਸ਼ਨ ਹੈ, ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇੱਥੇ.

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

ਓਪਨਸ਼ਿਫਟ ਪਾਈਪਲਾਈਨਾਂ

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

OpenShift ਪਾਈਪਲਾਈਨ ਕੀ ਹੈ

OpenShift Pipelines Tekton ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਈਪਲਾਈਨਾਂ ਲਈ ਇੱਕ ਕਲਾਉਡ-ਅਧਾਰਿਤ CI/CD ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਅਤੇ ਡਿਲਿਵਰੀ ਸਿਸਟਮ ਹੈ। ਟੇਕਟਨ ਇੱਕ ਓਪਨ ਸੋਰਸ, ਲਚਕਦਾਰ ਕੁਬਰਨੇਟਸ ਨੇਟਿਵ CI/CD ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਅੰਡਰਲਾਈੰਗ ਲੇਅਰ ਤੋਂ ਦੂਰ ਰਹਿ ਕੇ ਮਲਟੀਪਲ ਪਲੇਟਫਾਰਮਾਂ (ਕੁਬਰਨੇਟਸ, ਸਰਵਰ ਰਹਿਤ, ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ, ਆਦਿ) ਵਿੱਚ ਤੈਨਾਤੀ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦਾ ਹੈ।

ਇਸ ਲੇਖ ਨੂੰ ਸਮਝਣ ਲਈ ਪਾਈਪਲਾਈਨਾਂ ਦੇ ਕੁਝ ਗਿਆਨ ਦੀ ਲੋੜ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਪੜ੍ਹਨ ਦੀ ਜ਼ੋਰਦਾਰ ਸਲਾਹ ਦਿੰਦੇ ਹਾਂ ਅਧਿਕਾਰਤ ਪਾਠ ਪੁਸਤਕ.

ਕੰਮ ਕਰਨ ਦੇ ਮਾਹੌਲ ਨੂੰ ਸਥਾਪਤ ਕਰਨਾ

ਇਸ ਲੇਖ ਵਿਚਲੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਖੇਡਣ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਕੰਮ ਕਰਨ ਵਾਲਾ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਇੱਕ OpenShift 4 ਕਲੱਸਟਰ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਸੰਰਚਿਤ ਕਰੋ। ਸਾਡੀਆਂ ਉਦਾਹਰਣਾਂ ਇਸਦੇ ਲਈ ਕੋਡਰੇਡੀ ਕੰਟੇਨਰ (CRD) ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਜਿਸ ਲਈ ਇੰਸਟਾਲੇਸ਼ਨ ਨਿਰਦੇਸ਼ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ। ਇੱਥੇ.
2. ਕਲੱਸਟਰ ਦੇ ਤਿਆਰ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਇਸ 'ਤੇ ਪਾਈਪਲਾਈਨ ਓਪਰੇਟਰ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਡਰੋ ਨਾ, ਇਹ ਆਸਾਨ ਹੈ, ਇੰਸਟਾਲੇਸ਼ਨ ਨਿਰਦੇਸ਼ ਇੱਥੇ.
3. ਡਾ .ਨਲੋਡ Tekton CLI (tkn) ਇੱਥੇ.
4. ਇੱਕ ਐਪ ਬਣਾਉਣ ਲਈ create-react-app ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ ਚਲਾਓ ਜੋ ਫਿਰ ਤੈਨਾਤ ਕੀਤਾ ਜਾਵੇਗਾ (ਇਹ ਇੱਕ ਸਧਾਰਨ ਐਪ ਹੈ ਪ੍ਰਤੀਕਿਰਿਆ).
5. (ਵਿਕਲਪਿਕ) ਨਮੂਨਾ ਐਪ ਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ npm ਇੰਸਟੌਲ ਅਤੇ ਫਿਰ npm ਸਟਾਰਟ ਨਾਲ ਚਲਾਉਣ ਲਈ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਕਲੋਨ ਕਰੋ।

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

ਸ਼ੁਰੂ ਕਰਨਾ

ਸਾਡੀ ਉਦਾਹਰਨ ਲਈ ਪਹਿਲਾ ਕਦਮ ਓਪਨਸ਼ਿਫਟ ਕਲੱਸਟਰ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ ਹੈ। ਆਉ ਇਸ ਪ੍ਰੋਜੈਕਟ ਨੂੰ webapp-pipeline ਦਾ ਨਾਮ ਦੇਈਏ ਅਤੇ ਇਸਨੂੰ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਬਣਾਓ:

$ oc new-project webapp-pipeline

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

ਇਸ ਲਈ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ…

ਕਾਰਜ

ਆਉ ਅਸੀਂ ਕੁਝ ਕਾਰਜ (ਕਾਰਜ) ਬਣਾਈਏ, ਜੋ ਫਿਰ ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਪਾਈਪਲਾਈਨ ਦੇ ਅੰਦਰ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨਗੇ। ਪਹਿਲਾ ਕੰਮ, apply_manifests_task, ਉਹਨਾਂ Kubernetes ਸਰੋਤਾਂ (ਸੇਵਾ, ਤੈਨਾਤੀ, ਅਤੇ ਰੂਟ) ਦੇ YAML ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ ਜੋ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੇ k8s ਫੋਲਡਰ ਵਿੱਚ ਸਥਿਤ ਹਨ। ਦੂਜਾ ਕੰਮ - update_deployment_task - ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਦੁਆਰਾ ਬਣਾਏ ਗਏ ਚਿੱਤਰ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਤੈਨਾਤ ਚਿੱਤਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।

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

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml

ਫਿਰ, tkn CLI ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਜਾਂਚ ਕਰੋ ਕਿ ਕੰਮ ਬਣਾਏ ਗਏ ਹਨ:

$ tkn task ls

NAME                AGE
apply-manifests     1 minute ago
update-deployment   1 minute ago

ਨੋਟ: ਇਹ ਤੁਹਾਡੇ ਮੌਜੂਦਾ ਪ੍ਰੋਜੈਕਟ ਲਈ ਸਥਾਨਕ ਕਾਰਜ ਹਨ।

ਕਲੱਸਟਰ ਕਾਰਜ

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

$ tkn clustertask ls

NAME                       AGE
buildah                    1 day ago
buildah-v0-10-0            1 day ago
jib-maven                  1 day ago
kn                         1 day ago
maven                      1 day ago
openshift-client           1 day ago
openshift-client-v0-10-0   1 day ago
s2i                        1 day ago
s2i-go                     1 day ago
s2i-go-v0-10-0             1 day ago
s2i-java-11                1 day ago
s2i-java-11-v0-10-0        1 day ago
s2i-java-8                 1 day ago
s2i-java-8-v0-10-0         1 day ago
s2i-nodejs                 1 day ago
s2i-nodejs-v0-10-0         1 day ago
s2i-perl                   1 day ago
s2i-perl-v0-10-0           1 day ago
s2i-php                    1 day ago
s2i-php-v0-10-0            1 day ago
s2i-python-3               1 day ago
s2i-python-3-v0-10-0       1 day ago
s2i-ruby                   1 day ago
s2i-ruby-v0-10-0           1 day ago
s2i-v0-10-0                1 day ago

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

ਇੱਕ ਚਿੱਤਰ ਬਣਾਓ ਅਤੇ ਭੇਜੋ

ਪਹਿਲਾ ਕੰਮ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਅਸੀਂ ਦੁਹਰਾਵਾਂਗੇ ਜੋ ਅਸੀਂ ਲਿੰਕਡ ਅਸੈਂਬਲੀਆਂ ਬਾਰੇ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਕੀਤਾ ਸੀ। ਯਾਦ ਕਰੋ ਕਿ ਅਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ "ਬਿਲਡ" ਕਰਨ ਲਈ S2I ਚਿੱਤਰ (ubi8-s2i-web-app) ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਅਤੇ ਅੰਦਰੂਨੀ OpenShift ਰਜਿਸਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਇੱਕ ਚਿੱਤਰ ਨਾਲ ਸਮਾਪਤ ਹੋਈ। ਅਸੀਂ ਹੁਣ ਇਸ S2I ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਡੌਕਰਫਾਈਲ ਬਣਾਉਣ ਲਈ ਕਰਾਂਗੇ, ਅਤੇ ਫਿਰ ਅਸਲ ਵਿੱਚ ਓਪਨਸ਼ਿਫਟ ਦੀ ਅੰਦਰੂਨੀ ਰਜਿਸਟਰੀ ਵਿੱਚ ਨਤੀਜਾ ਚਿੱਤਰ ਬਣਾਉਣ ਅਤੇ ਧੱਕਣ ਲਈ ਬਿਲਡਾਹ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਇਹ ਬਿਲਕੁਲ ਓਪਨਸ਼ਿਫਟ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਨੋਡਸ਼ਿਫਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਹੋ।

ਅਸੀਂ ਇਹ ਸਭ ਕਿਵੇਂ ਜਾਣਦੇ ਹਾਂ, ਤੁਸੀਂ ਪੁੱਛਦੇ ਹੋ? ਤੋਂ ਅਧਿਕਾਰਤ Node.js ਦਾ ਅਧਿਕਾਰਤ ਸੰਸਕਰਣ, ਅਸੀਂ ਇਸਨੂੰ ਕਾਪੀ ਕੀਤਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਲਈ ਪੂਰਾ ਕੀਤਾ ਹੈ।

ਇਸ ਲਈ, ਹੁਣ ਅਸੀਂ s2i-web-app ਕਲੱਸਟਰ ਟਾਸਕ ਬਣਾਉਂਦੇ ਹਾਂ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml

ਅਸੀਂ ਇਸਦਾ ਵਿਸਥਾਰ ਵਿੱਚ ਵਿਸ਼ਲੇਸ਼ਣ ਨਹੀਂ ਕਰਾਂਗੇ, ਪਰ ਸਿਰਫ OUTPUT_DIR ਪੈਰਾਮੀਟਰ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ:

params:
      - name: OUTPUT_DIR
        description: The location of the build output directory
        default: build

ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਇਹ ਪੈਰਾਮੀਟਰ ਬਿਲਡ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਰੀਐਕਟ ਬਿਲਟ ਸਮੱਗਰੀ ਰੱਖਦਾ ਹੈ। ਹੋਰ ਫਰੇਮਵਰਕ ਵੱਖ-ਵੱਖ ਮਾਰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ ਐਂਬਰ ਵਿੱਚ ਇਹ ਦੂਰ ਹੈ। ਸਾਡੇ ਪਹਿਲੇ ਕਲੱਸਟਰ ਟਾਸਕ ਦਾ ਆਉਟਪੁੱਟ ਇੱਕ ਚਿੱਤਰ ਹੋਵੇਗਾ ਜਿਸ ਵਿੱਚ HTML, JavaScript, ਅਤੇ CSS ਅਸੀਂ ਇਕੱਠੇ ਕੀਤੇ ਹਨ।

ਅਸੀਂ NGINX ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਚਿੱਤਰ ਬਣਾਉਂਦੇ ਹਾਂ

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

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ - ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਥੋੜਾ ਜਿਹਾ - ਇੱਕ webapp-ਬਿਲਡ-ਰਨਟਾਈਮ ਕਲੱਸਟਰ ਟਾਸਕ ਬਣਾਵਾਂਗੇ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml

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

ਅਤੇ ਫਿਰ ਅਸੀਂ ਸੁੰਦਰਤਾ ਨਾਲ ਅਗਲੇ ਬਿੰਦੂ ਵੱਲ ਵਧਦੇ ਹਾਂ ...

ਸਰੋਤ

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

# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: web-application-repo
spec:
  type: git
  params:
    - name: url
      value: https://github.com/nodeshift-starters/react-pipeline-example
    - name: revision
      value: master

ਇੱਥੇ PipelineResource git ਕਿਸਮ ਦਾ ਹੈ। ਪੈਰਾਮ ਸੈਕਸ਼ਨ ਵਿੱਚ url ਕੁੰਜੀ ਇੱਕ ਖਾਸ ਰਿਪੋਜ਼ਟਰੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੀ ਹੈ ਅਤੇ ਮਾਸਟਰ ਬ੍ਰਾਂਚ ਨੂੰ ਸੈੱਟ ਕਰਦੀ ਹੈ (ਇਹ ਵਿਕਲਪਿਕ ਹੈ, ਪਰ ਅਸੀਂ ਇਸਨੂੰ ਸੰਪੂਰਨਤਾ ਲਈ ਲਿਖਦੇ ਹਾਂ)।

ਹੁਣ ਸਾਨੂੰ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਜਿੱਥੇ s2i-web-app ਟਾਸਕ ਦੇ ਨਤੀਜੇ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਜਾਣਗੇ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕੀਤਾ ਗਿਆ ਹੈ:

# This resource is the result of running "npm run build",  the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: built-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest

ਇੱਥੇ, PipelineResource ਚਿੱਤਰ ਦੀ ਕਿਸਮ ਦਾ ਹੈ, ਅਤੇ url ਪੈਰਾਮੀਟਰ ਦਾ ਮੁੱਲ ਅੰਦਰੂਨੀ OpenShift ਚਿੱਤਰ ਰਜਿਸਟਰੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ webapp-ਪਾਈਪਲਾਈਨ ਨੇਮਸਪੇਸ ਵਿੱਚ। ਇਸ ਸੈਟਿੰਗ ਨੂੰ ਬਦਲਣਾ ਯਾਦ ਰੱਖੋ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਖਰੀ ਨੇਮਸਪੇਸ ਵਰਤ ਰਹੇ ਹੋ।

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਸਾਨੂੰ ਲੋੜੀਂਦਾ ਆਖਰੀ ਸਰੋਤ ਵੀ ਕਿਸਮ ਦੀ ਚਿੱਤਰ ਦਾ ਹੋਵੇਗਾ, ਅਤੇ ਇਹ ਅੰਤਮ NGINX ਚਿੱਤਰ ਹੋਵੇਗਾ, ਜੋ ਫਿਰ ਤੈਨਾਤੀ ਦੌਰਾਨ ਵਰਤਿਆ ਜਾਵੇਗਾ:

# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: runtime-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest

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

ਇਹਨਾਂ ਸਾਰੇ ਸਰੋਤਾਂ ਨੂੰ ਇੱਕੋ ਵਾਰ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ create ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml

ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਰੋਤ ਬਣਾਏ ਗਏ ਹਨ, ਤੁਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹੋ:

$ tkn resource ls

ਪਾਈਪਲਾਈਨ

ਹੁਣ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਸਾਰੇ ਲੋੜੀਂਦੇ ਹਿੱਸੇ ਹਨ, ਅਸੀਂ ਉਹਨਾਂ ਤੋਂ ਇੱਕ ਪਾਈਪਲਾਈਨ ਨੂੰ ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਨਾਲ ਬਣਾ ਕੇ ਇਕੱਠੇ ਕਰਾਂਗੇ:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml

ਪਰ ਇਸ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇਹਨਾਂ ਭਾਗਾਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ. ਪਹਿਲਾ ਨਾਮ ਹੈ:

apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
  name: build-and-deploy-react

ਫਿਰ, ਵਿਸ਼ੇਸ਼ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਉਹਨਾਂ ਸਰੋਤਾਂ ਦਾ ਇੱਕ ਸੰਕੇਤ ਦੇਖਦੇ ਹਾਂ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਬਣਾਏ ਸਨ:

spec:
  resources:
    - name: web-application-repo
      type: git
    - name: built-web-application-image
      type: image
    - name: runtime-web-application-image
      type: image

ਅਸੀਂ ਫਿਰ ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਨੂੰ ਚਲਾਉਣ ਲਈ ਕਾਰਜ ਬਣਾਉਂਦੇ ਹਾਂ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਨੂੰ s2i-web-app ਕਾਰਜ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈ:

tasks:
    - name: build-web-application
      taskRef:
        name: s2i-web-app
        kind: ClusterTask

ਇਹ ਕੰਮ ਇਨਪੁਟ (ਗੀਰ ਸਰੋਤ) ਅਤੇ ਆਉਟਪੁੱਟ (ਬਿਲਟ-ਵੈੱਬ-ਐਪਲੀਕੇਸ਼ਨ-ਚਿੱਤਰ ਸਰੋਤ) ਪੈਰਾਮੀਟਰ ਲੈਂਦਾ ਹੈ। ਅਸੀਂ ਇਸਦੇ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮਾਪਦੰਡ ਵੀ ਪਾਸ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਇਹ TLS ਦੀ ਪੁਸ਼ਟੀ ਨਾ ਕਰੇ ਕਿਉਂਕਿ ਅਸੀਂ ਸਵੈ-ਦਸਤਖਤ ਸਰਟੀਫਿਕੇਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ:

resources:
        inputs:
          - name: source
            resource: web-application-repo
        outputs:
          - name: image
            resource: built-web-application-image
      params:
        - name: TLSVERIFY
          value: "false"

ਅਗਲਾ ਕੰਮ ਲਗਭਗ ਇੱਕੋ ਜਿਹਾ ਹੈ, ਸਿਰਫ ਵੈਬਐਪ-ਬਿਲਡ-ਰਨਟਾਈਮ ਕਲੱਸਟਰ ਟਾਸਕ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈ ਨੂੰ ਇੱਥੇ ਬੁਲਾਇਆ ਗਿਆ ਹੈ:

name: build-runtime-image
    taskRef:
      name: webapp-build-runtime
      kind: ClusterTask

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

resources:
        inputs:
          - name: image
            resource: built-web-application-image
        outputs:
          - name: image
            resource: runtime-web-application-image
        params:
        - name: TLSVERIFY
          value: "false"
      runAfter:
        - build-web-application

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

ਪਾਈਪਲਾਈਨ ਚਲਾਈ ਜਾ ਰਹੀ ਹੈ

ਇਸ ਲਈ, ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਦੇ ਸਾਰੇ ਹਿੱਸੇ ਬਣਾਏ ਗਏ ਹਨ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਸ਼ੁਰੂ ਕਰਾਂਗੇ:

$ tkn pipeline start build-and-deploy-react

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

? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr

ਹੁਣ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਪਾਈਪਲਾਈਨ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ:

$ tkn pipeline logs -f

ਪਾਈਪਲਾਈਨ ਸ਼ੁਰੂ ਹੋਣ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਤੈਨਾਤ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਪ੍ਰਕਾਸ਼ਿਤ ਰੂਟ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰੋ:

$ oc get route react-pipeline-example --template='http://{{.spec.host}}'

ਵਧੇਰੇ ਦਿੱਖ ਲਈ, ਤੁਸੀਂ ਭਾਗ ਵਿੱਚ ਵੈੱਬ ਕੰਸੋਲ ਦੇ ਡਿਵੈਲਪਰ ਮੋਡ ਵਿੱਚ ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਦੇਖ ਸਕਦੇ ਹੋ ਪਾਈਪਲਾਈਨਜ਼ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। 1.

ਚਿੱਤਰ.1. ਚੱਲ ਰਹੀਆਂ ਪਾਈਪਲਾਈਨਾਂ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ।

ਚੱਲ ਰਹੀ ਪਾਈਪਲਾਈਨ 'ਤੇ ਕਲਿੱਕ ਕਰਨਾ ਵਾਧੂ ਵੇਰਵੇ ਦਿਖਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ 2 ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

ਚੌਲ. 2. ਕਨਵੇਅਰ ਬਾਰੇ ਵਾਧੂ ਜਾਣਕਾਰੀ।

ਹੋਰ ਵੇਰਵਿਆਂ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ ਟੌਪਲੋਜੀ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ. 3.

ਚਿੱਤਰ 3. ਰਨਿੰਗ ਪੌਡ।

ਆਈਕਨ ਦੇ ਉੱਪਰ ਸੱਜੇ ਕੋਨੇ ਵਿੱਚ ਸਰਕਲ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਨਾਲ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਖੁੱਲ੍ਹਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ 4 ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

ਚੌਲ. 4. ਇੱਕ ਚੱਲ ਰਹੀ ਪ੍ਰਤੀਕਿਰਿਆ ਐਪਲੀਕੇਸ਼ਨ।

ਸਿੱਟਾ

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

ਵਧੀਕ ਸਰੋਤ

• ਮੁਫਤ ਈ-ਕਿਤਾਬ "ਓਪਨ ਸ਼ਿਫਟ ਵਿਕਾਸ: ਬੇਸਬਰੀ ਲਈ ਇੱਕ ਗਾਈਡ"
• Red Hat OpenShift ਐਪਲੀਕੇਸ਼ਨ ਰਨਟਾਈਮ ਅਤੇ Istio ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਟੇਨਰਾਈਜ਼ਡ Node.js ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਬਣਾਉਣਾ
• Chrome DevTools ਨਾਲ OpenShift 'ਤੇ Node.js ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ
• ਸਕ੍ਰੈਚ ਤੋਂ ਓਪਨਸ਼ਿਫਟ 'ਤੇ ਐਕਸਪ੍ਰੈਸ ਨੂੰ ਮਾਸਟਰ ਕਰਨ ਲਈ ਤਿੰਨ ਕਮਾਂਡਾਂ
• Red Hat OpenShift ਐਪਲੀਕੇਸ਼ਨ ਰਨਟਾਈਮ ਦੇ ਹਿੱਸੇ ਵਜੋਂ Node.js ਦੇ ਜਨਤਕ ਸੰਸਕਰਣ ਦੀ ਘੋਸ਼ਣਾ
• Prometheus ਨਾਲ OpenShift 'ਤੇ Node.js ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ
• 'ਤੇ ਹੋਰ ਲੇਖ OpenShift ਅਤੇ Kubernetes Red Hat ਵੈੱਬਸਾਈਟ 'ਤੇ

ਆਗਾਮੀ ਵੈਬਿਨਾਰਾਂ ਦੀਆਂ ਘੋਸ਼ਣਾਵਾਂ

ਅਸੀਂ Red Hat OpenShift ਕੰਟੇਨਰ ਪਲੇਟਫਾਰਮ ਅਤੇ ਕੁਬਰਨੇਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਮੂਲ ਅਨੁਭਵ ਬਾਰੇ ਸ਼ੁੱਕਰਵਾਰ ਵੈਬਿਨਾਰਾਂ ਦੀ ਇੱਕ ਲੜੀ ਸ਼ੁਰੂ ਕਰ ਰਹੇ ਹਾਂ:

• ਅਗਸਤ 28, ਵੈਬਿਨਾਰ ਸਮਰਾਟ "ਓਪਰੇਟਰ": ਓਪਨਸ਼ਿਫਟ ਅਤੇ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਆਪਰੇਟਰ
• ਸਤੰਬਰ 11, DeploymentConfig ਬਨਾਮ ਡਿਪਲਾਇਮੈਂਟ - ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਅਤੇ ਤੈਨਾਤ ਕਰਨ ਲਈ ਓਪਨਸ਼ਿਫਟ-ਵਿਸ਼ੇਸ਼ ਜਾਦੂ
• 25 ਸਤੰਬਰ, Red Hat OpenShift ਅਤੇ ਮਸ਼ੀਨ API
• ਅਕਤੂਬਰ 9, ਕੰਮ ਦੇ ਬੋਝ ਵਿੱਚ ਅਚਾਨਕ ਵਾਧੇ ਨਾਲ ਕਿਵੇਂ ਨਜਿੱਠਣਾ ਹੈ
• 23 ਅਕਤੂਬਰ, ਰੈੱਡ ਹੈਟ ਓਪਨਸ਼ਿਫਟ ਕੰਟੇਨਰ ਪਲੇਟਫਾਰਮ 'ਤੇ ਏਮਬੇਡਡ ਜੇਨਕਿਨਸ, ਪਾਈਪਲਾਈਨ-ਬਿਲਡਸ, ਟੇਕਟਨ

ਸਰੋਤ: www.habr.com