🥇 ਕੁਬਰਨੇਟਸ ਦਾ ਵਿਸਤਾਰ ਅਤੇ ਪੂਰਕ (ਸਮੀਖਿਆ ਅਤੇ ਵੀਡੀਓ ਰਿਪੋਰਟ)

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

ਪਰੰਪਰਾ ਦੁਆਰਾ, ਅਸੀਂ ਪੇਸ਼ ਕਰਨ ਲਈ ਖੁਸ਼ ਹਾਂ ਰਿਪੋਰਟ ਦੀ ਵੀਡੀਓ (50 ਮਿੰਟ, ਲੇਖ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਭਰਪੂਰ) ਅਤੇ ਪਾਠ ਰੂਪ ਵਿੱਚ ਮੁੱਖ ਸੰਖੇਪ। ਜਾਣਾ!

K8s ਵਿੱਚ ਕੋਰ ਅਤੇ ਜੋੜ

ਕੁਬਰਨੇਟਸ ਉਦਯੋਗ ਨੂੰ ਬਦਲ ਰਿਹਾ ਹੈ ਅਤੇ ਪ੍ਰਸ਼ਾਸਨ ਲਈ ਪਹੁੰਚ ਜੋ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਸਥਾਪਿਤ ਹਨ:

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

ਹਾਲਾਂਕਿ, ਬੇਸ਼ਕ, ਸਭ ਕੁਝ ਇੰਨਾ ਨਿਰਵਿਘਨ ਨਹੀਂ ਹੈ: ਕੁਬਰਨੇਟਸ ਨੇ ਆਪਣੀਆਂ ਨਵੀਆਂ ਚੁਣੌਤੀਆਂ ਵੀ ਲਿਆਂਦੀਆਂ ਹਨ.

ਕਬਰਨੇਟਿਸ ਨਾ ਇੱਕ ਕੰਬਾਈਨ ਹੈ ਜੋ ਸਾਰੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦੀ ਹੈ. ਕੋਰ ਕੁਬਰਨੇਟਸ ਸਿਰਫ ਘੱਟੋ-ਘੱਟ ਲੋੜੀਂਦੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਇੱਕ ਸੈੱਟ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ ਜੋ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਹਰ ਕਲੱਸਟਰ:

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

ਦੂਜੇ ਪਾਸੇ, K8s ਉਪਲਬਧ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਧਾਉਣ ਦੇ ਬਹੁਤ ਵਧੀਆ ਮੌਕੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਦੂਜਿਆਂ ਨੂੰ ਬੰਦ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ - ਖਾਸ - ਉਪਭੋਗਤਾ ਦੀਆਂ ਲੋੜਾਂ. ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਜੋੜਨਾ ਕਲੱਸਟਰ ਪ੍ਰਸ਼ਾਸਕਾਂ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਆਪਣੇ ਕਲੱਸਟਰ ਨੂੰ "ਸਹੀ ਆਕਾਰ ਵਿੱਚ" [ਉਨ੍ਹਾਂ ਦੀਆਂ ਖਾਸ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ] ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਸੰਰਚਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਕਿਹੋ ਜਿਹੇ ਜੋੜ ਹਨ? ਆਓ ਕੁਝ ਉਦਾਹਰਣਾਂ ਵੱਲ ਧਿਆਨ ਦੇਈਏ।

ਐਡ-ਆਨ ਦੀਆਂ ਉਦਾਹਰਨਾਂ

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

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

ਹੋਰ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

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

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

ਆਟੋਮੇਸ਼ਨ

ਆਪਰੇਟਰ ਰੁਟੀਨ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਅਸੀਂ ਹਰ ਰੋਜ਼ ਸਾਹਮਣਾ ਕਰਦੇ ਹਾਂ। ਇੱਥੇ ਅਸਲ-ਜੀਵਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਲਈ ਇੱਕ ਓਪਰੇਟਰ ਲਿਖਣਾ ਇੱਕ ਵਧੀਆ ਹੱਲ ਹੋਵੇਗਾ:

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

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

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

