ਡੌਕਰ ਕੰਪੋਜ਼: ਵਿਕਾਸ ਤੋਂ ਉਤਪਾਦਨ ਤੱਕ

ਕੋਰਸ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਦੀ ਉਮੀਦ ਵਿੱਚ ਤਿਆਰ ਪੋਡਕਾਸਟ ਟ੍ਰਾਂਸਕ੍ਰਿਪਸ਼ਨ ਦਾ ਅਨੁਵਾਦ "ਲੀਨਕਸ ਪ੍ਰਸ਼ਾਸਕ"

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

ਦੇ ਆਗਮਨ ਨਾਲ ਡੌਕਰ ਕੰਪੋਜ਼ v3 ਇਹਨਾਂ YAML ਫਾਈਲਾਂ ਨੂੰ ਸਿੱਧੇ ਉਤਪਾਦਨ ਵਾਤਾਵਰਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਨਾਲ ਕੰਮ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ
ਕਲੱਸਟਰ ਡੌਕਰ ਸਵਰਮ.

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

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

ਵਿਕਾਸ ਅਤੇ ਉਤਪਾਦਨ ਫਾਈਲਾਂ ਵਿਚਕਾਰ ਅੰਤਰ

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

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

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

ਸੰਰਚਨਾ ਓਵਰਰਾਈਡ

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

ਡੌਕਰ ਕੰਪੋਜ਼ ਵੱਖ-ਵੱਖ ਕੰਪੋਜ਼ ਫਾਈਲਾਂ ਨੂੰ ਮਿਲਾਉਣ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ
ਅੰਤਮ ਸੰਰਚਨਾ ਪ੍ਰਾਪਤ ਕਰੋ. ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਉਦਾਹਰਨ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

$ cat docker-compose.yml
version: "3.2"

services:
  whale:
    image: docker/whalesay
    command: ["cowsay", "hello!"]
$ docker-compose up
Creating network "composeconfigs_default" with the default driver
Starting composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ________
whale_1  | < hello! >
whale_1  |  --------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

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

$ cat docker-compose.second.yml
version: "3.2"
services:
  whale:
    command: ["cowsay", "bye!"]

$ docker-compose -f docker-compose.yml -f docker-compose.second.yml up
Creating composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ______
whale_1  | < bye! >
whale_1  |  ------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

ਇਹ ਸੰਟੈਕਸ ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ, ਜਦੋਂ ਕਮਾਂਡ
ਕਈ ਵਾਰ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ।

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਡੌਕਰ ਕੰਪੋਜ਼ ਆਟੋਮੈਟਿਕਲੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਫਾਈਲ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ
docker-compose.override.yml ਮੁੱਲਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨ ਲਈ ਡੌਕਰ-ਕੰਪੋਜ਼.ਆਈ.ਐਮ.ਐਲ.. ਜੇ
ਦੂਜੀ ਫਾਈਲ ਦਾ ਨਾਮ ਬਦਲੋ, ਤੁਹਾਨੂੰ ਉਹੀ ਨਤੀਜਾ ਮਿਲੇਗਾ, ਸਿਰਫ ਅਸਲ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ:

$ mv docker-compose.second.yml docker-compose.override.yml
$ docker-compose up
Starting composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ______
whale_1  | < bye! >
whale_1  |  ------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

ਠੀਕ ਹੈ, ਇਹ ਯਾਦ ਰੱਖਣਾ ਆਸਾਨ ਹੈ।

ਵੇਰੀਏਬਲਾਂ ਦਾ ਇੰਟਰਪੋਲੇਸ਼ਨ

ਸੰਰਚਨਾ ਫਾਇਲ ਸਹਿਯੋਗ ਇੰਟਰਪੋਲੇਸ਼ਨ
ਵੇਰੀਏਬਲ ਅਤੇ ਮੂਲ ਮੁੱਲ। ਭਾਵ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ:

services:
  my-service:
    build:
      context: .
    image: private.registry.mine/my-stack/my-service:${MY_SERVICE_VERSION:-latest}
...

ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਕਰਦੇ ਹੋ ਡੌਕਰ-ਕੰਪੋਜ਼ ਬਿਲਡ (ਜਾਂ ਪੁਸ਼) ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਤੋਂ ਬਿਨਾਂ
$MY_SERVICE_VERSION, ਮੁੱਲ ਵਰਤਿਆ ਜਾਵੇਗਾ ਤਾਜ਼ਾਪਰ ਜੇ ਤੁਸੀਂ ਸੈਟ ਕਰਦੇ ਹੋ
ਬਿਲਡ ਤੋਂ ਪਹਿਲਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ, ਇਹ ਬਿਲਡਿੰਗ ਜਾਂ ਪੁਸ਼ ਕਰਨ ਵੇਲੇ ਵਰਤਿਆ ਜਾਵੇਗਾ
ਰਜਿਸਟਰ ਨੂੰ private.registry.mine.

