ਡੌਕਰ ਅਤੇ ਸਾਰੇ, ਸਾਰੇ, ਸਾਰੇ

TL; DR: ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਚੱਲਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਫਰੇਮਵਰਕ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਇੱਕ ਸੰਖੇਪ ਗਾਈਡ। ਡੌਕਰ ਅਤੇ ਹੋਰ ਸਮਾਨ ਪ੍ਰਣਾਲੀਆਂ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ ਜਾਵੇਗਾ।

ਇਹ ਸਭ ਕਿੱਥੋਂ ਆਇਆ ਇਸ ਦਾ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਇਤਿਹਾਸ

История

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

ਅਗਲਾ ਤਰੀਕਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਰਨਲ ਦੀਆਂ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਇੱਕ ਪੂਰਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਲਾਂਚ ਕਰਨਾ ਹੈ। ਇਸ ਵਿਧੀ ਨੂੰ ਵੱਖ-ਵੱਖ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਸਾਰ ਇੱਕ ਹੀ ਹੈ - ਕਈ ਸੁਤੰਤਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਨੂੰ ਲਾਂਚ ਕਰਨਾ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਉਹੀ ਕਰਨਲ ਚਲਾਉਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਮੁੱਖ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਚੱਲਦਾ ਹੈ। ਇਹਨਾਂ ਵਿੱਚ ਲੀਨਕਸ ਲਈ FreeBSD ਜੇਲ੍ਹਾਂ, ਸੋਲਾਰਿਸ ਜ਼ੋਨ, OpenVZ ਅਤੇ LXC ਸ਼ਾਮਲ ਹਨ। ਅਲੱਗ-ਥਲੱਗ ਨਾ ਸਿਰਫ਼ ਡਿਸਕ ਸਪੇਸ ਦੁਆਰਾ, ਸਗੋਂ ਹੋਰ ਸਰੋਤਾਂ ਦੁਆਰਾ ਵੀ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ; ਖਾਸ ਤੌਰ 'ਤੇ, ਹਰੇਕ ਕੰਟੇਨਰ ਵਿੱਚ ਪ੍ਰੋਸੈਸਰ ਦੇ ਸਮੇਂ, RAM ਅਤੇ ਨੈੱਟਵਰਕ ਬੈਂਡਵਿਡਥ ਦੀਆਂ ਸੀਮਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਕ੍ਰੋਟ ਦੇ ਮੁਕਾਬਲੇ, ਕੰਟੇਨਰ ਨੂੰ ਛੱਡਣਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਕੰਟੇਨਰ ਵਿੱਚ ਸੁਪਰਯੂਜ਼ਰ ਕੋਲ ਸਿਰਫ ਕੰਟੇਨਰ ਦੀ ਸਮੱਗਰੀ ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ, ਹਾਲਾਂਕਿ, ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਅਪ ਟੂ ਡੇਟ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਅਤੇ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਦੇ ਕਾਰਨ ਕਰਨਲ ਦੇ (ਲੀਨਕਸ ਲਈ ਢੁਕਵੇਂ, ਕੁਝ ਹੱਦ ਤੱਕ FreeBSD), ਕਰਨਲ ਆਈਸੋਲੇਸ਼ਨ ਸਿਸਟਮ ਨੂੰ "ਤੋੜਨ" ਅਤੇ ਮੁੱਖ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਗੈਰ-ਜ਼ੀਰੋ ਹੈ।

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

ਡੌਕਰ

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

ਸਰੋਤ: ਵਿਕੀਮੀਡੀਆ

ਆਰਕੀਟੈਕਚਰ

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

ਇੰਸਟਾਲੇਸ਼ਨ ਅਤੇ ਸੰਰਚਨਾ

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

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

ਇਹ ਵਿਧੀ ਸਵੈਚਲਿਤ ਸਥਾਪਨਾ ਲਈ ਵੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ Ansible ਜਾਂ ਹੋਰ ਸਮਾਨ ਪ੍ਰਣਾਲੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਪਰ ਮੈਂ ਇਸ ਲੇਖ ਵਿੱਚ ਇਸ ਬਾਰੇ ਵਿਚਾਰ ਨਹੀਂ ਕਰਾਂਗਾ।

ਸਥਾਪਨਾ Centos 7 'ਤੇ ਕੀਤੀ ਜਾਵੇਗੀ, ਮੈਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਸਰਵਰ ਵਜੋਂ ਵਰਤਾਂਗਾ, ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਵਾਂਗਾ:

# yum install -y yum-utils
# yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# yum install docker-ce docker-ce-cli containerd.io

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

