OpenShift 'ਤੇ ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨ, ਭਾਗ 2: ਚੇਨਡ ਬਿਲਡਸ

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

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

ਸਾਫ਼ ਬਿਲਡਰ ਚਿੱਤਰ

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਭਾਗ XNUMX ਵਿੱਚ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ, ਜ਼ਿਆਦਾਤਰ ਆਧੁਨਿਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਅਖੌਤੀ ਬਿਲਡ ਪੜਾਅ ਹੁੰਦਾ ਹੈ, ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਕੋਡ ਟ੍ਰਾਂਸਪੀਲੇਸ਼ਨ, ਮਲਟੀਪਲ ਫਾਈਲ ਕਨਕੇਟੇਨੇਸ਼ਨ, ਅਤੇ ਮਿਨੀਫਿਕੇਸ਼ਨ ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਦਾ ਹੈ। ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ ਫਾਈਲਾਂ - ਅਤੇ ਇਹ ਸਥਿਰ HTML, JavaScript ਅਤੇ CSS - ਆਉਟਪੁੱਟ ਫੋਲਡਰ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਫੋਲਡਰ ਦਾ ਟਿਕਾਣਾ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਬਿਲਡ ਟੂਲ ਵਰਤੇ ਜਾ ਰਹੇ ਹਨ, ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਲਈ ਇਹ ./build ਫੋਲਡਰ ਹੋਵੇਗਾ (ਅਸੀਂ ਹੇਠਾਂ ਹੋਰ ਵੇਰਵੇ ਨਾਲ ਇਸ 'ਤੇ ਵਾਪਸ ਆਵਾਂਗੇ)।

ਸਰੋਤ-ਤੋਂ-ਚਿੱਤਰ (S2I)

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

ਅਸੈਂਬਲੀ ਪੜਾਅ

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

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

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਕਿਹਾ ਹੈ, ਮੁਕੰਮਲ, ਪਹਿਲਾਂ ਤੋਂ ਬਣਾਈ ਗਈ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਸਥਿਤੀ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਹੜੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, React ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਇਹ ./build ਫੋਲਡਰ ਹੋਵੇਗਾ, ਅਤੇ Angular ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਇਹ project_name/dist ਫੋਲਡਰ ਹੋਵੇਗਾ। ਅਤੇ, ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਪਿਛਲੀ ਪੋਸਟ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਆਉਟਪੁੱਟ ਡਾਇਰੈਕਟਰੀ ਦੀ ਸਥਿਤੀ, ਜੋ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬਣਾਉਣ ਲਈ ਸੈੱਟ ਕੀਤੀ ਗਈ ਹੈ, ਨੂੰ OUTPUT_DIR ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਓਵਰਰਾਈਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਖੈਰ, ਕਿਉਂਕਿ ਆਉਟਪੁੱਟ ਫੋਲਡਰ ਦੀ ਸਥਿਤੀ ਫਰੇਮਵਰਕ ਤੋਂ ਫਰੇਮਵਰਕ ਤੱਕ ਵੱਖਰੀ ਹੁੰਦੀ ਹੈ, ਤੁਸੀਂ ਬਸ ਤਿਆਰ ਕੀਤੀ ਆਉਟਪੁੱਟ ਨੂੰ ਚਿੱਤਰ ਵਿੱਚ ਸਟੈਂਡਰਡ ਫੋਲਡਰ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹੋ, ਅਰਥਾਤ /opt/apt-root/output. ਇਸ ਲੇਖ ਦੇ ਬਾਕੀ ਹਿੱਸੇ ਨੂੰ ਸਮਝਣ ਲਈ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਪਰ ਹੁਣ ਲਈ ਆਓ ਜਲਦੀ ਨਾਲ ਅਗਲੇ ਪੜਾਅ - ਰਨ ਪੜਾਅ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ।

ਰਨ ਪੜਾਅ

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

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

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

ਜੰਜੀਰ ਬੰਨ੍ਹਦਾ ਹੈ

ਇਸ ਬਾਰੇ ਉਹ ਲਿਖਦੇ ਹਨ ਜੰਜੀਰੀ ਬਣਾਉਂਦੇ ਹਨ OpenShift ਦਸਤਾਵੇਜ਼ ਵਿੱਚ:

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

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

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

ਹੁਣ ਇਸ ਨੂੰ ਇੱਕ ਖਾਸ ਉਦਾਹਰਣ ਨਾਲ ਵੇਖੀਏ।

ਸਿਖਲਾਈ ਲਈ ਅਸੀਂ ਵਰਤਾਂਗੇ ਸਧਾਰਨ ਪ੍ਰਤੀਕਿਰਿਆ ਐਪਲੀਕੇਸ਼ਨ, create-react-app ਕਮਾਂਡ ਲਾਈਨ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਗਿਆ।

ਇਹ ਸਾਨੂੰ ਸਭ ਕੁਝ ਇਕੱਠੇ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ OpenShift ਟੈਂਪਲੇਟ ਫਾਈਲ.

ਆਉ ਇਸ ਫਾਈਲ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ, ਅਤੇ ਪੈਰਾਮੀਟਰ ਸੈਕਸ਼ਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ.

parameters:
  - name: SOURCE_REPOSITORY_URL
    description: The source URL for the application
    displayName: Source URL
    required: true
  - name: SOURCE_REPOSITORY_REF
    description: The branch name for the application
    displayName: Source Branch
    value: master
    required: true
  - name: SOURCE_REPOSITORY_DIR
    description: The location within the source repo of the application
    displayName: Source Directory
    value: .
    required: true
  - name: OUTPUT_DIR
    description: The location of the compiled static files from your web apps builder
    displayName: Output Directory
    value: build
    required: false

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

ਆਓ ਹੁਣ ਇਮੇਜਸਟ੍ਰੀਮਜ਼ ਸੈਕਸ਼ਨ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ।

- apiVersion: v1
  kind: ImageStream
  metadata:
    name: react-web-app-builder  // 1 
  spec: {}
- apiVersion: v1
  kind: ImageStream
  metadata:
    name: react-web-app-runtime  // 2 
  spec: {}
- apiVersion: v1
  kind: ImageStream
  metadata:
    name: web-app-builder-runtime // 3
  spec:
    tags:
    - name: latest
      from:
        kind: DockerImage
        name: nodeshift/ubi8-s2i-web-app:10.x
- apiVersion: v1
  kind: ImageStream
  metadata:
    name: nginx-image-runtime // 4
  spec:
    tags:
    - name: latest
      from:
        kind: DockerImage
        name: 'centos/nginx-112-centos7:latest'

ਤੀਜੇ ਅਤੇ ਚੌਥੇ ਚਿੱਤਰਾਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੋ। ਉਹ ਦੋਵੇਂ ਡੌਕਰ ਚਿੱਤਰਾਂ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਉਹ ਕਿੱਥੋਂ ਆਉਂਦੇ ਹਨ.

ਤੀਜਾ ਚਿੱਤਰ ਵੈੱਬ-ਐਪ-ਬਿਲਡਰ ਹੈ ਅਤੇ ਇਹ nodeshift/ubi8-s2i-web-app ਟੈਗ ਕੀਤੇ 10.x ਤੋਂ ਆਉਂਦਾ ਹੈ ਡੌਕਰ ਹੱਬ.

ਚੌਥਾ ਇੱਕ NGINX ਚਿੱਤਰ (ਵਰਜਨ 1.12) ਹੈ ਜਿਸ ਵਿੱਚ ਨਵੀਨਤਮ ਟੈਗ ਹੈ ਡੌਕਰ ਹੱਬ.

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

ਦੂਜਾ ਚਿੱਤਰ - react-web-app-runtime - nginx-image-runtime ਅਤੇ react-web-app-builder ਚਿੱਤਰ ਤੋਂ ਕੁਝ ਫਾਈਲਾਂ ਨੂੰ ਜੋੜਨ ਦਾ ਨਤੀਜਾ ਹੋਵੇਗਾ। ਇਹ ਚਿੱਤਰ ਤੈਨਾਤੀ ਦੌਰਾਨ ਵੀ ਵਰਤਿਆ ਜਾਵੇਗਾ ਅਤੇ ਇਸ ਵਿੱਚ ਸਿਰਫ਼ ਵੈੱਬ ਸਰਵਰ ਅਤੇ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਸਥਿਰ HTML, JavaScript, CSS ਸ਼ਾਮਲ ਹੋਵੇਗਾ।

ਉਲਝਣ? ਆਓ ਹੁਣ ਬਿਲਡ ਸੰਰਚਨਾਵਾਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ ਅਤੇ ਇਹ ਥੋੜਾ ਸਪੱਸ਼ਟ ਹੋ ਜਾਵੇਗਾ.

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

  apiVersion: v1
  kind: BuildConfig
  metadata:
    name: react-web-app-builder
  spec:
    output:
      to:
        kind: ImageStreamTag
        name: react-web-app-builder:latest // 1
    source:   // 2 
      git:
        uri: ${SOURCE_REPOSITORY_URL}
        ref: ${SOURCE_REPOSITORY_REF}
      contextDir: ${SOURCE_REPOSITORY_DIR}
      type: Git
    strategy:
      sourceStrategy:
        env:
          - name: OUTPUT_DIR // 3 
            value: ${OUTPUT_DIR}
        from:
          kind: ImageStreamTag
          name: web-app-builder-runtime:latest // 4
        incremental: true // 5
      type: Source
    triggers: // 6
    - github:
        secret: ${GITHUB_WEBHOOK_SECRET}
      type: GitHub
    - type: ConfigChange
    - imageChange: {}
      type: ImageChange

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

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

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

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

ਅਤੇ ਅੰਤ ਵਿੱਚ, 6 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ ਬਿਲਡ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਚਲਾਉਣ ਲਈ, ਦਸਤੀ ਦਖਲ ਦੇ ਬਿਨਾਂ, ਜਦੋਂ ਕੁਝ ਬਦਲਦਾ ਹੈ, ਬਣਾਉਣ ਲਈ ਕੁਝ ਟਰਿੱਗਰ ਹਨ।

ਕੁੱਲ ਮਿਲਾ ਕੇ ਇਹ ਇੱਕ ਬਹੁਤ ਹੀ ਮਿਆਰੀ ਬਿਲਡ ਕੌਂਫਿਗਰੇਸ਼ਨ ਹੈ।

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

apiVersion: v1
  kind: BuildConfig
  metadata:
    name: react-web-app-runtime
  spec:
    output:
      to:
        kind: ImageStreamTag
        name: react-web-app-runtime:latest // 1
    source: // 2
      type: Image
      images:                              
        - from:
            kind: ImageStreamTag
            name: react-web-app-builder:latest // 3
          paths:
            - sourcePath: /opt/app-root/output/.  // 4
              destinationDir: .  // 5
             
    strategy: // 6
      sourceStrategy:
        from:
          kind: ImageStreamTag
          name: nginx-image-runtime:latest
        incremental: true
      type: Source
    triggers:
    - github:
        secret: ${GITHUB_WEBHOOK_SECRET}
      type: GitHub
    - type: ConfigChange
    - type: ImageChange
      imageChange: {}
    - type: ImageChange
      imageChange:
        from:
          kind: ImageStreamTag
          name: react-web-app-builder:latest // 7

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

1 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ ਕੋਈ ਨਵੀਂ ਗੱਲ ਨਹੀਂ ਹੈ - ਇਹ ਸਿਰਫ਼ ਇਹ ਕਹਿੰਦੀ ਹੈ ਕਿ ਬਿਲਡ ਨਤੀਜਾ ਰੀਐਕਟ-ਵੈਬ-ਐਪ-ਰਨਟਾਈਮ ਚਿੱਤਰ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ.

2 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਸੰਰਚਨਾ ਵਿੱਚ, ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਸਰੋਤ ਕੋਡ ਕਿੱਥੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਪਰ ਧਿਆਨ ਦਿਓ ਕਿ ਇੱਥੇ ਅਸੀਂ ਕਹਿ ਰਹੇ ਹਾਂ ਕਿ ਇਹ ਚਿੱਤਰ ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਚਿੱਤਰ ਤੋਂ ਜੋ ਅਸੀਂ ਹੁਣੇ ਬਣਾਈ ਹੈ - ਪ੍ਰਤੀਕਿਰਿਆ-ਵੈਬ-ਐਪ-ਬਿਲਡਰ ਤੋਂ (3 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ)। ਜਿਹੜੀਆਂ ਫਾਈਲਾਂ ਅਸੀਂ ਵਰਤਣੀਆਂ ਚਾਹੁੰਦੇ ਹਾਂ ਉਹ ਚਿੱਤਰ ਦੇ ਅੰਦਰ ਹਨ ਅਤੇ ਉਹਨਾਂ ਦਾ ਸਥਾਨ 4 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਇਹ /opt/app-root/output/ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਯਾਦ ਹੈ, ਤਾਂ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਆਧਾਰ 'ਤੇ ਤਿਆਰ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਲੇਬਲ 5 ਦੇ ਨਾਲ ਸ਼ਬਦ ਵਿੱਚ ਨਿਰਦਿਸ਼ਟ ਮੰਜ਼ਿਲ ਫੋਲਡਰ ਸਿਰਫ਼ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਹੈ (ਇਹ ਸਭ ਕੁਝ ਹੈ, ਯਾਦ ਰੱਖੋ, ਓਪਨਸ਼ਿਫਟ ਨਾਮਕ ਕਿਸੇ ਜਾਦੂਈ ਚੀਜ਼ ਦੇ ਅੰਦਰ ਚੱਲ ਰਿਹਾ ਹੈ, ਨਾ ਕਿ ਤੁਹਾਡੇ ਸਥਾਨਕ ਕੰਪਿਊਟਰ 'ਤੇ)।