ਕੁਬਰਨੇਟਸ ਲਈ ਬਿਆਨ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ?

ਆਮ ਤੌਰ 'ਤੇ, ਸਕੀਮ ਸਧਾਰਨ ਹੈ:

... ਪਰ ਫਿਰ ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ:

ਕੁਬਰਨੇਟਸ API ਇੱਕ ਗੈਰ-ਮਾਮੂਲੀ ਚੀਜ਼ ਹੈ ਜਿਸ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲੱਗਦਾ ਹੈ;
ਪ੍ਰੋਗਰਾਮਿੰਗ ਵੀ ਹਰ ਕਿਸੇ ਲਈ ਨਹੀਂ ਹੈ (ਗੋ ਭਾਸ਼ਾ ਨੂੰ ਤਰਜੀਹੀ ਭਾਸ਼ਾ ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ ਕਿਉਂਕਿ ਇਸਦੇ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਢਾਂਚਾ ਹੈ - ਓਪਰੇਟਰ SDK);
ਸਥਿਤੀ ਫਰੇਮਵਰਕ ਦੇ ਨਾਲ ਵੀ ਸਮਾਨ ਹੈ.

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

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

ਸ਼ੈੱਲ-ਓਪਰੇਟਰ

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

ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਨੂੰ ਕਿਵੇਂ ਪਤਾ ਲੱਗ ਜਾਂਦਾ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਘਟਨਾਵਾਂ 'ਤੇ ਕਿਸ ਹੁੱਕ ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੈ? ਇਹ ਜਾਣਕਾਰੀ ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਨੂੰ ਹੁੱਕਾਂ ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਪ੍ਰਸਾਰਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਉਹ ਇਸਨੂੰ ਬਹੁਤ ਹੀ ਅਸਾਨੀ ਨਾਲ ਕਰਦੇ ਹਨ।

ਇੱਕ ਹੁੱਕ ਇੱਕ Bash ਸਕ੍ਰਿਪਟ ਜਾਂ ਕੋਈ ਹੋਰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਹੈ ਜੋ ਇੱਕ ਸਿੰਗਲ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ --config ਅਤੇ JSON ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਬਾਅਦ ਵਾਲਾ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਵਸਤੂਆਂ ਇਸ ਵਿੱਚ ਦਿਲਚਸਪੀ ਵਾਲੀਆਂ ਹਨ ਅਤੇ ਕਿਹੜੀਆਂ ਘਟਨਾਵਾਂ (ਇਨ੍ਹਾਂ ਵਸਤੂਆਂ ਲਈ) ਨੂੰ ਜਵਾਬ ਦਿੱਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ:

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

ਅਭਿਆਸ: 1. ਇੱਕ ਹੁੱਕ ਲਿਖੋ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਹੁੱਕ ਵਿੱਚ ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਕਰਾਂਗੇ --config, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਨਾਮ-ਸਥਾਨਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ, ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ, ਉਹਨਾਂ ਦੀ ਰਚਨਾ ਦੇ ਪਲ:

[[ $1 == "--config" ]] ; then
  cat << EOF
{
  "onKubernetesEvent": [
    {
      "kind": "namespace",
      "event": ["add"]
    }
  ]
}
EOF
…

ਤਰਕ ਕਿਸ ਤਰ੍ਹਾਂ ਦਾ ਦਿਖਾਈ ਦੇਵੇਗਾ? ਇਹ ਵੀ ਕਾਫ਼ੀ ਸਧਾਰਨ:

…
else
  createdNamespace=$(jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH)
  kubectl create -n ${createdNamespace} -f - << EOF
Kind: Secret
...
EOF
fi

ਪਹਿਲਾ ਕਦਮ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਹੈ ਕਿ ਕਿਹੜੀ ਨੇਮਸਪੇਸ ਬਣਾਈ ਗਈ ਸੀ, ਅਤੇ ਦੂਜਾ ਇਸਨੂੰ ਵਰਤ ਕੇ ਬਣਾਉਣਾ ਹੈ kubectl ਇਸ ਨੇਮਸਪੇਸ ਲਈ ਗੁਪਤ.