# systemctl enable docker
# systemctl start docker
# firewall-cmd --zone=public --add-port=2377/tcp --permanent

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਇੱਕ ਡੌਕਰ ਸਮੂਹ ਬਣਾ ਸਕਦੇ ਹੋ, ਜਿਸ ਦੇ ਉਪਭੋਗਤਾ ਬਿਨਾਂ ਸੂਡੋ ਦੇ ਡੌਕਰ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਗੇ, ਲੌਗਿੰਗ ਸੈਟ ਅਪ ਕਰ ਸਕਣਗੇ, ਬਾਹਰੋਂ API ਤੱਕ ਪਹੁੰਚ ਨੂੰ ਸਮਰੱਥ ਕਰ ਸਕਣਗੇ, ਅਤੇ ਫਾਇਰਵਾਲ ਨੂੰ ਵਧੇਰੇ ਸਹੀ ਢੰਗ ਨਾਲ ਕੌਂਫਿਗਰ ਕਰਨਾ ਨਾ ਭੁੱਲੋ (ਹਰ ਚੀਜ਼ ਜਿਸਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ) ਉੱਪਰ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਮਨਾਹੀ ਹੈ - ਮੈਂ ਇਸਨੂੰ ਸਾਦਗੀ ਅਤੇ ਸਪਸ਼ਟਤਾ ਲਈ ਛੱਡ ਦਿੱਤਾ ਹੈ), ਪਰ ਮੈਂ ਇੱਥੇ ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ।

ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

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

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

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

ਡੌਕਰ ਨਾਲ ਕੰਮ ਕਰਨਾ

ਇੰਸਟਾਲੇਸ਼ਨ ਅਤੇ ਕੌਂਫਿਗਰੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇੱਕ ਕਲੱਸਟਰ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਵਿਕਾਸ ਟੀਮ ਲਈ ਗਿੱਟਲੈਬ ਅਤੇ ਡੌਕਰ ਰਜਿਸਟਰੀ ਨੂੰ ਤੈਨਾਤ ਕਰਾਂਗੇ। ਮੈਂ ਸਰਵਰਾਂ ਦੇ ਤੌਰ 'ਤੇ ਤਿੰਨ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ, ਜਿਸ 'ਤੇ ਮੈਂ ਵਿਤਰਿਤ FS GlusterFS ਨੂੰ ਵੀ ਤੈਨਾਤ ਕਰਾਂਗਾ; ਮੈਂ ਇਸਨੂੰ ਡੌਕਰ ਵਾਲੀਅਮ ਸਟੋਰੇਜ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਾਂਗਾ, ਉਦਾਹਰਨ ਲਈ, ਡੌਕਰ ਰਜਿਸਟਰੀ ਦੇ ਇੱਕ ਨੁਕਸ-ਸਹਿਣਸ਼ੀਲ ਸੰਸਕਰਣ ਨੂੰ ਚਲਾਉਣ ਲਈ। ਚਲਾਉਣ ਲਈ ਮੁੱਖ ਭਾਗ: ਡੌਕਰ ਰਜਿਸਟਰੀ, Postgresql, Redis, GitLab Swarm ਦੇ ਸਿਖਰ 'ਤੇ GitLab ਰਨਰ ਲਈ ਸਮਰਥਨ ਦੇ ਨਾਲ। ਅਸੀਂ ਕਲੱਸਟਰਿੰਗ ਨਾਲ Postgresql ਲਾਂਚ ਕਰਾਂਗੇ ਸਟੋਲਨ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ Postgresql ਡਾਟਾ ਸਟੋਰ ਕਰਨ ਲਈ GlusterFS ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਬਾਕੀ ਬਚਿਆ ਨਾਜ਼ੁਕ ਡੇਟਾ GlusterFS 'ਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਵੇਗਾ।

GlusterFS ਨੂੰ ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਤੈਨਾਤ ਕਰਨ ਲਈ (ਉਹਨਾਂ ਨੂੰ node1, node2, node3 ਕਿਹਾ ਜਾਂਦਾ ਹੈ), ਤੁਹਾਨੂੰ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ, ਫਾਇਰਵਾਲ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਅਤੇ ਲੋੜੀਂਦੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ:

# yum -y install centos-release-gluster7
# yum -y install glusterfs-server
# systemctl enable glusterd
# systemctl start glusterd
# firewall-cmd --add-service=glusterfs --permanent
# firewall-cmd --reload
# mkdir -p /srv/gluster
# mkdir -p /srv/docker
# echo "$(hostname):/docker /srv/docker glusterfs defaults,_netdev 0 0" >> /etc/fstab

ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, GlusterFS ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ 'ਤੇ ਕੰਮ ਨੂੰ ਇੱਕ ਨੋਡ ਤੋਂ ਜਾਰੀ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ node1:

# gluster peer probe node2
# gluster peer probe node3
# gluster volume create docker replica 3 node1:/srv/gluster node2:/srv/gluster node3:/srv/gluster force
# gluster volume start docker

ਫਿਰ ਤੁਹਾਨੂੰ ਨਤੀਜੇ ਵਾਲੇ ਵਾਲੀਅਮ ਨੂੰ ਮਾਊਂਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ (ਕਮਾਂਡ ਨੂੰ ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਚਲਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ):

