ਕੁਬਰਨੇਟਸ ਲਈ ਆਪਰੇਟਰ: ਸਟੇਟਫੁੱਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ

ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਸਟੇਟਫੁੱਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨਾਲ ਸਮੱਸਿਆ

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

ਸਧਾਰਨ ਰੂਪ ਵਿੱਚ, ਕੰਟੇਨਰਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਵਿੱਚ PHP/ਰੂਬੀ/ਪਾਈਥਨ ਵਿੱਚ ਬੈਕਐਂਡ ਦੀਆਂ ਪੰਜ ਹੋਰ ਕਾਪੀਆਂ ਨੂੰ ਲਾਂਚ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸਿਰਫ ਇੱਕ ਨਵਾਂ ਸਰਵਰ 5 ਵਾਰ ਸੈਟ ਅਪ ਕਰਨ ਅਤੇ ਸਰੋਤਾਂ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਕਿਉਂਕਿ ਸਰੋਤ ਕੋਡ ਅਤੇ init ਸਕ੍ਰਿਪਟ ਦੋਵੇਂ ਚਿੱਤਰ ਵਿੱਚ ਹਨ, ਇੱਕ ਸਟੇਟਲੈੱਸ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਕੇਲ ਕਰਨਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮੁਢਲਾ ਬਣ ਜਾਂਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਕੰਟੇਨਰਾਂ ਅਤੇ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਆਰਕੀਟੈਕਚਰ ਦੇ ਪ੍ਰਸ਼ੰਸਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣਦੇ ਹਨ, ਮੁਸ਼ਕਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਸਟੇਟਫੁਲ ਐਪਸ, i.e. ਡੇਟਾਬੇਸ ਅਤੇ ਕੈਚ (MySQL, PostgreSQL, Redis, ElasticSearch, Cassandra...) ਵਰਗੇ ਡੇਟਾ ਸਥਿਰਤਾ ਦੇ ਨਾਲ. ਇਹ ਦੋਨਾਂ ਸਾਫਟਵੇਅਰਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ ਜੋ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਕੋਰਮ ਕਲੱਸਟਰ (ਉਦਾਹਰਨ ਲਈ, Percona XtraDB ਅਤੇ Cassandra) ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਾਫਟਵੇਅਰ ਜਿਸ ਲਈ ਵੱਖਰੀ ਪ੍ਰਬੰਧਨ ਉਪਯੋਗਤਾਵਾਂ (ਜਿਵੇਂ ਕਿ Redis, MySQL, PostgreSQL...) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

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

CoreOS ਆਪਰੇਟਰ

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

ਕੁਬਰਨੇਟਸ (ਸਮੇਤ. ਸਟੇਟਫੁੱਲ ਸੈੱਟ, ਹੇਠਾਂ ਫਰਕ ਦੇਖੋ) DevOps ਮਾਹਰਾਂ ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿੱਚ ਕਾਰਜਸ਼ੀਲ ਗਿਆਨ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ।

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

ਓਪਰੇਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

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

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

ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਸਭ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ? ਆਪਰੇਟਰ ਇੱਕ ਮੈਨੇਜਰ ਡੈਮਨ ਹੈ ਜੋ:

1. ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਈਵੈਂਟ API ਦੀ ਗਾਹਕੀ ਲੈਂਦਾ ਹੈ;
2. ਇਸ ਤੋਂ ਸਿਸਟਮ ਬਾਰੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ (ਇਸ ਦੇ ਬਾਰੇ ਰਿਪਲੀਕਾਸੈਟਸ, pods, ਸਰਵਿਸਿਜ਼ ਇਤਆਦਿ.);
3. ਬਾਰੇ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਤੀਜੀ ਧਿਰ ਦੇ ਸਰੋਤ (ਹੇਠਾਂ ਉਦਾਹਰਨਾਂ ਦੇਖੋ);
4. ਦਿੱਖ/ਪਰਿਵਰਤਨ ਪ੍ਰਤੀ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦਾ ਹੈ ਤੀਜੀ ਧਿਰ ਦੇ ਸਰੋਤ (ਉਦਾਹਰਣ ਲਈ, ਆਕਾਰ ਨੂੰ ਬਦਲਣ ਲਈ, ਸੰਸਕਰਣ ਬਦਲੋ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ);
5. ਸਿਸਟਮ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਪ੍ਰਤੀ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦਾ ਹੈ (ਇਸ ਦੇ ਬਾਰੇ ਰਿਪਲੀਕਾਸੈਟਸ, pods, ਸਰਵਿਸਿਜ਼ ਇਤਆਦਿ.);
6. ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ:
   1. ਕੁਬਰਨੇਟਸ API ਨੂੰ ਹਰ ਚੀਜ਼ ਬਣਾਉਣ ਲਈ ਕਾਲ ਕਰਦਾ ਹੈ (ਦੁਬਾਰਾ, ਇਸਦਾ ਆਪਣਾ ਰਿਪਲੀਕਾਸੈਟਸ, pods, ਸਰਵਿਸਿਜ਼...),
   2. ਕੁਝ ਜਾਦੂ ਕਰਦਾ ਹੈ (ਸਰਲ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ ਸੋਚ ਸਕਦੇ ਹੋ ਕਿ ਓਪਰੇਟਰ ਆਪਣੇ ਆਪ ਪੌਡਾਂ ਵਿੱਚ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਕਲੱਸਟਰ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਲਈ ਜਾਂ ਇੱਕ ਸੰਸਕਰਣ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਵੇਲੇ ਡੇਟਾ ਫਾਰਮੈਟ ਨੂੰ ਅੱਪਗਰੇਡ ਕਰਨਾ)।

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

ਇਸ ਤਰ੍ਹਾਂ, ਜਦੋਂ ਅਸੀਂ ਅੰਦਰ ਬਣਾਇਆ ਹੈ ਨਾਮਸਪੇਸ ਆਪਰੇਟਰ, ਅਸੀਂ ਇਸ ਵਿੱਚ ਜੋੜ ਸਕਦੇ ਹਾਂ ਤੀਜੀ ਧਿਰ ਦੇ ਸਰੋਤ.

ਆਦਿ ਲਈ ਉਦਾਹਰਨ (ਵੇਰਵਿਆਂ ਲਈ ਹੇਠਾਂ ਦੇਖੋ):

apiVersion: etcd.coreos.com/v1beta1
kind: Cluster
metadata:
  name: example-etcd-cluster
spec:
  size: 3
  version: 3.1.0

Elasticsearch ਲਈ ਉਦਾਹਰਨ:

apiVersion: enterprises.upmc.com/v1
kind: ElasticsearchCluster
metadata:
  name: example-es-cluster
spec:
  client-node-replicas: 3
  master-node-replicas: 2
  data-node-replicas: 3
  zones:
  - us-east-1c
  - us-east-1d
  - us-east-1e
  data-volume-size: 10Gi
  java-options: "-Xms1024m -Xmx1024m"
  snapshot:
    scheduler-enabled: true
    bucket-name: elasticsnapshots99
    cron-schedule: "@every 2m"
  storage:
    type: gp2
    storage-class-provisioner: kubernetes.io/aws-ebs

ਆਪਰੇਟਰਾਂ ਲਈ ਲੋੜਾਂ

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