ਅਭਿਆਸ: 2. ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ

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

FROM flant/shell-operator:v1.0.0-beta.1
ADD my-handler.sh /hooks

ਇਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਅਤੇ ਧੱਕਣਾ ਬਾਕੀ ਹੈ:

$ docker build -t registry.example.com/my-operator:v1 .
$ docker push registry.example.com/my-operator:v1

ਅੰਤਮ ਛੋਹ ਚਿੱਤਰ ਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ ਤੈਨਾਤ ਕਰਨਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਆਓ ਲਿਖਦੇ ਹਾਂ ਡਿਪਲੋਮੇਟ:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-operator
spec:
  template:
    spec:
      containers:
      - name: my-operator
        image: registry.example.com/my-operator:v1 # 1
      serviceAccountName: my-operator              # 2

ਧਿਆਨ ਦੇਣ ਲਈ ਦੋ ਨੁਕਤੇ ਹਨ:

ਨਵੇਂ ਬਣਾਏ ਚਿੱਤਰ ਦਾ ਸੰਕੇਤ;
ਇਹ ਇੱਕ ਸਿਸਟਮ ਕੰਪੋਨੈਂਟ ਹੈ ਜਿਸਨੂੰ (ਘੱਟੋ-ਘੱਟ) ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਇਵੈਂਟਾਂ ਦੀ ਗਾਹਕੀ ਲੈਣ ਅਤੇ ਨਾਮ-ਸਥਾਨਾਂ ਲਈ ਰਾਜ਼ ਅਲਾਟ ਕਰਨ ਲਈ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਹੁੱਕ ਲਈ ਇੱਕ ServiceAccount (ਅਤੇ ਨਿਯਮਾਂ ਦਾ ਇੱਕ ਸੈੱਟ) ਬਣਾਉਂਦੇ ਹਾਂ।

ਨਤੀਜਾ - ਅਸੀਂ ਆਪਣੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਕੀਤਾ ਰਿਸ਼ਤੇਦਾਰ ਕੁਬਰਨੇਟਸ ਲਈ ਇਸ ਤਰੀਕੇ ਨਾਲ ਜੋ ਰਹੱਸਾਂ ਨੂੰ ਸੜਨ ਲਈ ਇੱਕ ਆਪਰੇਟਰ ਬਣਾਉਂਦਾ ਹੈ।

ਹੋਰ ਸ਼ੈੱਲ-ਆਪਰੇਟਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

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

"onKubernetesEvent": [
  {
    "selector": {
      "matchLabels": {
        "foo": "bar",
       },
       "matchExpressions": [
         {
           "key": "allow",
           "operation": "In",
           "values": ["wan", "warehouse"],
         },
       ],
     }
     …
  }
]

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

ਜਦੋਂ ਇੱਕ ਹੁੱਕ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਇਸਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ ਵਸਤੂ ਡਾਟਾ, ਜੋ ਕਿਸੇ ਵੀ ਲੋੜ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.

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

ਅਤੇ ਸ਼ੈੱਲ-ਆਪਰੇਟਰ ਦੀਆਂ ਦੋ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ:

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

ਰਿਪੋਰਟ ਦੇ ਇਸ ਹਿੱਸੇ ਨੂੰ ਸੰਖੇਪ ਕਰਨ ਲਈ:

ਐਡ-ਆਨ ਇੰਸਟਾਲ ਕਰੋ

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

ਅਸੀਂ ਕੁਬਰਨੇਟਸ ਦੇ ਨਾਲ ਕਈ ਕਲੱਸਟਰਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕੀਤਾ, ਜਿਸ ਵਿੱਚ ਇੱਕੋ ਇੱਕ ਵਾਧਾ ਸੀ Ingress। ਇਸਨੂੰ ਹਰੇਕ ਕਲੱਸਟਰ ਵਿੱਚ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਸੀ, ਅਤੇ ਅਸੀਂ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਲਈ ਕਈ YAML ਸੰਰਚਨਾਵਾਂ ਕੀਤੀਆਂ: ਬੇਅਰ ਮੈਟਲ, AWS...

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