# mount /srv/docker

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

ਸ਼ੁਰੂਆਤੀ ਕਲੱਸਟਰ ਸੈੱਟਅੱਪ, ਮੈਂ node1 'ਤੇ ਕਮਾਂਡ ਚਲਾਉਂਦਾ ਹਾਂ:

# docker swarm init
Swarm initialized: current node (a5jpfrh5uvo7svzz1ajduokyq) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-0c5mf7mvzc7o7vjk0wngno2dy70xs95tovfxbv4tqt9280toku-863hyosdlzvd76trfptd4xnzd xx.xx.xx.xx:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
# docker swarm join-token manager

ਅਸੀਂ ਦੂਜੀ ਕਮਾਂਡ ਦੇ ਨਤੀਜੇ ਦੀ ਨਕਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ node2 ਅਤੇ node3 'ਤੇ ਚਲਾਉਂਦੇ ਹਾਂ:

# docker swarm join --token SWMTKN-x-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxx xx.xx.xx.xx:2377
This node joined a swarm as a manager.

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

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਕੰਟੇਨਰਾਂ ਲਈ ਨੈੱਟਵਰਕ ਬਣਾਈਏ:

# docker network create --driver=overlay etcd
# docker network create --driver=overlay pgsql
# docker network create --driver=overlay redis
# docker network create --driver=overlay traefik
# docker network create --driver=overlay gitlab

ਫਿਰ ਅਸੀਂ ਸਰਵਰਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰਦੇ ਹਾਂ, ਕੁਝ ਸੇਵਾਵਾਂ ਨੂੰ ਸਰਵਰਾਂ ਨਾਲ ਜੋੜਨ ਲਈ ਇਹ ਜ਼ਰੂਰੀ ਹੈ:

# docker node update --label-add nodename=node1 node1
# docker node update --label-add nodename=node2 node2
# docker node update --label-add nodename=node3 node3

ਅੱਗੇ, ਅਸੀਂ etcd ਡੇਟਾ, KV ਸਟੋਰੇਜ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਉਂਦੇ ਹਾਂ, ਜੋ ਟਰੈਫਿਕ ਅਤੇ ਸਟੋਲਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ। Postgresql ਦੇ ਸਮਾਨ, ਇਹ ਸਰਵਰਾਂ ਨਾਲ ਜੁੜੇ ਕੰਟੇਨਰ ਹੋਣਗੇ, ਇਸਲਈ ਅਸੀਂ ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਇਹ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹਾਂ:

# mkdir -p /srv/etcd

ਅੱਗੇ, etcd ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ ਬਣਾਓ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਰੋ:

00etcd.yml

version: '3.7'

services:
  etcd1:
    image: quay.io/coreos/etcd:latest
    hostname: etcd1
    command:
      - etcd
      - --name=etcd1
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd1:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd1:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    networks:
      - etcd
    volumes:
      - etcd1vol:/data.etcd
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node1]
  etcd2:
    image: quay.io/coreos/etcd:latest
    hostname: etcd2
    command:
      - etcd
      - --name=etcd2
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd2:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd2:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    networks:
      - etcd
    volumes:
      - etcd2vol:/data.etcd
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node2]
  etcd3:
    image: quay.io/coreos/etcd:latest
    hostname: etcd3
    command:
      - etcd
      - --name=etcd3
      - --data-dir=/data.etcd
      - --advertise-client-urls=http://etcd3:2379
      - --listen-client-urls=http://0.0.0.0:2379
      - --initial-advertise-peer-urls=http://etcd3:2380
      - --listen-peer-urls=http://0.0.0.0:2380
      - --initial-cluster=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
      - --initial-cluster-state=new
      - --initial-cluster-token=etcd-cluster
    networks:
      - etcd
    volumes:
      - etcd3vol:/data.etcd
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node3]

volumes:
  etcd1vol:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/etcd"
  etcd2vol:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/etcd"
  etcd3vol:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/etcd"

networks:
  etcd:
    external: true

# docker stack deploy --compose-file 00etcd.yml etcd

ਕੁਝ ਸਮੇਂ ਬਾਅਦ, ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ etcd ਕਲੱਸਟਰ ਉੱਪਰ ਹੈ:

# docker exec $(docker ps | awk '/etcd/ {print $1}')  etcdctl member list
ade526d28b1f92f7: name=etcd1 peerURLs=http://etcd1:2380 clientURLs=http://etcd1:2379 isLeader=false
bd388e7810915853: name=etcd3 peerURLs=http://etcd3:2380 clientURLs=http://etcd3:2379 isLeader=false
d282ac2ce600c1ce: name=etcd2 peerURLs=http://etcd2:2380 clientURLs=http://etcd2:2379 isLeader=true
# docker exec $(docker ps | awk '/etcd/ {print $1}')  etcdctl cluster-health
member ade526d28b1f92f7 is healthy: got healthy result from http://etcd1:2379
member bd388e7810915853 is healthy: got healthy result from http://etcd3:2379
member d282ac2ce600c1ce is healthy: got healthy result from http://etcd2:2379
cluster is healthy