ਰਣਨੀਤੀ ਭਾਗ - 6 ਲੇਬਲ ਵਾਲੀ ਲਾਈਨ - ਵੀ ਪਹਿਲੀ ਬਿਲਡ ਕੌਂਫਿਗਰੇਸ਼ਨ ਦੇ ਸਮਾਨ ਹੈ। ਕੇਵਲ ਇਸ ਵਾਰ ਅਸੀਂ nginx-image-runtime ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਚਿੱਤਰਸਟ੍ਰੀਮ ਭਾਗ ਵਿੱਚ ਦੇਖਿਆ ਹੈ.

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

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

ਐਪਲੀਕੇਸ਼ਨ ਤੈਨਾਤੀ

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

ਅਸੀਂ ਆਪਣੇ ਟੈਂਪਲੇਟ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਓਪਨਸ਼ਿਫਟ ਕਲਾਇੰਟ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ:

$ find . | grep openshiftio | grep application | xargs -n 1 oc apply -f

$ oc new-app --template react-web-app -p SOURCE_REPOSITORY_URL=https://github.com/lholmquist/react-web-app

ਉੱਪਰ ਦਿੱਤੇ ਸਕ੍ਰੀਨਸ਼ੌਟ ਵਿੱਚ ਪਹਿਲੀ ਕਮਾਂਡ ਇੱਕ ਟੈਂਪਲੇਟ./openshiftio/application.yaml ਨੂੰ ਲੱਭਣ ਦਾ ਇੱਕ ਜਾਣਬੁੱਝ ਕੇ ਇੰਜੀਨੀਅਰਿੰਗ ਤਰੀਕਾ ਹੈ।