ਮੇਰੇ ਅਸੂਲ

ਮੇਰੇ ਲਈ ਕੰਮ ਕਰਨ ਵਾਲੇ ਤਰੀਕੇ ਤੁਹਾਡੇ ਲਈ ਵੀ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ। ਮੈਂ ਇਹਨਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹਾਂ
ਸਧਾਰਨ ਨਿਯਮ:

• ਉਤਪਾਦਨ, ਵਿਕਾਸ (ਜਾਂ ਹੋਰ ਵਾਤਾਵਰਣ) ਲਈ ਮੇਰੇ ਸਾਰੇ ਸਟੈਕ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ
  docker-ਕੰਪੋਜ਼ ਫਾਈਲਾਂ
• ਮੇਰੇ ਸਾਰੇ ਵਾਤਾਵਰਨ ਨੂੰ ਕਵਰ ਕਰਨ ਲਈ ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਦੀ ਲੋੜ ਹੈ, ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ
  ਨਕਲ ਤੋਂ ਬਚੋ।
• ਮੈਨੂੰ ਹਰੇਕ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਕਮਾਂਡ ਦੀ ਲੋੜ ਹੈ।
• ਮੁੱਖ ਸੰਰਚਨਾ ਨੂੰ ਫਾਇਲ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਡੌਕਰ-ਕੰਪੋਜ਼.ਆਈ.ਐਮ.ਐਲ..
• ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਦੀ ਵਰਤੋਂ ਚਿੱਤਰ ਟੈਗ ਜਾਂ ਹੋਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ
  ਵੇਰੀਏਬਲ ਜੋ ਵਾਤਾਵਰਣ ਤੋਂ ਵਾਤਾਵਰਣ ਤੱਕ ਵੱਖੋ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ (ਸਟੇਜਿੰਗ, ਏਕੀਕਰਣ,
  ਉਤਪਾਦਨ).
• ਉਤਪਾਦਨ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲਾਂ ਲਈ ਮੁੱਲਾਂ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ
  ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਜੋਖਮਾਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ ਜੇਕਰ ਸਟੈਕ ਬਿਨਾਂ ਉਤਪਾਦਨ ਵਿੱਚ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ
  ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰੋ।
• ਇੱਕ ਉਤਪਾਦਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਇੱਕ ਸੇਵਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ docker stack deploy - compose-file docker-compose.yml -with-registry-auth my-stack-name.
• ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਾਰਜਸ਼ੀਲ ਵਾਤਾਵਰਣ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ ਡੌਕਰ-ਕੰਪੋਜ਼ ਅਪ-ਡੀ.

ਆਉ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਵੱਲ ਧਿਆਨ ਦੇਈਏ.

# docker-compose.yml
...
services:
  my-service:
    build:
      context: .
    image: private.registry.mine/my-stack/my-service:${MY_SERVICE_VERSION:-latest}
    environment:
      API_ENDPOINT: ${API_ENDPOINT:-https://production.my-api.com}
...

И

# docker-compose.override.yml
...
services:
  my-service:
    ports: # This is needed for development!
      - 80:80
    environment:
      API_ENDPOINT: https://devel.my-api.com
    volumes:
      - ./:/project/src
...

ਮੈਂ ਵਰਤ ਸਕਦਾ ਹਾਂ ਡੌਕਰ-ਕੰਪੋਜ਼ (ਡੌਕਰ-ਕੰਪੋਜ਼ ਅੱਪ)ਵਿੱਚ ਸਟੈਕ ਨੂੰ ਚਲਾਉਣ ਲਈ
ਵਿੱਚ ਮਾਊਂਟ ਕੀਤੇ ਸਰੋਤ ਕੋਡ ਦੇ ਨਾਲ ਵਿਕਾਸ ਮੋਡ /ਪ੍ਰੋਜੈਕਟ/src.

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

export MY_SERVICE_VERSION=1.2.3
docker-compose -f docker-compose.yml build
docker-compose -f docker-compose.yml push

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

export MY_SERVICE_VERSION=1.2.3
docker stack deploy my-stack --compose-file docker-compose.yml --with-registry-auth

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

export MY_SERVICE_VERSION=1.2.3
export API_ENDPOINT=http://staging.my-api.com
docker stack deploy my-stack --compose-file docker-compose.yml --with-registry-auth

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਦੋ ਵੱਖ-ਵੱਖ ਡੌਕਰ-ਕੰਪੋਜ਼ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਜੋ ਕਿ ਬਿਨਾਂ
ਡੁਪਲੀਕੇਟ ਸੰਰਚਨਾ ਤੁਹਾਡੇ ਕਿਸੇ ਵੀ ਵਾਤਾਵਰਣ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ!

ਕੋਰਸ ਬਾਰੇ ਹੋਰ ਜਾਣੋ "ਲੀਨਕਸ ਪ੍ਰਸ਼ਾਸਕ"

ਸਰੋਤ: www.habr.com