ਅਸੀਂ Postgresql ਲਈ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਉਂਦੇ ਹਾਂ, ਸਾਰੇ ਸਰਵਰਾਂ 'ਤੇ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹਾਂ:

# mkdir -p /srv/pgsql

ਅੱਗੇ, Postgresql ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ ਬਣਾਓ:

01pgsql.yml

version: '3.7'

services:
  pgsentinel:
    image: sorintlab/stolon:master-pg10
    command:
      - gosu
      - stolon
      - stolon-sentinel
      - --cluster-name=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
      - --log-level=debug
    networks:
      - etcd
      - pgsql
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 30s
        order: stop-first
        failure_action: pause
  pgkeeper1:
    image: sorintlab/stolon:master-pg10
    hostname: pgkeeper1
    command:
      - gosu
      - stolon
      - stolon-keeper
      - --pg-listen-address=pgkeeper1
      - --pg-repl-username=replica
      - --uid=pgkeeper1
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --cluster-name=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    networks:
      - etcd
      - pgsql
    environment:
      - PGDATA=/var/lib/postgresql/data
    volumes:
      - pgkeeper1:/var/lib/postgresql/data
    secrets:
      - pgsql
      - pgsql_repl
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node1]
  pgkeeper2:
    image: sorintlab/stolon:master-pg10
    hostname: pgkeeper2
    command:
      - gosu
      - stolon 
      - stolon-keeper
      - --pg-listen-address=pgkeeper2
      - --pg-repl-username=replica
      - --uid=pgkeeper2
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --cluster-name=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    networks:
      - etcd
      - pgsql
    environment:
      - PGDATA=/var/lib/postgresql/data
    volumes:
      - pgkeeper2:/var/lib/postgresql/data
    secrets:
      - pgsql
      - pgsql_repl
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node2]
  pgkeeper3:
    image: sorintlab/stolon:master-pg10
    hostname: pgkeeper3
    command:
      - gosu
      - stolon 
      - stolon-keeper
      - --pg-listen-address=pgkeeper3
      - --pg-repl-username=replica
      - --uid=pgkeeper3
      - --pg-su-username=postgres
      - --pg-su-passwordfile=/run/secrets/pgsql
      - --pg-repl-passwordfile=/run/secrets/pgsql_repl
      - --data-dir=/var/lib/postgresql/data
      - --cluster-name=stolon-cluster
      - --store-backend=etcdv3
      - --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    networks:
      - etcd
      - pgsql
    environment:
      - PGDATA=/var/lib/postgresql/data
    volumes:
      - pgkeeper3:/var/lib/postgresql/data
    secrets:
      - pgsql
      - pgsql_repl
    deploy:
      replicas: 1
      placement:
        constraints: [node.labels.nodename == node3]
  postgresql:
    image: sorintlab/stolon:master-pg10
    command: gosu stolon stolon-proxy --listen-address 0.0.0.0 --cluster-name stolon-cluster --store-backend=etcdv3 --store-endpoints http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
    networks:
      - etcd
      - pgsql
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 30s
        order: stop-first
        failure_action: rollback

volumes:
  pgkeeper1:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/pgsql"
  pgkeeper2:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/pgsql"
  pgkeeper3:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/pgsql"

secrets:
  pgsql:
    file: "/srv/docker/postgres"
  pgsql_repl:
    file: "/srv/docker/replica"

networks:
  etcd:
    external: true
  pgsql:
    external: true

ਅਸੀਂ ਰਾਜ਼ ਤਿਆਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:

# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/replica
# </dev/urandom tr -dc 234567890qwertyuopasdfghjkzxcvbnmQWERTYUPASDFGHKLZXCVBNM | head -c $(((RANDOM%3)+15)) > /srv/docker/postgres
# docker stack deploy --compose-file 01pgsql.yml pgsql

ਕੁਝ ਸਮੇਂ ਬਾਅਦ (ਕਮਾਂਡ ਦੀ ਆਉਟਪੁੱਟ ਵੇਖੋ ਡੌਕਰ ਸੇਵਾ lsਕਿ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਪੂਰੀਆਂ ਹੋ ਗਈਆਂ ਹਨ) ਅਸੀਂ Postgresql ਕਲੱਸਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ:

# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 init

Postgresql ਕਲੱਸਟਰ ਦੀ ਤਿਆਰੀ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ:

# docker exec $(docker ps | awk '/pgkeeper/ {print $1}') stolonctl --cluster-name=stolon-cluster --store-backend=etcdv3 --store-endpoints=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379 status
=== Active sentinels ===

ID      LEADER
26baa11d    false
74e98768    false
a8cb002b    true

=== Active proxies ===

ID
4d233826
9f562f3b
b0c79ff1

=== Keepers ===