ਦੂਜੀ ਕਮਾਂਡ ਇਸ ਟੈਂਪਲੇਟ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਨਵੀਂ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਂਦੀ ਹੈ।

ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਦੇ ਕੰਮ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਸਾਡੇ ਕੋਲ ਦੋ ਅਸੈਂਬਲੀਆਂ ਹਨ:

ਅਤੇ ਓਵਰਵਿਊ ਸਕ੍ਰੀਨ ਤੇ ਵਾਪਸ ਆਉਣਾ, ਅਸੀਂ ਲਾਂਚ ਕੀਤੇ ਪੌਡ ਨੂੰ ਦੇਖਾਂਗੇ:

ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਸਾਨੂੰ ਸਾਡੀ ਐਪ 'ਤੇ ਲਿਜਾਇਆ ਜਾਵੇਗਾ, ਜੋ ਕਿ ਡਿਫੌਲਟ ਰੀਐਕਟ ਐਪ ਪੰਨਾ ਹੈ:

ਪੂਰਕ 1

ਕੋਣ ਪ੍ਰੇਮੀਆਂ ਲਈ ਸਾਡੇ ਕੋਲ ਵੀ ਹੈ ਉਦਾਹਰਨ ਐਪਲੀਕੇਸ਼ਨ.