1. ਇੰਸਟਾਲੇਸ਼ਨ ਇੱਕ ਸਿੰਗਲ ਦੁਆਰਾ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਡਿਪਲੋਮੇਟ: kubectl create -f SOME_OPERATOR_URL/deployment.yaml - ਅਤੇ ਵਾਧੂ ਕਾਰਵਾਈਆਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
2. Kubernetes ਵਿੱਚ ਇੱਕ ਓਪਰੇਟਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਸਮੇਂ, ਇੱਕ ਨਵੀਂ ਤੀਜੀ-ਧਿਰ ਦੀ ਕਿਸਮ ਬਣਾਈ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ (ThirdPartyResource). ਐਪਲੀਕੇਸ਼ਨ ਉਦਾਹਰਨਾਂ (ਕਲੱਸਟਰ ਉਦਾਹਰਨਾਂ) ਨੂੰ ਲਾਂਚ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੋਰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ (ਵਰਜਨ ਅੱਪਡੇਟ ਕਰਨਾ, ਮੁੜ ਆਕਾਰ ਦੇਣਾ, ਆਦਿ), ਉਪਭੋਗਤਾ ਇਸ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ।
3. ਜਦੋਂ ਵੀ ਸੰਭਵ ਹੋਵੇ, ਤੁਹਾਨੂੰ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਬਣਾਏ ਗਏ ਪ੍ਰਾਚੀਨ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਰਵਿਸਿਜ਼ и ਰਿਪਲੀਕਾਸੈਟਸਚੰਗੀ ਤਰ੍ਹਾਂ ਟੈਸਟ ਕੀਤੇ ਅਤੇ ਸਮਝਣ ਯੋਗ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ।
4. ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਬਣਾਏ ਸਰੋਤਾਂ ਦੇ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਲਈ ਓਪਰੇਟਰਾਂ ਦੀ ਪਛੜਵੀਂ ਅਨੁਕੂਲਤਾ ਅਤੇ ਸਮਰਥਨ ਦੀ ਲੋੜ ਹੈ।
5. ਜੇਕਰ ਆਪਰੇਟਰ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਅ ਦੇ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।
6. ਉਪਭੋਗਤਾ ਲੋੜੀਂਦੇ ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਅਪਡੇਟਾਂ ਨੂੰ ਆਰਕੈਸਟਰੇਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਸੌਫਟਵੇਅਰ ਅੱਪਡੇਟ ਦੀ ਘਾਟ ਸੰਚਾਲਨ ਅਤੇ ਸੁਰੱਖਿਆ ਸਮੱਸਿਆਵਾਂ ਦਾ ਇੱਕ ਆਮ ਸਰੋਤ ਹੈ, ਇਸਲਈ ਓਪਰੇਟਰਾਂ ਨੂੰ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਮਦਦ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
7. ਓਪਰੇਟਰਾਂ ਨੂੰ ਕੈਓਸ ਮੌਨਕੀ ਵਰਗੇ ਟੂਲ ਨਾਲ ਟੈਸਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਪੌਡਾਂ, ਸੰਰਚਨਾਵਾਂ ਅਤੇ ਨੈਟਵਰਕ ਵਿੱਚ ਸੰਭਾਵੀ ਅਸਫਲਤਾਵਾਂ ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ।

etcd ਆਪਰੇਟਰ

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

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

1. ਨਿਰੀਖਣ ਕਰੋ। ਆਪਰੇਟਰ ਕੁਬਰਨੇਟਸ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਲੱਸਟਰ ਦੀ ਸਥਿਤੀ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ।
2. ਵਿਸ਼ਲੇਸ਼ਣ. ਮੌਜੂਦਾ ਸਥਿਤੀ ਅਤੇ ਲੋੜੀਂਦੇ (ਉਪਭੋਗਤਾ ਸੰਰਚਨਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ) ਵਿਚਕਾਰ ਅੰਤਰ ਲੱਭਦਾ ਹੈ।
3. ਕਾਰਵਾਈ. etcd ਅਤੇ/ਜਾਂ Kubernetes ਸੇਵਾ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਖੋਜੇ ਗਏ ਅੰਤਰਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।

ਇਸ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਆਪਰੇਟਰ ਵਿੱਚ ਫੰਕਸ਼ਨ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ ਬਣਾਓ/ਨਸ਼ਟ ਕਰੋ (etcd ਕਲੱਸਟਰ ਮੈਂਬਰਾਂ ਨੂੰ ਬਣਾਉਣਾ ਅਤੇ ਮਿਟਾਉਣਾ) ਅਤੇ ਮੁੜ ਆਕਾਰ ਦਿਓ (ਕਲੱਸਟਰ ਮੈਂਬਰਾਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਤਬਦੀਲੀ)। ਨੈੱਟਫਲਿਕਸ ਤੋਂ ਕੈਓਸ ਬਾਂਦਰ ਦੀ ਸਮਾਨਤਾ ਵਿੱਚ ਬਣਾਈ ਗਈ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਦੇ ਸੰਚਾਲਨ ਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਸੀ, ਯਾਨੀ. ਬੇਤਰਤੀਬੇ etcd pods ਨੂੰ ਮਾਰਨਾ.

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