UID     HEALTHY PG LISTENADDRESS    PG HEALTHY  PG WANTEDGENERATION PG CURRENTGENERATION
pgkeeper1   true    pgkeeper1:5432         true     2           2
pgkeeper2   true    pgkeeper2:5432          true            2                   2
pgkeeper3   true    pgkeeper3:5432          true            3                   3

=== Cluster Info ===

Master Keeper: pgkeeper3

===== Keepers/DB tree =====

pgkeeper3 (master)
├─pgkeeper2
└─pgkeeper1

ਅਸੀਂ ਬਾਹਰੋਂ ਕੰਟੇਨਰਾਂ ਤੱਕ ਪਹੁੰਚ ਖੋਲ੍ਹਣ ਲਈ ਟ੍ਰੈਫਿਕ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦੇ ਹਾਂ:

03traefik.yml

version: '3.7'

services:
  traefik:
    image: traefik:latest
    command: >
      --log.level=INFO
      --providers.docker=true
      --entryPoints.web.address=:80
      --providers.providersThrottleDuration=2
      --providers.docker.watch=true
      --providers.docker.swarmMode=true
      --providers.docker.swarmModeRefreshSeconds=15s
      --providers.docker.exposedbydefault=false
      --accessLog.bufferingSize=0
      --api=true
      --api.dashboard=true
      --api.insecure=true
    networks:
      - traefik
    ports:
      - 80:80
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      replicas: 3
      placement:
        constraints:
          - node.role == manager
        preferences:
          - spread: node.id
      labels:
        - traefik.enable=true
        - traefik.http.routers.traefik.rule=Host(`traefik.example.com`)
        - traefik.http.services.traefik.loadbalancer.server.port=8080
        - traefik.docker.network=traefik

networks:
  traefik:
    external: true

# docker stack deploy --compose-file 03traefik.yml traefik

ਅਸੀਂ Redis ਕਲੱਸਟਰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ, ਅਜਿਹਾ ਕਰਨ ਲਈ ਅਸੀਂ ਸਾਰੇ ਨੋਡਾਂ 'ਤੇ ਸਟੋਰੇਜ ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਂਦੇ ਹਾਂ:

# mkdir -p /srv/redis

05redis.yml

version: '3.7'

services:
  redis-master:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '6379:6379'
    environment:
      - REDIS_REPLICATION_MODE=master
      - REDIS_PASSWORD=xxxxxxxxxxx
    deploy:
      mode: global
      restart_policy:
        condition: any
    volumes:
      - 'redis:/opt/bitnami/redis/etc/'

  redis-replica:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '6379'
    depends_on:
      - redis-master
    environment:
      - REDIS_REPLICATION_MODE=slave
      - REDIS_MASTER_HOST=redis-master
      - REDIS_MASTER_PORT_NUMBER=6379
      - REDIS_MASTER_PASSWORD=xxxxxxxxxxx
      - REDIS_PASSWORD=xxxxxxxxxxx
    deploy:
      mode: replicated
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: any

  redis-sentinel:
    image: 'bitnami/redis:latest'
    networks:
      - redis
    ports:
      - '16379'
    depends_on:
      - redis-master
      - redis-replica
    entrypoint: |
      bash -c 'bash -s <<EOF
      "/bin/bash" -c "cat <<EOF > /opt/bitnami/redis/etc/sentinel.conf
      port 16379
      dir /tmp
      sentinel monitor master-node redis-master 6379 2
      sentinel down-after-milliseconds master-node 5000
      sentinel parallel-syncs master-node 1
      sentinel failover-timeout master-node 5000
      sentinel auth-pass master-node xxxxxxxxxxx
      sentinel announce-ip redis-sentinel
      sentinel announce-port 16379
      EOF"
      "/bin/bash" -c "redis-sentinel /opt/bitnami/redis/etc/sentinel.conf"
      EOF'
    deploy:
      mode: global
      restart_policy:
        condition: any

volumes:
  redis:
    driver: local
    driver_opts:
      type: 'none'
      o: 'bind'
      device: "/srv/redis"

networks:
  redis:
    external: true

# docker stack deploy --compose-file 05redis.yml redis

ਡੌਕਰ ਰਜਿਸਟਰੀ ਸ਼ਾਮਲ ਕਰੋ:

06registry.yml

version: '3.7'

services:
  registry:
    image: registry:2.6
    networks:
      - traefik
    volumes:
      - registry_data:/var/lib/registry
    deploy:
      replicas: 1
      placement:
        constraints: [node.role == manager]
      restart_policy:
        condition: on-failure
      labels:
        - traefik.enable=true
        - traefik.http.routers.registry.rule=Host(`registry.example.com`)
        - traefik.http.services.registry.loadbalancer.server.port=5000
        - traefik.docker.network=traefik

volumes:
  registry_data:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/docker/registry"

networks:
  traefik:
    external: true

# mkdir /srv/docker/registry
# docker stack deploy --compose-file 06registry.yml registry

