ਇੱਕ ਸਿੰਗਲ ਕੰਟੇਨਰ ਨੂੰ ਡਿਪਲੋਏ ਕਰਨਾ ਸੌਖਾ ਹੈ। ਦਸ ਨੂੰ ਡਿਪਲੋਏ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਦਰਜਨਾਂ ਮਸ਼ੀਨਾਂ 'ਤੇ ਸੈਂਕੜੇ ਕੰਟੇਨਰ ਚਲਾ ਰਹੇ ਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੈਨੂਅਲ ਮੈਨੇਜਮੈਂਟ ਮੁਸ਼ਕਲ ਨਹੀਂ ਰਹਿੰਦੀ ਬਲਕਿ ਅਸੰਭਵ ਹੋ ਜਾਂਦੀ ਹੈ। ਤੁਸੀਂ ਇਸ ਗੱਲ ਦਾ ਪਤਾ ਗੁਆ ਲੈਂਦੇ ਹੋ ਕਿ ਕਿਹੜਾ ਕੰਟੇਨਰ ਕਿੱਥੇ ਹੈ। ਇੱਕ ਸਰਵਰ ਖਰਾਬ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਉਦੋਂ ਤੱਕ ਗਾਇਬ ਰਹਿੰਦੀ ਹੈ ਜਦੋਂ ਤੱਕ ਕੋਈ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਜਾਗਦਾ ਨਹੀਂ। ਨਵੇਂ ਇੰਸਟੈਂਸ (instances) ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਟ੍ਰੈਫਿਕ ਦਾ ਵਾਧਾ ਤੁਹਾਡੇ ਸੈੱਟਅੱਪ ਨੂੰ ਬੇਵੱਸ ਕਰ ਦਿੰਦਾ ਹੈ। ਇਹੀ ਉਹ ਮੌਕਾ ਹੈ ਜਿੱਥੇ Kubernetes ਦਾਖਲ ਹੁੰਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਇੱਕ ਹੋਰ DevOps ਟੂਲ ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ ਆਰਕੇਸਟ੍ਰੇਸ਼ਨ ਲੇਅਰ (orchestration layer) ਹੈ ਜੋ ਕੰਟੇਨਰ ਮੈਨੇਜਮੈਂਟ ਨੂੰ ਸਕ੍ਰਿਪਟਿੰਗ ਅਭਿਆਸ ਦੀ ਬਜਾਏ ਇੱਕ ਕੰਟਰੋਲ ਸਮੱਸਿਆ ਵਜੋਂ ਦੇਖਦੀ ਹੈ।
ਸਕ੍ਰਿਪਟਾਂ ਅੰਤ ਵਿੱਚ ਕਿਉਂ ਫੇਲ ਹੋ ਜਾਂਦੀਆਂ ਹਨ
ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ (shell scripts) ਜਾਂ ਬੇਸਿਕ ਆਟੋਮੇਸ਼ਨ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਦੀਆਂ ਹਨ। ਉਹ ਇਮੇਜਾਂ (images) ਨੂੰ ਪੁੱਲ ਕਰਨ, ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰਨ, ਲੌਗਸ (logs) ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਅਤੇ ਫੇਲ ਹੋਈਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਮਾਂਡਾਂ ਲਿਖਦੇ ਹਨ। ਉਹ ਪਹੁੰਚ ਇੱਕ ਪ੍ਰੂਫ ਆਫ ਕੰਸੈਪਟ (proof of concept) ਲਈ ਕੰਮ ਕਰਦੀ ਹੈ। ਪਰ ਅਸਲ ਦੁਨੀਆ ਦੇ ਲੋਡ ਹੇਠ ਇਹ ਟੁੱਟ ਜਾਂਦੀ ਹੈ। ਮਾਈਕ੍ਰੋਸਰਵਿਸਿਜ਼ (Microservices) ਵੱਖ-ਵੱਖ ਹੋਸਟਾਂ 'ਤੇ ਇੱਕ ਦੂਜੇ ਨਾਲ ਗੱਲ ਕਰਦੀਆਂ ਹਨ, ਖਾਸ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲਜ਼ (environment variables) 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਪਰਸਿਸਟੈਂਟ ਸਟੋਰੇਜ (persistent storage) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਕੰਟੇਨਰ ਰੀਸਟਾਰਟ ਹੋਣ 'ਤੇ ਵੀ ਬਣੀ ਰਹੇ, ਅਤੇ ਵੱਖ-ਵੱਖ ਵਰਜ਼ਨਾਂ ਵਿਚਕਾਰ ਇਕਸਾਰ ਨੈੱਟਵਰਕਿੰਗ ਦੀ ਉਮੀਦ ਕਰਦੀਆਂ ਹਨ। ਜਦੋਂ ਕੋਈ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਗਾਇਬ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਆਪਣੇ ਆਪ ਵਰਕਲੋਡ (workload) ਨੂੰ ਦੁਬਾਰਾ ਸ਼ਡਿਊਲ ਨਹੀਂ ਕਰ ਸਕਦੀ। ਇਹ ਕ੍ਰੈਸ਼ ਲੂਪ (crash loop) ਵਿੱਚ ਫਸੇ ਹੋਏ ਇੰਸਟੈਂਸਾਂ ਨੂੰ ਛੱਡ ਕੇ ਸਿਹਤਮੰਦ ਇੰਸਟੈਂਸਾਂ ਵਿੱਚ ਨੈੱਟਵਰਕ ਟ੍ਰੈਫਿਕ ਨੂੰ ਵੰਡ ਨਹੀਂ ਸਕਦੀ। Kubernetes ਇਸ ਨੂੰ ਕਲੱਸਟਰ (cluster) ਨੂੰ ਹੀ ਉਹਨਾਂ ਫੈਸਲਿਆਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਬਣਾ ਕੇ ਹੱਲ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਜੋ ਚਾਹੁੰਦੇ ਹੋ ਉਸਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਅਤੇ ਸਿਸਟਮ ਲਗਾਤਾਰ ਉਸ ਸਥਿਤੀ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।
ਤਿੰਨ ਚੀਜ਼ਾਂ ਜੋ ਇਹ ਤੁਹਾਨੂੰ ਦਿੰਦਾ ਹੈ
Kubernetes ਤਿੰਨ ਮੁੱਖ ਸਮਰੱਥਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਮੈਨੂਅਲ ਫਾਇਰਫਾਈਟਿੰਗ (firefighting) ਦੀ ਜਗ੍ਹਾ ਆਟੋਮੇਟਡ ਭਰੋਸੇਯੋਗਤਾ ਲਿਆਉਂਦੀਆਂ ਹਨ।
High availability ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਆਨਲਾਈਨ ਰਹਿੰਦੀਆਂ ਹਨ, ਭਾਵੇਂ ਤੁਹਾਡੇ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਦੇ ਹਿੱਸੇ ਫੇਲ ਹੋ ਜਾਣ। ਜੇਕਰ ਕੋਈ ਕੰਟੇਨਰ ਕ੍ਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ Kubernetes ਕੁਝ ਹੀ ਸਕਿੰਟਾਂ ਵਿੱਚ ਇਸਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਪੂਰਾ ਵਰਕਰ ਨੋਡ (worker node) ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸ਼ਡਿਊਲਰ ਗਾਇਬ ਹੋਏ ਹਾਰਟਬੀਟ (heartbeat) ਦਾ ਨੋਟਿਸ ਕਰਦਾ ਹੈ ਅਤੇ ਪ੍ਰਭਾਵਿਤ ਵਰਕਲੋਡਸ ਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ ਕਿਤੇ ਹੋਰ ਸਿਹਤਮੰਦ ਮਸ਼ੀਨਾਂ 'ਤੇ ਤਬਦੀਲ ਕਰ ਦਿੰਦਾ ਹੈ। ਸਿਸਟਮ ਤੁਹਾਡੇ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਲੋੜੀਂਦੀ ਸਥਿਤੀ 'ਤੇ ਲਗਾਤਾਰ ਨਜ਼ਰ ਰੱਖਦਾ ਹੈ, ਅਤੇ ਮਨੁੱਖੀ ਦਖਲਅੰਦਾਜ਼ੀ ਤੋਂ ਬਿਨਾਂ ਗਲਤੀਆਂ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ।
Scalability ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਤੁਹਾਡੇ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਨਾਲ ਵਧਦੀਆਂ ਹਨ। ਸਿਰਫ਼ ਦੋ ਘੰਟੇ ਦੇ ਟ੍ਰੈਫਿਕ ਪੀਕ (peak) ਨੂੰ ਸਹਿਣ ਲਈ ਵੀਹ ਸਰਵਰ ਪ੍ਰੋਵੀਜ਼ਨ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ CPU ਦੀ ਵਰਤੋਂ ਜਾਂ ਰਿਕੁਐਸਟ ਲੇਟੈਂਸੀ (request latency) ਵਰਗੇ ਮਹੱਤਵਪੂਰਨ ਮੈਟ੍ਰਿਕਸ (metrics) ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ, ਅਤੇ ਜਦੋਂ ਸੀਮਾਵਾਂ (thresholds) ਪਾਰ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ ਕਲੱਸਟਰ ਨੂੰ ਹੋਰ ਕੰਟੇਨਰ ਇੰਸਟੈਂਸ ਜੋੜਨ ਦਿੰਦੇ ਹੋ। ਜਦੋਂ ਮੰਗ ਘਟਦੀ ਹੈ, ਤਾਂ ਰੀਪਲਿਕਾ ਕਾਊਂਟ (replica count) ਫਿਰ ਤੋਂ ਘਟ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਉਸੇ ਲਈ ਭੁਗਤਾਨ ਕਰਦੇ ਹੋ ਜਿਸਦੀ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ, ਜਦੋਂ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ।
Disaster recovery ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕ੍ਰੈਸ਼ ਤੋਂ ਬਾਅਦ ਤੁਹਾਡਾ ਡੇਟਾ ਅਤੇ ਕੌਂਫਿਗਰੇਸ਼ਨ ਵਾਪਸ ਆ ਜਾਂਦੇ ਹਨ। Kubernetes ਪੂਰੇ ਕਲੱਸਟਰ ਦੀ ਸਥਿਤੀ ਨੂੰ ਇੱਕ ਡਿਸਟ੍ਰੀਬਿਊਟਡ ਕੀ-ਵੈਲਯੂ ਸਟੋਰ (distributed key-value store) ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਭਿਆਨਕ ਫੇਲ੍ਹ ਹੋਣ ਕਾਰਨ ਵਰਕਰ ਨੋਡ ਜਾਂ ਕੰਟਰੋਲ ਪਲੇਨ ਦਾ ਕੋਈ ਹਿੱਸਾ ਵੀ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਉਹ ਸਟੋਰ ਕੀਤੀ ਸਥਿਤੀ ਸਿਸਟਮ ਨੂੰ ਤੁਹਾਡੇ ਵਰਕਲੋਡਸ ਨੂੰ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਮੁੜ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਜਿਵੇਂ ਉਹ ਕੌਂਫਿਗ ਕੀਤੇ ਗਏ ਸਨ। ਤੁਹਾਡਾ ਡੇਟਾ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਆਰਕੇਸਟ੍ਰੇਟਰ ਨੂੰ ਯਾਦ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹ ਕਿਹੋ ਜਿਹਾ ਹੋਣਾ ਚਾਹੀਦਾ ਸੀ।
ਸੈੱਟਅੱਪ: ਦਿਮਾਗ ਅਤੇ ਮਾਸਪੇਸ਼ੀਆਂ
ਇੱਕ Kubernetes ਕਲੱਸਟਰ ਦੇ ਦੋ ਮੂਲ ਭੂਮਿਕਾਵਾਂ (roles) ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਵਰਣਨ ਡਰਾਫਟ ਵਿੱਚ ਦਿਮਾਗ ਅਤੇ ਮਾਸਪੇਸ਼ੀਆਂ ਵਜੋਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਉਦਾਹਰਨ ਅਸਲ ਵਿੱਚ ਬਹੁਤ ਸਹੀ ਬੈਠਦੀ ਹੈ।
Master Node ਦਿਮਾਗ ਹੈ। ਇਹ ਤੁਹਾਡੀਆਂ ਗਾਹਕਾਂ ਨੂੰ ਦੇਖਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਨਹੀਂ ਚਲਾਉਂਦਾ। ਇਸਦੀ ਬਜਾਏ, ਇਹ ਕੰਟਰੋਲ ਪਲੇਨ ਦੇ ਉਹ ਹਿੱਸੇ ਹੋਸਟ ਕਰਦਾ ਹੈ ਜੋ ਕੰਮਾਂ ਨੂੰ ਸ਼ਡਿਊਲ ਕਰਦੇ ਹਨ, ਕਲੱਸਟਰ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹਨ, ਅਤੇ ਬਦਲਾਅਾਂ ਦਾ ਜਵਾਬ ਦਿੰਦੇ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਕਮਾਂਡ ਜਾਰੀ ਕਰਦੇ ਹੋ ਜਾਂ ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲ ਸਬਮਿਟ ਕਰਦੇ ਹੋ, ਤਾਂ ਮਾਸਟਰ ਨੋਡ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਵਰਕਲੋਡ ਕਿੱਥੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਕੀ ਇਹ ਸਿਹਤਮੰਦ ਹੈ, ਅਤੇ ਜਦੋਂ ਇਹ ਸਿਹਤਮੰਦ ਨਹੀਂ ਹੁੰਦਾ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ।
Worker Nodes ਮਾਸਪੇਸ਼ੀਆਂ ਹਨ। ਹਰੇਕ ਵਰਕਰ ਇੱਕ ਹਲਕਾ ਏਜੰਟ (agent) ਚਲਾਉਂਦਾ ਹੈ ਜੋ ਮਾਸਟਰ ਨਾਲ ਸੰਚਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸਲ ਪੌਡਸ (pods) ਨੂੰ ਚਲਾਉਣ ਲਈ ਕੰਟੇਨਰ ਰਨਟਾਈਮ (container runtime) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਨੋਡ ਉਹ ਹਨ ਜਿੱਥੇ ਤੁਹਾਡਾ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ CPU ਅਤੇ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਹੋਰ ਵਰਕਰ ਨੋਡ ਜੋੜੋ, ਅਤੇ ਤੁਹਾਡੇ ਕਲੱਸਟਰ ਦੀ ਸਮਰੱਥਾ ਵਧ ਜਾਂਦੀ ਹੈ। ਰੈਡੰਡੈਂਸੀ (redundancy) ਲਈ ਕੌਂਫਿਗ ਕੀਤੇ ਹੋਏ ਹੋਰ ਮਾਸਟਰ ਨੋਡ ਜੋੜੋ, ਅਤੇ ਤੁਹਾਡਾ ਕੰਟਰੋਲ ਪਲੇਨ ਹਾਰਡਵੇਅਰ ਦੀਆਂ ਵਿਅਕਤੀਗਤ ਅਸਫਲਤਾਵਾਂ ਪ੍ਰਤੀ ਲਚਕੀਲਾ ਬਣ ਜਾਂਦਾ ਹੈ।
ਪੌਡਸ (Pods), ਕੰਟੇਨਰ ਅਤੇ ਸਰਵਿਸਿਜ਼
Kubernetes ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਤਿੰਨ ਸ਼ਬਦਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਜੋ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ ਸਾਫਟਵੇਅਰ ਨੂੰ ਕਿਵੇਂ ਪੈਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਸ ਤੱਕ ਕਿਵੇਂ ਪਹੁੰਚਿਆ ਜਾਂਦਾ ਹੈ।
Containers ਉਹ ਪੈਕੇਜ ਹਨ ਜੋ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇਸਦੀਆਂ ਡਿਪੈਂਡੈਂਸੀਜ਼ (dependencies), ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਕੌਂਫਿਗਰੇਸ਼ਨ ਦੇ ਨਾਲ ਬੰਨ੍ਹਦੇ ਹਨ। ਉਹ ਸਾਫਟਵੇਅਰ ਨੂੰ ਅਸਲ ਹੋਸਟ ਤੋਂ ਅਲੱਗ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਇਹ ਡਿਵੈਲਪਮੈਂਟ, ਸਟੇਜਿੰਗ ਅਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਇੱਕੋ ਤਰ੍ਹਾਂ ਚੱਲੇ।
Pods Kubernetes ਵਿੱਚ ਸਭ ਤੋਂ ਛੋਟੀ ਡਿਪਲਾਏਅਰ (deployable) ਯੂਨਿਟ ਹਨ। ਇੱਕ pod ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਕੰਟੇਨਰਾਂ (containers) ਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਰੋਤਾਂ (resources) ਨੂੰ ਸਾਂਝਾ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਹ ਇੱਕੋ ਨੈੱਟਵਰਕ ਨੇਮਸਪੇਸ (network namespace) ਸਾਂਝਾ ਕਰਦੇ ਹਨ ਅਤੇ ਇੱਕੋ ਸਥਾਨਕ ਸਟੋਰੇਜ ਵਾਲਯੂਮਾਂ (local storage volumes) ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਤੁਸੀਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਇੱਕ ਖਾਲੀ ਕੰਟੇਨਰ ਨੂੰ ਡਿਪਲਾਏ ਨਹੀਂ ਕਰਦੇ। ਤੁਸੀਂ ਇੱਕ pod ਨੂੰ ਡਿਪਲਾਏ ਕਰਦੇ ਹੋ ਜੋ ਉਸਨੂੰ ਆਪਣੇ ਅੰਦਰ ਰੱਖਦਾ ਹੈ। Pods ਜਾਣਬੁੱਝ ਕੇ ਅਸਥਾਈ (ephemeral) ਹੁੰਦੇ ਹਨ। ਹਾਲਾਤ ਬਦਲਣ ਦੇ ਨਾਲ ਹੀ ਉਹ ਬਣਦੇ ਹਨ, ਖਤਮ ਹੁੰਦੇ ਹਨ ਅਤੇ ਬਦਲੇ ਜਾਂਦੇ ਹਨ। ਉਹਨਾਂ ਦਾ ਜੀਵਨ-ਕਾਲ (lifespan) ਡਿਜ਼ਾਈਨ ਅਨੁਸਾਰ ਗਤੀਸ਼ੀਲ (dynamic) ਹੁੰਦਾ ਹੈ।
Services ਇਸ ਲਈ ਹੁੰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ pods ਅਸਥਾਈ (transient) ਹੁੰਦੇ ਹਨ। ਹਰ ਵਾਰ ਜਦੋਂ ਇੱਕ pod ਰੀਸਟਾਰਟ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਇੱਕ ਨਵਾਂ ਅੰਦਰੂਨੀ IP ਐਡਰੈੱਸ ਮਿਲੇਗਾ। ਜੇਕਰ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਹੋਰ ਹਿੱਸੇ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਬਦਲਦੇ ਹੋਏ ਐਡਰੈੱਸਾਂ ਨਾਲ ਜੁੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਗੇ, ਤਾਂ ਉਹ ਲਗਾਤਾਰ ਅਸਫਲ ਹੋ ਜਾਣਗੇ। ਇੱਕ service ਤੁਹਾਡੇ pods ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ IP ਐਡਰੈੱਸ ਅਤੇ DNS ਨਾਮ ਦਿੰਦੀ ਹੈ। ਇਹ ਇੱਕ ਸਥਿਰ ਫਰੰਟ ਡੋਰ ਵਜੋਂ ਕੰਮ ਕਰਦੀ ਹੈ, ਜੋ ਇਸਦੇ ਸਲੈਕਟਰ (selector) ਨਾਲ ਮੇਲ ਖਾਣ ਵਾਲੇ ਸਾਰੇ ਸਿਹਤਮੰਦ pods ਵਿੱਚ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ (requests) ਦਾ ਲੋਡ-ਬੈਲੈਂਸਿੰਗ (load-balancing) ਕਰਦੀ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਕਲਾਇੰਟਾਂ ਨੂੰ ਵਿਅਕਤੀਗਤ ਕੰਟੇਨਰ ਜੀਵਨ ਚੱਕਰਾਂ (life cycles) ਦੀ ਉਲਝਣ ਤੋਂ ਵੱਖ ਕਰਦੀ ਹੈ।
ਵੱਡੇ ਪੱਧਰ 'ਤੇ Kubernetes: Netflix ਦੀ ਉਦਾਹਰਣ
Netflix ਆਪਣੇ ਕੰਟੈਂਟ ਡਿਲੀਵਰੀ ਨੈੱਟਵਰਕ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ Kubernetes ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਬੁਨਿਆਦੀ ਢਾਂਚਾ (infrastructure) ਦੁਨੀਆ ਭਰ ਦੇ ਲੱਖਾਂ ਦਰਸ਼ਕਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਵੀਡੀਓ ਸਟ੍ਰੀਮਾਂ ਪਹੁੰਚਾਉਂਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਮਸ਼ਹੂਰ ਸ਼ੋਅ ਆਉਂਦਾ ਹੈ ਅਤੇ ਮੰਗ ਵਧਦੀ ਹੈ, ਤਾਂ ਕਲੱਸਟਰ (cluster) ਉਹਨਾਂ ਕੈਸ਼ ਨੋਡਾਂ (cache nodes) ਦਾ ਪਸਾਰ (scale out) ਕਰਦਾ ਹੈ ਜੋ ਵੀਡੀਓ ਸੈਗਮੈਂਟਾਂ ਨੂੰ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਨੇੜੇ ਸਟੋਰ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਕੋਈ ਖੇਤਰੀ ਨੋਡ (regional node) ਫੇਲ੍ਹ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਟ੍ਰੈਫਿਕ ਆਪਣੇ ਆਪ ਦੂਜੇ ਰਸਤੇ 'ਤੇ ਮੋੜ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ ਕਿਸੇ ਇੰਜੀਨੀਅਰ ਨੂੰ ਮੈਨੂਅਲ ਐਮਰਜੈਂਸੀ ਪੇਜ ਕੀਤੇ ਬਿਨਾਂ ਲੱਖਾਂ ਲੋਕਾਂ ਲਈ ਫਿਲਮਾਂ ਚਲਦੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ। Orchestrator ਪੈਮਾਨੇ (scale) ਅਤੇ ਅਸਫਲਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ ਤਾਂ ਜੋ ਸੇਵਾ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਜਾਰੀ ਰਹੇ।
ਸ਼ੁਰੂਆਤ ਕਰਨਾ: YAML, JSON, ਅਤੇ API Server
Kubernetes ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਦਾ ਮਤਲਬ ਹੈ ਇੰਪਰੇਟਿਵ (imperative) click-ops ਨੂੰ ਛੱਡਣਾ ਅਤੇ ਡਿਕਲੇਰੇਟਿਵ (declarative) ਕੌਂਫਿਗ