ਓਪਰੇਟਰ ਨਾਲ ਕੰਮ ਕਰਨਾ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ?

$ kubectl create -f https://coreos.com/operators/etcd/latest/deployment.yaml
$ kubectl create -f https://coreos.com/operators/etcd/latest/example-etcd-cluster.yaml
$ kubectl get pods
NAME                             READY     STATUS    RESTARTS   AGE
etcd-cluster-0000                1/1       Running   0          23s
etcd-cluster-0001                1/1       Running   0          16s
etcd-cluster-0002                1/1       Running   0          8s
etcd-cluster-backup-tool-rhygq   1/1       Running   0          18s

etcd ਆਪਰੇਟਰ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਇੱਕ ਬੀਟਾ ਸੰਸਕਰਣ ਹੈ, ਜਿਸਨੂੰ ਚਲਾਉਣ ਲਈ Kubernetes 1.5.3+ ਅਤੇ etcd 3.0+ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਸਰੋਤ ਕੋਡ ਅਤੇ ਦਸਤਾਵੇਜ਼ (ਵਰਤੋਂ ਲਈ ਨਿਰਦੇਸ਼ਾਂ ਸਮੇਤ) 'ਤੇ ਉਪਲਬਧ ਹਨ GitHub.

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

ਸਥਿਤੀ ਅਤੇ ਸੰਭਾਵਨਾਵਾਂ

ਕੁਬਰਨੇਟਸ ਆਪਰੇਟਰਾਂ ਦੇ ਐਲਾਨ ਤੋਂ 5 ਮਹੀਨੇ ਬੀਤ ਚੁੱਕੇ ਹਨ। ਅਧਿਕਾਰਤ CoreOS ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਅਜੇ ਵੀ ਸਿਰਫ ਦੋ ਸਥਾਪਨ ਉਪਲਬਧ ਹਨ (etcd ਅਤੇ Prometheus ਲਈ)। ਦੋਵੇਂ ਅਜੇ ਆਪਣੇ ਸਥਿਰ ਸੰਸਕਰਣਾਂ 'ਤੇ ਨਹੀਂ ਪਹੁੰਚੇ ਹਨ, ਪਰ ਪ੍ਰਤੀਬੱਧਤਾ ਰੋਜ਼ਾਨਾ ਅਧਾਰ 'ਤੇ ਵੇਖੀ ਜਾਂਦੀ ਹੈ।

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

• ਇਲਾਸਟਿਕ ਖੋਜ ਆਪਰੇਟਰ UPMC ਇੰਟਰਪ੍ਰਾਈਜਿਜ਼ ਤੋਂ;
• PostgreSQL ਆਪਰੇਟਰ ਕਰੰਚੀ ਡੇਟਾ ਤੋਂ (ਮਾਰਚ 2017 ਦੇ ਅਖੀਰ ਵਿੱਚ ਘੋਸ਼ਿਤ);
• ਰੂਕ ਆਪਰੇਟਰ Ceph (Rook ਅਲਫ਼ਾ ਸਥਿਤੀ ਵਿੱਚ ਹੈ) 'ਤੇ ਆਧਾਰਿਤ ਇੱਕ ਵਿਤਰਿਤ ਡੇਟਾ ਸਟੋਰੇਜ ਸਿਸਟਮ ਦੇ ਲੇਖਕਾਂ ਤੋਂ;
• ਓਪਨਸਟੈਕ ਆਪਰੇਟਰ SAP CCloud ਤੋਂ।

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

PS ਲੇਖ ਵਿੱਚ ਤੁਹਾਡੀ ਦਿਲਚਸਪੀ ਲਈ ਧੰਨਵਾਦ! ਸਾਡੇ ਹੱਬ ਦੇ ਗਾਹਕ ਬਣੋ, ਤਾਂ ਕਿ DevOps ਅਤੇ GNU/Linux ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਨ 'ਤੇ ਨਵੀਂ ਸਮੱਗਰੀ ਅਤੇ ਪਕਵਾਨਾਂ ਨੂੰ ਨਾ ਖੁੰਝਾਇਆ ਜਾਵੇ - ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਾਂਗੇ!

ਸਰੋਤ: www.habr.com