ਅਤੇ ਅੰਤ ਵਿੱਚ - GitLab:

08gitlab-runner.yml

version: '3.7'

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    networks:
      - pgsql
      - redis
      - traefik
      - gitlab
    ports:
      - 22222:22
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        postgresql['enable'] = false
        redis['enable'] = false
        gitlab_rails['registry_enabled'] = false
        gitlab_rails['db_username'] = "gitlab"
        gitlab_rails['db_password'] = "XXXXXXXXXXX"
        gitlab_rails['db_host'] = "postgresql"
        gitlab_rails['db_port'] = "5432"
        gitlab_rails['db_database'] = "gitlab"
        gitlab_rails['db_adapter'] = 'postgresql'
        gitlab_rails['db_encoding'] = 'utf8'
        gitlab_rails['redis_host'] = 'redis-master'
        gitlab_rails['redis_port'] = '6379'
        gitlab_rails['redis_password'] = 'xxxxxxxxxxx'
        gitlab_rails['smtp_enable'] = true
        gitlab_rails['smtp_address'] = "smtp.yandex.ru"
        gitlab_rails['smtp_port'] = 465
        gitlab_rails['smtp_user_name'] = "[email protected]"
        gitlab_rails['smtp_password'] = "xxxxxxxxx"
        gitlab_rails['smtp_domain'] = "example.com"
        gitlab_rails['gitlab_email_from'] = '[email protected]'
        gitlab_rails['smtp_authentication'] = "login"
        gitlab_rails['smtp_tls'] = true
        gitlab_rails['smtp_enable_starttls_auto'] = true
        gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
        external_url 'http://gitlab.example.com/'
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    volumes:
      - gitlab_conf:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
        - node.role == manager
      labels:
        - traefik.enable=true
        - traefik.http.routers.gitlab.rule=Host(`gitlab.example.com`)
        - traefik.http.services.gitlab.loadbalancer.server.port=80
        - traefik.docker.network=traefik
  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    networks:
      - gitlab
    volumes:
      - gitlab_runner_conf:/etc/gitlab
      - /var/run/docker.sock:/var/run/docker.sock
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
        - node.role == manager

volumes:
  gitlab_conf:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/docker/gitlab/conf"
  gitlab_logs:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/docker/gitlab/logs"
  gitlab_data:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/docker/gitlab/data"
  gitlab_runner_conf:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: "/srv/docker/gitlab/runner"

networks:
  pgsql:
    external: true
  redis:
    external: true
  traefik:
    external: true
  gitlab:
    external: true

# mkdir -p /srv/docker/gitlab/conf
# mkdir -p /srv/docker/gitlab/logs
# mkdir -p /srv/docker/gitlab/data
# mkdir -p /srv/docker/gitlab/runner
# docker stack deploy --compose-file 08gitlab-runner.yml gitlab

ਕਲੱਸਟਰ ਅਤੇ ਸੇਵਾਵਾਂ ਦੀ ਅੰਤਮ ਸਥਿਤੀ:

# docker service ls
ID                  NAME                   MODE                REPLICAS            IMAGE                          PORTS
lef9n3m92buq        etcd_etcd1             replicated          1/1                 quay.io/coreos/etcd:latest
ij6uyyo792x5        etcd_etcd2             replicated          1/1                 quay.io/coreos/etcd:latest
fqttqpjgp6pp        etcd_etcd3             replicated          1/1                 quay.io/coreos/etcd:latest
hq5iyga28w33        gitlab_gitlab          replicated          1/1                 gitlab/gitlab-ce:latest        *:22222->22/tcp
dt7s6vs0q4qc        gitlab_gitlab-runner   replicated          1/1                 gitlab/gitlab-runner:latest
k7uoezno0h9n        pgsql_pgkeeper1        replicated          1/1                 sorintlab/stolon:master-pg10
cnrwul4r4nse        pgsql_pgkeeper2        replicated          1/1                 sorintlab/stolon:master-pg10
frflfnpty7tr        pgsql_pgkeeper3        replicated          1/1                 sorintlab/stolon:master-pg10
x7pqqchi52kq        pgsql_pgsentinel       replicated          3/3                 sorintlab/stolon:master-pg10
mwu2wl8fti4r        pgsql_postgresql       replicated          3/3                 sorintlab/stolon:master-pg10
9hkbe2vksbzb        redis_redis-master     global              3/3                 bitnami/redis:latest           *:6379->6379/tcp
l88zn8cla7dc        redis_redis-replica    replicated          3/3                 bitnami/redis:latest           *:30003->6379/tcp
1utp309xfmsy        redis_redis-sentinel   global              3/3                 bitnami/redis:latest           *:30002->16379/tcp
oteb824ylhyp        registry_registry      replicated          1/1                 registry:2.6
qovrah8nzzu8        traefik_traefik        replicated          3/3                 traefik:latest                 *:80->80/tcp, *:443->443/tcp