OUTPUT_DIR ਵੇਰੀਏਬਲ ਨੂੰ ਛੱਡ ਕੇ, ਇੱਥੇ ਪੈਟਰਨ ਇੱਕੋ ਜਿਹਾ ਹੈ।

ਪੂਰਕ 2

ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ NGINX ਨੂੰ ਇੱਕ ਵੈਬ ਸਰਵਰ ਵਜੋਂ ਵਰਤਿਆ ਹੈ, ਪਰ ਇਸਨੂੰ ਅਪਾਚੇ ਨਾਲ ਬਦਲਣਾ ਕਾਫ਼ੀ ਆਸਾਨ ਹੈ, ਸਿਰਫ਼ ਫਾਈਲ ਵਿੱਚ ਟੈਂਪਲੇਟ ਬਦਲੋ NGINX ਚਿੱਤਰ 'ਤੇ ਅਪਾਚੇ ਚਿੱਤਰ.

ਸਿੱਟਾ

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

ਲੇਖਾਂ ਦੀ ਇਸ ਲੜੀ ਦੀ ਸਮੱਗਰੀ

• ਭਾਗ 1: ਆਧੁਨਿਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕੁਝ ਕਦਮਾਂ ਵਿੱਚ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ;
• ਭਾਗ 2: ਇੱਕ ਮੌਜੂਦਾ HTTP ਸਰਵਰ ਚਿੱਤਰ, ਜਿਵੇਂ ਕਿ NGINX, ਉਤਪਾਦਨ ਤੈਨਾਤੀ ਲਈ ਸੰਬੰਧਿਤ ਓਪਨਸ਼ਿਫਟ ਅਸੈਂਬਲੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਨਵੀਂ S2I ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ;
• ਭਾਗ 3: OpenShift ਪਲੇਟਫਾਰਮ 'ਤੇ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਵਿਕਾਸ ਸਰਵਰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਥਾਨਕ ਫਾਈਲ ਸਿਸਟਮ ਨਾਲ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕਰਨਾ ਹੈ।

ਵਧੀਕ ਸਰੋਤ

• ਮੁਫਤ ਈ-ਕਿਤਾਬ OpenShift ਵਿੱਚ ਤੈਨਾਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ.
• 'ਤੇ ਜਾਣਕਾਰੀ OpenShift ਅਤੇ Kubernetes.

ਸਰੋਤ: www.habr.com