ਹਰ ਚੀਜ਼ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਰੱਖਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਸਕ੍ਰਿਪਟ (install-ingress.sh), ਜਿਸ ਨੇ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਕਲੱਸਟਰ ਦੀ ਕਿਸਮ ਨੂੰ ਲਿਆ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਤੈਨਾਤ ਕਰਾਂਗੇ, ਲੋੜੀਂਦੀ YAML ਸੰਰਚਨਾ ਤਿਆਰ ਕੀਤੀ ਅਤੇ ਇਸਨੂੰ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਰੋਲ ਆਊਟ ਕੀਤਾ।

ਸੰਖੇਪ ਵਿੱਚ, ਸਾਡਾ ਅਗਲਾ ਮਾਰਗ ਅਤੇ ਇਸ ਨਾਲ ਜੁੜੇ ਤਰਕ ਇਸ ਪ੍ਰਕਾਰ ਸਨ:

YAML ਸੰਰਚਨਾਵਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਇੱਕ ਟੈਂਪਲੇਟ ਇੰਜਣ ਦੀ ਲੋੜ ਹੈ (ਪਹਿਲੇ ਪੜਾਅ 'ਤੇ ਇਹ ਸਧਾਰਨ sed ਹੈ);
ਕਲੱਸਟਰਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਵਾਧੇ ਦੇ ਨਾਲ, ਆਟੋਮੈਟਿਕ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਲੋੜ ਆਈ (ਸਭ ਤੋਂ ਪਹਿਲਾ ਹੱਲ ਇਹ ਸੀ ਕਿ ਸਕ੍ਰਿਪਟ ਨੂੰ ਗਿੱਟ ਵਿੱਚ ਪਾਓ, ਇਸਨੂੰ ਕ੍ਰੋਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਪਡੇਟ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਚਲਾਓ);
ਪ੍ਰੋਮੀਥੀਅਸ ਲਈ ਇੱਕ ਸਮਾਨ ਲਿਪੀ ਦੀ ਲੋੜ ਸੀ (install-prometheus.sh), ਹਾਲਾਂਕਿ, ਇਹ ਇਸ ਤੱਥ ਲਈ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਇਸ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਇਨਪੁਟ ਡੇਟਾ ਦੀ ਲੋੜ ਹੈ, ਨਾਲ ਹੀ ਉਹਨਾਂ ਦੀ ਸਟੋਰੇਜ (ਚੰਗੇ ਤਰੀਕੇ ਨਾਲ - ਕੇਂਦਰੀਕ੍ਰਿਤ ਅਤੇ ਇੱਕ ਕਲੱਸਟਰ ਵਿੱਚ), ਅਤੇ ਕੁਝ ਡੇਟਾ (ਪਾਸਵਰਡ) ਆਪਣੇ ਆਪ ਤਿਆਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ:
ਕਲੱਸਟਰਾਂ ਦੀ ਵਧਦੀ ਗਿਣਤੀ ਵਿੱਚ ਕੁਝ ਗਲਤ ਹੋਣ ਦਾ ਜੋਖਮ ਲਗਾਤਾਰ ਵੱਧ ਰਿਹਾ ਸੀ, ਇਸਲਈ ਸਾਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਇੰਸਟਾਲਰ (ਅਰਥਾਤ ਦੋ ਲਿਪੀਆਂ: ਪ੍ਰਵੇਸ਼ ਅਤੇ ਪ੍ਰੋਮੀਥੀਅਸ ਲਈ) ਸਟੇਜਿੰਗ ਦੀ ਲੋੜ ਸੀ (ਗਿੱਟ ਵਿੱਚ ਕਈ ਸ਼ਾਖਾਵਾਂ, ਉਹਨਾਂ ਨੂੰ ਅਨੁਸਾਰੀ ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਕਈ ਕ੍ਰੋਨ: ਸਥਿਰ ਜਾਂ ਟੈਸਟ ਕਲੱਸਟਰ);
с kubectl apply ਇਸ ਨਾਲ ਕੰਮ ਕਰਨਾ ਔਖਾ ਹੋ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਇਹ ਘੋਸ਼ਣਾਤਮਕ ਨਹੀਂ ਹੈ ਅਤੇ ਸਿਰਫ਼ ਵਸਤੂਆਂ ਬਣਾ ਸਕਦਾ ਹੈ, ਪਰ ਉਹਨਾਂ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਫੈਸਲੇ ਨਹੀਂ ਕਰ ਸਕਦਾ/ਉਨ੍ਹਾਂ ਨੂੰ ਮਿਟਾਉਣਾ;
ਅਸੀਂ ਕੁਝ ਫੰਕਸ਼ਨ ਗੁਆ ਰਹੇ ਸੀ ਜੋ ਅਸੀਂ ਉਸ ਸਮੇਂ ਲਾਗੂ ਨਹੀਂ ਕੀਤੇ ਸਨ:
- ਕਲੱਸਟਰ ਅੱਪਡੇਟ ਦੇ ਨਤੀਜੇ 'ਤੇ ਪੂਰਾ ਕੰਟਰੋਲ,
- ਕਲੱਸਟਰ (ਖੋਜ) ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾ ਸਕਣ ਵਾਲੇ ਡੇਟਾ ਦੇ ਅਧਾਰ ਤੇ ਕੁਝ ਮਾਪਦੰਡਾਂ (ਇੰਸਟਾਲੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇਨਪੁਟ) ਦਾ ਆਟੋਮੈਟਿਕ ਨਿਰਧਾਰਨ,
- ਨਿਰੰਤਰ ਖੋਜ ਦੇ ਰੂਪ ਵਿੱਚ ਇਸਦਾ ਤਰਕਪੂਰਨ ਵਿਕਾਸ।

ਅਸੀਂ ਆਪਣੇ ਦੂਜੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਫਰੇਮਵਰਕ ਦੇ ਅੰਦਰ ਇਸ ਸਾਰੇ ਇਕੱਠੇ ਕੀਤੇ ਅਨੁਭਵ ਨੂੰ ਲਾਗੂ ਕੀਤਾ - addon-operator.

ਐਡਨ-ਓਪਰੇਟਰ

ਇਹ ਪਹਿਲਾਂ ਹੀ ਜ਼ਿਕਰ ਕੀਤੇ ਸ਼ੈੱਲ-ਓਪਰੇਟਰ 'ਤੇ ਅਧਾਰਤ ਹੈ। ਸਾਰਾ ਸਿਸਟਮ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:

ਹੇਠਾਂ ਦਿੱਤੇ ਨੂੰ ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਹੁੱਕਾਂ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਹੈ:

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

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

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

ਹੁਣ, ਜਦੋਂ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਕੁਝ ਵਾਪਰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਗਲੋਬਲ ਹੁੱਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਗਲੋਬਲ ਸਟੋਰ ਵਿੱਚ ਕੁਝ ਬਦਲ ਸਕਦੇ ਹਾਂ। ਇਹ ਤਬਦੀਲੀ ਨੋਟ ਕੀਤੀ ਜਾਵੇਗੀ ਅਤੇ ਕਲੱਸਟਰ ਵਿੱਚ ਸਾਰੇ ਮੋਡੀਊਲ ਰੋਲਆਊਟ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣੇਗੀ:

ਇਹ ਸਕੀਮ ਐਡ-ਆਨ ਸਥਾਪਤ ਕਰਨ ਦੀਆਂ ਸਾਰੀਆਂ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੀ ਹੈ ਜੋ ਉੱਪਰ ਦੱਸੀਆਂ ਗਈਆਂ ਸਨ:

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

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

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

"Flant" ਵਰਤਦਾ ਹੈ addon-operator 70+ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰਾਂ 'ਤੇ। ਮੌਜੂਦਾ ਸਥਿਤੀ - ਅਲਫ਼ਾ ਸੰਸਕਰਣ. ਹੁਣ ਅਸੀਂ ਬੀਟਾ ਨੂੰ ਜਾਰੀ ਕਰਨ ਲਈ ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰ ਰਹੇ ਹਾਂ, ਪਰ ਹੁਣ ਲਈ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਉਦਾਹਰਨਾਂ ਉਪਲਬਧ ਹਨ, ਜਿਸ ਦੇ ਆਧਾਰ 'ਤੇ ਤੁਸੀਂ ਆਪਣਾ ਐਡਆਨ ਬਣਾ ਸਕਦੇ ਹੋ।

ਮੈਂ ਐਡ-ਆਨ-ਓਪਰੇਟਰ ਲਈ ਮੈਡਿਊਲ ਕਿੱਥੋਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹਾਂ? ਸਾਡੀ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ ਸਾਡੇ ਲਈ ਅਗਲਾ ਪੜਾਅ ਹੈ; ਅਸੀਂ ਇਸਨੂੰ ਗਰਮੀਆਂ ਵਿੱਚ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੇ ਹਾਂ।

ਵੀਡੀਓਜ਼ ਅਤੇ ਸਲਾਈਡਾਂ

ਪ੍ਰਦਰਸ਼ਨ ਤੋਂ ਵੀਡੀਓ (~50 ਮਿੰਟ):

ਰਿਪੋਰਟ ਦੀ ਪੇਸ਼ਕਾਰੀ:

PS

ਸਾਡੇ ਬਲੌਗ 'ਤੇ ਹੋਰ ਰਿਪੋਰਟਾਂ:

«ਡਾਟਾਬੇਸ ਅਤੇ ਕੁਬਰਨੇਟਸ"; (ਦਮਿਤਰੀ ਸਟੋਲਯਾਰੋਵ; ਹਾਈਲੋਡ++ 'ਤੇ 8 ਨਵੰਬਰ, 2018);
«ਨਿਗਰਾਨੀ ਅਤੇ ਕੁਬਰਨੇਟਸ"; (ਦਮਿਤਰੀ ਸਟੋਲਯਾਰੋਵ; ਰੂਟਕਾਨਫ 'ਤੇ 28 ਮਈ, 2018);
«ਕੁਬਰਨੇਟਸ ਅਤੇ ਗਿਟਲੈਬ ਦੇ ਨਾਲ CI/CD ਵਧੀਆ ਅਭਿਆਸ"; (ਦਮਿਤਰੀ ਸਟੋਲਯਾਰੋਵ; ਹਾਈਲੋਡ++ 'ਤੇ 7 ਨਵੰਬਰ, 2017);
«ਛੋਟੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਨਾਲ ਸਾਡਾ ਅਨੁਭਵ"; (ਦਮਿਤਰੀ ਸਟੋਲਯਾਰੋਵ; ਰੂਟਕਾਨਫ 'ਤੇ 6 ਜੂਨ, 2017).

ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਪ੍ਰਕਾਸ਼ਨਾਂ ਵਿੱਚ ਵੀ ਦਿਲਚਸਪੀ ਹੋ ਸਕਦੀ ਹੈ:

«ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਪੇਸ਼ ਕਰਨਾ: ਕੁਬਰਨੇਟਸ ਲਈ ਆਪਰੇਟਰ ਬਣਾਉਣਾ ਹੁਣੇ ਆਸਾਨ ਹੋ ਗਿਆ ਹੈ".

ਸਰੋਤ: www.habr.com

ਕੁਬਰਨੇਟਸ ਦਾ ਵਿਸਥਾਰ ਅਤੇ ਪੂਰਕ (ਸਮੀਖਿਆ ਅਤੇ ਵੀਡੀਓ ਰਿਪੋਰਟ)