ਹੋਰ ਕੀ ਸੁਧਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ? https ਉੱਤੇ ਕੰਟੇਨਰ ਚਲਾਉਣ ਲਈ Traefik ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ, Postgresql ਅਤੇ Redis ਲਈ tls ਐਨਕ੍ਰਿਪਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ। ਪਰ ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਪਹਿਲਾਂ ਹੀ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਪੀਓਸੀ ਦੇ ਤੌਰ 'ਤੇ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਆਓ ਹੁਣ ਡੌਕਰ ਦੇ ਵਿਕਲਪਾਂ ਨੂੰ ਵੇਖੀਏ.

ਪੋਡਮੈਨ

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

ਪੋਡਮੈਨ ਨਾਲ ਕੰਮ ਕਰਨਾ ਆਮ ਤੌਰ 'ਤੇ ਡੌਕਰ ਲਈ ਉਸ ਦੀ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ, ਇਸ ਬਿੰਦੂ ਤੱਕ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਦੁਆਰਾ ਕਿਹਾ ਗਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਨੇ ਇਸ ਲੇਖ ਦੇ ਲੇਖਕ ਸਮੇਤ ਇਸਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ):

$ alias docker=podman

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

ਸੈਟਿੰਗ

Centos 7 'ਤੇ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਸਿਰਫ਼ ਐਕਸਟਰਾ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਰਗਰਮ ਕਰੋ, ਅਤੇ ਫਿਰ ਕਮਾਂਡ ਨਾਲ ਸਭ ਕੁਝ ਸਥਾਪਿਤ ਕਰੋ:

# yum -y install podman

ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

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

ਪੋਡਮੈਨ ਨਾਲ ਕੰਮ ਕਰਨਾ

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

ਪੌਡਮੈਨ-ਕੰਪੋਜ਼ ਸਥਾਪਿਤ ਕਰੋ:

# yum -y install python3-pip
# pip3 install podman-compose

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

gitlab-podman.yml

version: '3.7'

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    hostname: gitlab.example.com
    restart: unless-stopped
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    ports:
      - "80:80"
      - "22222:22"
    volumes:
      - /srv/podman/gitlab/conf:/etc/gitlab
      - /srv/podman/gitlab/data:/var/opt/gitlab
      - /srv/podman/gitlab/logs:/var/log/gitlab
    networks:
      - gitlab

  gitlab-runner:
    image: gitlab/gitlab-runner:alpine
    restart: unless-stopped
    depends_on:
      - gitlab
    volumes:
      - /srv/podman/gitlab/runner:/etc/gitlab-runner
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - gitlab

networks:
  gitlab:

# podman-compose -f gitlab-runner.yml -d up

ਨਤੀਜਾ:

# podman ps
CONTAINER ID  IMAGE                                  COMMAND               CREATED             STATUS                 PORTS                                      NAMES
da53da946c01  docker.io/gitlab/gitlab-runner:alpine  run --user=gitlab...  About a minute ago  Up About a minute ago  0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp  root_gitlab-runner_1
781c0103c94a  docker.io/gitlab/gitlab-ce:latest      /assets/wrapper       About a minute ago  Up About a minute ago  0.0.0.0:22222->22/tcp, 0.0.0.0:80->80/tcp  root_gitlab_1

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

# podman pod ls
POD ID         NAME   STATUS    CREATED          # OF CONTAINERS   INFRA ID
71fc2b2a5c63   root   Running   11 minutes ago   3                 db40ab8bf84b

ਕੁਬਰਨੇਟਸ:

# podman generate kube 71fc2b2a5c63
# Generation of Kubernetes YAML is still under development!
#
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-1.6.4
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: "2020-07-29T19:22:40Z"
  labels:
    app: root
  name: root
spec:
  containers:
  - command:
    - /assets/wrapper
    env:
    - name: PATH
      value: /opt/gitlab/embedded/bin:/opt/gitlab/bin:/assets:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    - name: TERM
      value: xterm
    - name: HOSTNAME
      value: gitlab.example.com
    - name: container
      value: podman
    - name: GITLAB_OMNIBUS_CONFIG
      value: |
        gitlab_rails['gitlab_shell_ssh_port'] = 22222
    - name: LANG
      value: C.UTF-8
    image: docker.io/gitlab/gitlab-ce:latest
    name: rootgitlab1
    ports:
    - containerPort: 22
      hostPort: 22222
      protocol: TCP
    - containerPort: 80
      hostPort: 80
      protocol: TCP
    resources: {}
    securityContext:
      allowPrivilegeEscalation: true
      capabilities: {}
      privileged: false
      readOnlyRootFilesystem: false
    volumeMounts:
    - mountPath: /var/opt/gitlab
      name: srv-podman-gitlab-data
    - mountPath: /var/log/gitlab
      name: srv-podman-gitlab-logs
    - mountPath: /etc/gitlab
      name: srv-podman-gitlab-conf
    workingDir: /
  - command:
    - run
    - --user=gitlab-runner
    - --working-directory=/home/gitlab-runner
    env:
    - name: PATH
      value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    - name: TERM
      value: xterm
    - name: HOSTNAME
    - name: container
      value: podman
    image: docker.io/gitlab/gitlab-runner:alpine
    name: rootgitlab-runner1
    resources: {}
    securityContext:
      allowPrivilegeEscalation: true
      capabilities: {}
      privileged: false
      readOnlyRootFilesystem: false
    volumeMounts:
    - mountPath: /etc/gitlab-runner
      name: srv-podman-gitlab-runner
    - mountPath: /var/run/docker.sock
      name: var-run-docker.sock
    workingDir: /
  volumes:
  - hostPath:
      path: /srv/podman/gitlab/runner
      type: Directory
    name: srv-podman-gitlab-runner
  - hostPath:
      path: /var/run/docker.sock
      type: File
    name: var-run-docker.sock
  - hostPath:
      path: /srv/podman/gitlab/data
      type: Directory
    name: srv-podman-gitlab-data
  - hostPath:
      path: /srv/podman/gitlab/logs
      type: Directory
    name: srv-podman-gitlab-logs
  - hostPath:
      path: /srv/podman/gitlab/conf
      type: Directory
    name: srv-podman-gitlab-conf
status: {}

ਸਿਸਟਮਡ:

# podman generate systemd 71fc2b2a5c63
# pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
Documentation=man:podman-generate-systemd(1)
Requires=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Before=container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
ExecStop=/usr/bin/podman stop -t 10 db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/db40ab8bf84bf35141159c26cb6e256b889c7a98c0418eee3c4aa683c14fccaa/userdata/conmon.pid

[Install]
WantedBy=multi-user.target
# container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman container-da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
ExecStop=/usr/bin/podman stop -t 10 da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/da53da946c01449f500aa5296d9ea6376f751948b17ca164df438b7df6607864/userdata/conmon.pid

[Install]
WantedBy=multi-user.target
# container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
# autogenerated by Podman 1.6.4
# Thu Jul 29 15:23:28 EDT 2020

[Unit]
Description=Podman container-781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3.service
Documentation=man:podman-generate-systemd(1)
RefuseManualStart=yes
RefuseManualStop=yes
BindsTo=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service
After=pod-71fc2b2a5c6346f0c1c86a2dc45dbe78fa192ea02aac001eb8347ccb8c043c26.service

[Service]
Restart=on-failure
ExecStart=/usr/bin/podman start 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
ExecStop=/usr/bin/podman stop -t 10 781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3
KillMode=none
Type=forking
PIDFile=/var/run/containers/storage/overlay-containers/781c0103c94aaa113c17c58d05ddabf8df4bf39707b664abcf17ed2ceff467d3/userdata/conmon.pid

[Install]
WantedBy=multi-user.target

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

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

ਆਰ ਕੇ ਟੀ

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

ਪਲਾਸ

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

ਸਿੱਟਾ

ਕੁਬਰਨੇਟਸ ਦੀ ਸਥਿਤੀ ਬਹੁਤ ਦਿਲਚਸਪ ਹੈ: ਇੱਕ ਪਾਸੇ, ਡੌਕਰ ਨਾਲ ਤੁਸੀਂ ਇੱਕ ਕਲੱਸਟਰ ਬਣਾ ਸਕਦੇ ਹੋ (ਸਵਾਰਮ ਮੋਡ ਵਿੱਚ), ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਗਾਹਕਾਂ ਲਈ ਉਤਪਾਦ ਵਾਤਾਵਰਣ ਵੀ ਚਲਾ ਸਕਦੇ ਹੋ, ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਛੋਟੀਆਂ ਟੀਮਾਂ (3-5 ਲੋਕ) ਲਈ ਸੱਚ ਹੈ। , ਜਾਂ ਇੱਕ ਛੋਟੇ ਸਮੁੱਚੇ ਲੋਡ ਦੇ ਨਾਲ, ਜਾਂ ਕੁਬਰਨੇਟਸ ਸਥਾਪਤ ਕਰਨ ਦੀਆਂ ਪੇਚੀਦਗੀਆਂ ਨੂੰ ਸਮਝਣ ਦੀ ਇੱਛਾ ਦੀ ਘਾਟ, ਜਿਸ ਵਿੱਚ ਉੱਚ ਲੋਡ ਸ਼ਾਮਲ ਹਨ।

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

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

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

ਰਿਲੀਜ਼ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਵ-ਆਰਡਰ ਦੀ ਕੀਮਤ: 5000 ਰੂਬਲ। ਤੁਸੀਂ ਡੌਕਰ ਵੀਡੀਓ ਕੋਰਸ ਪ੍ਰੋਗਰਾਮ ਦੇਖ ਸਕਦੇ ਹੋ ਕੋਰਸ ਪੰਨੇ 'ਤੇ.

ਸਰੋਤ: www.habr.com