ਕੁਬਰਨੇਟਸ: ਮੈਨੀਫੈਸਟ, ਹੈਲਮ ਅਤੇ ਏਆਈ-ਪਾਵਰਡ ਆਰਕੈਸਟਰੇਸ਼ਨ

ਲਾਭ:

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

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

ਪਰ ਕੁਬਰਨੇਟਸ ਵਿੱਚ, ਇੱਕ ਗਲਤ ਮੈਨੀਫੈਸਟ ਦਾ ਮਤਲਬ ਹੈ ਇੱਕ ਪੂਰੀ ਸੇਵਾ ਨੂੰ ਖੜ੍ਹਾ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋਣਾ, ਗਲਤ ਢੰਗ ਨਾਲ ਸਕੇਲਿੰਗ ਕਰਨਾ, ਜਾਂ ਇੱਕ ਕਮਜ਼ੋਰੀ ਛੱਡਣਾ। AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਹਰੇਕ ਮੈਨੀਫੈਸਟ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਤਸਦੀਕ ਕਰਨਾ ਤੁਹਾਡੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੈ — ਖਾਸ ਕਰਕੇ kubectl ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ।

ਕੁਬਰਨੇਟਸ ਕੋਰ ਆਬਜੈਕਟ

ਕੁਬਰਨੇਟਸ ਦਾ ਆਡਿਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਮੁੱਖ ਧਾਰਨਾਵਾਂ ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

Pod: ਸਭ ਤੋਂ ਛੋਟੀ ਕੰਮ ਕਰਨ ਵਾਲੀ ਇਕਾਈ; ਇਸ ਵਿੱਚ ਇੱਕ ਜਾਂ ਕਈ ਡੱਬੇ ਹੁੰਦੇ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ, ਪੌਡ ਦੀ ਵਰਤੋਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਪਰ ਇਸ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਾਲੇ ਮੂਲ ਵਸਤੂਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਤੈਨਾਤੀ: ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਕਿੰਨੀਆਂ ਕਾਪੀਆਂ ਚੱਲਣਗੀਆਂ, ਇਹ ਕਿਹੜਾ ਚਿੱਤਰ ਵਰਤੇਗਾ, ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਵੇਗਾ। ਜੇਕਰ ਕੋਈ ਪੌਡ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ ਇਸਨੂੰ ਦੁਬਾਰਾ ਬਣਾ ਦੇਵੇਗਾ।
ਸੇਵਾ: ਇੱਕ ਨਿਸ਼ਚਿਤ ਨੈੱਟਵਰਕ ਪਤਾ ਅਤੇ ਪੌਡਾਂ ਨੂੰ ਲੋਡ ਸੰਤੁਲਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ; ਭਾਵੇਂ ਪੌਡ ਆਉਂਦੇ ਅਤੇ ਜਾਂਦੇ ਹਨ, ਪਹੁੰਚ ਦਾ ਪਤਾ ਨਹੀਂ ਬਦਲਦਾ.
ConfigMap ਅਤੇ ਗੁਪਤ: ਸੰਰਚਨਾ ਮੁੱਲ ਅਤੇ ਗੁਪਤ ਜਾਣਕਾਰੀ ਨੂੰ Pods ਤੋਂ ਵੱਖ ਰੱਖਦਾ ਹੈ। ConfigMap ਸਪੱਸ਼ਟ ਸੈਟਿੰਗਾਂ ਲਈ ਹੈ, ਸੀਕਰੇਟ ਸੰਵੇਦਨਸ਼ੀਲ ਮੁੱਲਾਂ ਲਈ ਹੈ।
ਨੇਮਸਪੇਸ: ਉਹ ਖੇਤਰ ਜੋ ਤਰਕ ਨਾਲ ਸਰੋਤਾਂ ਨੂੰ ਵੰਡਦਾ ਅਤੇ ਅਲੱਗ ਕਰਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ dev, prod)।
ਪ੍ਰਵੇਸ਼: ਨਿਯਮ ਸੈੱਟ ਜੋ ਕਲੱਸਟਰ ਵਿੱਚ ਸੇਵਾਵਾਂ ਲਈ ਬਾਹਰੀ ਦੁਨੀਆ ਤੋਂ HTTP ਟ੍ਰੈਫਿਕ ਨੂੰ ਨਿਰਦੇਸ਼ਤ ਕਰਦਾ ਹੈ।

ਹੈਲਮ ਕੁਬਰਨੇਟਸ ਦਾ "ਪੈਕੇਜ ਮੈਨੇਜਰ" ਹੈ: ਇਹ ਤੁਹਾਨੂੰ ਆਵਰਤੀ ਮੈਨੀਫੈਸਟਾਂ (ਚਾਰਟ) ਨੂੰ ਟੈਂਪਲੇਟ ਕਰਨ ਅਤੇ ਇੱਕੋ ਕਮਾਂਡ ਨਾਲ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਨਾਲ ਸਥਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। AI ਕੱਚਾ ਮੈਨੀਫੈਸਟ ਅਤੇ ਹੈਲਮ ਚਾਰਟ ਦੋਵੇਂ ਤਿਆਰ ਕਰਦਾ ਹੈ।

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

ਸੁਝਾਅ: ਕੁਬਰਨੇਟਸ ਵਿੱਚ, ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸੁਰੱਖਿਅਤ ਟੈਸਟਿੰਗ ਟੂਲ kubectl apply --dry-run=server -f file.yaml ਹੈ: ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਸਰਵਰ ਸਵੀਕਾਰ ਕਰੇਗਾ ਅਤੇ ਅਸਲ ਵਿੱਚ ਮੈਨੀਫੈਸਟ ਨੂੰ ਲਾਗੂ ਕੀਤੇ ਬਿਨਾਂ ਕੀ ਕਰਨਾ ਹੈ। ਪ੍ਰੋਡ 'ਤੇ ਮੈਨੀਫੈਸਟ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਡਰਾਈ-ਰਨ ਅਤੇ ਕਿਊਬੈਕਟਲ ਡਿਫ ਨੂੰ ਚਲਾਉਣਾ ਯਕੀਨੀ ਬਣਾਓ।

ਕਦਮ ਦਰ ਕਦਮ: AI ਨਾਲ ਮੈਨੀਫੈਸਟ ਬਣਾਉਣਾ

ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਲੋੜ ਦਾ ਵਰਣਨ ਕਰੋ। ਚਿੱਤਰ ਦਾ ਨਾਮ, ਪੋਰਟ, ਕਿੰਨੀਆਂ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ, ਸਰੋਤ ਸੀਮਾਵਾਂ (CPU/ਮੈਮੋਰੀ)।
ਤੈਨਾਤੀ + ਸੇਵਾ ਲਈ ਬੇਨਤੀ ਕਰੋ। ਆਮ ਤੌਰ 'ਤੇ ਦੋਵੇਂ ਇਕੱਠੇ ਲੋੜੀਂਦੇ ਹਨ।
ਵੱਖਰੀ ਸੰਰਚਨਾ ਅਤੇ ਗੁਪਤ. ConfigMap ਲਈ ਸੈਟਿੰਗਾਂ, ਸੀਕਰੇਟ ਲਈ ਸੰਵੇਦਨਸ਼ੀਲ ਮੁੱਲ।
ਸਿਹਤ ਜਾਂਚਾਂ ਸ਼ਾਮਲ ਕਰੋ। livenessProbe (ਕੀ ਇਹ ਲਾਈਵ ਹੈ) ਅਤੇ ReadinessProbe (ਕੀ ਇਹ ਆਵਾਜਾਈ ਲਈ ਤਿਆਰ ਹੈ) ਮਹੱਤਵਪੂਰਨ ਹਨ।
ਇੱਕ ਸਰੋਤ ਸੀਮਾ ਸੈੱਟ ਕਰੋ। ਬੇਨਤੀਆਂ/ਸੀਮਾਵਾਂ ਦੇ ਬਿਨਾਂ ਇੱਕ ਪੋਡ ਪੂਰੇ ਨੋਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।
`--dry-run` ਅਤੇ `diff` ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ, ਫਿਰ ਲਾਗੂ ਕਰੋ। ਟੈਸਟ ਨਾਮ-ਸਥਾਨ ਵਿੱਚ ਪਹਿਲਾਂ।

ਸੁਰੱਖਿਆ: ਕੁਬਰਨੇਟਸ-ਵਿਸ਼ੇਸ਼ ਜੋਖਮ

ਰਾਜ਼ ਅਸਲ ਵਿੱਚ ਗੁਪਤ ਨਹੀਂ ਹੈ - ਇਹ ਸਿਰਫ ਅਧਾਰ 64 ਹੈ. ਕੁਬਰਨੇਟਸ ਸੀਕਰੇਟ ਆਬਜੈਕਟ ਬੇਸ64 ਮੁੱਲਾਂ ਨੂੰ ਏਨਕੋਡ ਕਰਦਾ ਹੈ; ਇਹ ਏਨਕ੍ਰਿਪਸ਼ਨ ਨਹੀਂ ਹੈ, ਇਸਨੂੰ ਆਸਾਨੀ ਨਾਲ ਡੀਕ੍ਰਿਪਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸੱਚੀ ਗੋਪਨੀਯਤਾ ਲਈ, etcd ਐਨਕ੍ਰਿਪਸ਼ਨ ਅਤੇ ਬਾਹਰੀ ਵਾਲਟ (ਵਾਲਟ, ਕਲਾਉਡ ਸੀਕ੍ਰੇਟ ਮੈਨੇਜਰ) ਦੀ ਲੋੜ ਹੈ। ਕਦੇ ਵੀ ਗੁਪਤ ਪ੍ਰਗਟਾਵੇ ਸਿੱਧੇ ਗਿੱਟ ਨੂੰ ਨਾ ਕਰੋ (ਇਸਦੇ ਲਈ ਹੱਲ ਹਨ ਜਿਵੇਂ ਕਿ ਸੀਲਬੰਦ ਰਾਜ਼/ਬਾਹਰੀ ਰਾਜ਼)।
ਇੱਕ ਸਰੋਤ ਸੀਮਾ ਸੈੱਟ ਕਰੋ। ਬਿਨਾਂ ਸੀਮਾ ਦੇ ਇੱਕ ਪੌਡ ਮੈਮੋਰੀ ਲੀਕ ਨਾਲ ਪੂਰੇ ਨੋਡ ਨੂੰ ਕਰੈਸ਼ ਕਰ ਸਕਦਾ ਹੈ।
ਘੱਟੋ-ਘੱਟ ਅਧਿਕਾਰ (RBAC)। ਰੋਲ-ਅਧਾਰਿਤ ਪਹੁੰਚ ਨਿਯੰਤਰਣ ਦੇ ਨਾਲ, ਹਰੇਕ ਸੇਵਾ/ਉਪਭੋਗਤਾ ਕੋਲ ਸਿਰਫ਼ ਉਹਨਾਂ ਅਨੁਮਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਿਹਨਾਂ ਦੀ ਉਸਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ। AI ਕਈ ਵਾਰ ਵੱਡੇ ਕਲੱਸਟਰ-ਐਡਮਿਨ ਦਿੰਦਾ ਹੈ; ਇਸ ਨੂੰ ਘੱਟ ਕਰੋ।
'ਨਵੀਨਤਮ' ਚਿੱਤਰ ਟੈਗ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। ਤੁਸੀਂ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਕਿਹੜਾ ਸੰਸਕਰਣ ਚੱਲ ਰਿਹਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਵਾਪਸ ਨਹੀਂ ਰੋਲ ਕਰ ਸਕਦੇ ਹੋ।

ਸਾਵਧਾਨ: kubectl ਮਿਟਾਉਣਾ ਜਾਂ ਗਲਤ ਲਾਗੂ ਕਰਨਾ ਲਾਈਵ ਤੈਨਾਤੀ ਨੂੰ ਨਸ਼ਟ ਕਰ ਸਕਦਾ ਹੈ। ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਪੁਸ਼ਟੀ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਕਿਸ ਨਾਮ-ਸਪੇਸ (kubectl config current-context) ਵਿੱਚ ਹੋ; ਉਤਪਾਦਨ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਦੁਰਘਟਨਾ ਦਾ ਕੰਮ ਇੱਕ ਆਮ ਤਬਾਹੀ ਹੈ।

ਰਾਅ ਮੈਨੀਫੈਸਟ ਬਨਾਮ ਹੈਲਮ ਟੇਬਲ

ਮਾਪਦੰਡ

ਕੱਚਾ YAML ਮੈਨੀਫੈਸਟ

ਹੈਲਮ ਚਾਰਟ

ਇੰਸਟਾਲੇਸ਼ਨ

kubectl apply -f

ਹੈਲਮ ਇੰਸਟਾਲ ਕਰੋ

ਮਲਟੀਮੀਡੀਆ (dev/prod)

ਕਾਪੀ-ਪੇਸਟ, ਗਲਤੀ ਦੀ ਸੰਭਾਵਨਾ

ਸਿੰਗਲ ਚਾਰਟ, ਵੱਖ-ਵੱਖ ਮੁੱਲ.yaml

ਸੰਸਕਰਣ/ਰੋਲਬੈਕ

ਹੱਥ ਨਾਲ

ਹੈਲਮ ਰੋਲਬੈਕ ਨਾਲ ਆਸਾਨ

ਸਿੱਖਣ ਦੀ ਵਕਰ

ਘੱਟ

ਮੱਧਮ

ਜਦੋਂ

ਛੋਟਾ, ਸਿੰਗਲ ਵਾਤਾਵਰਣ

ਮਲਟੀ-ਮੀਡੀਆ, ਦੁਹਰਾਉਣ ਵਾਲੀ ਸੇਵਾ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - ਕਰੈਸ਼ ਹੋਈ ਸੇਵਾ ਦਾ ਰਾਜ਼। ਇੱਕ Pod ਲਗਾਤਾਰ ਰੀਬੂਟ ਹੋ ਰਿਹਾ ਸੀ (CrashLoopBackOff)। ਟੀਮ ਨੇ AI ਨੂੰ ਲੌਗ ਅਤੇ ਮੈਨੀਫੈਸਟ ਦਿੱਤਾ; ਏਆਈ ਨੇ ਦਿਖਾਇਆ ਕਿ ਪੌਡ ਨੂੰ ਕਦੇ ਵੀ "ਤਿਆਰ" ਨਹੀਂ ਮੰਨਿਆ ਗਿਆ ਸੀ ਕਿਉਂਕਿ ਰੈਡੀਨੇਸਪ੍ਰੋਬ ਗਲਤ ਪੋਰਟ ਨੂੰ ਦੇਖ ਰਿਹਾ ਸੀ। ਉਨ੍ਹਾਂ ਨੇ ਪੋਰਟ ਨੂੰ ਠੀਕ ਕੀਤਾ, ਸੇਵਾ 10 ਮਿੰਟਾਂ ਵਿੱਚ ਸਥਿਰ ਹੋ ਗਈ। ਇਸ ਰਿਸ਼ਤੇ ਨੂੰ ਹੱਥੀਂ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਘੰਟੇ ਲੱਗ ਸਕਦੇ ਹਨ।

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

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

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ

1) ਤੈਨਾਤੀ + ਸੇਵਾ ਉਤਪਾਦਨ:

ਕੁਬਰਨੇਟਸ ਲਈ ਇੱਕ ਡਿਪਲਾਇਮੈਂਟ ਅਤੇ ਸਰਵਿਸ ਮੈਨੀਫੈਸਟ ਲਿਖੋ। ਐਪਲੀਕੇਸ਼ਨ: [AD], ਚਿੱਤਰ: [ਚਿੱਤਰ: ਸਥਿਰ-ਵਰਜਨ], ਪੋਰਟ: [X], ਪ੍ਰਤੀਕ੍ਰਿਤੀ: [N]। ਨਿਯਮ:- CPU/ਮੈਮੋਰੀ ਬੇਨਤੀਆਂ ਅਤੇ ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਕਰੋ।- livenessProbe ਅਤੇ ReadinessProbe ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।- ConfigMap ਤੋਂ ਸੰਰਚਨਾ ਪੜ੍ਹੋ, ਸੀਕ੍ਰੇਟ ਆਬਜੈਕਟ ਤੋਂ ਗੁਪਤ; ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਏਮਬੈਡ ਨਾ ਕਰੋ, ਪਲੇਸਹੋਲਡਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। - ਚਿੱਤਰ ਟੈਗ ": ਨਵੀਨਤਮ" ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। ਵਰਣਨ ਦੇ ਨਾਲ ਦਿਓ.

2) ਮੈਨੀਫੈਸਟ ਗਲਤੀ ਹੱਲ ਕਰਨਾ:

ਮੌਜੂਦਾ Pod [CrashLoopBackOff/Pending/ImagePullBackOff] ਅਵਸਥਾ ਵਿੱਚ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ ਮੈਨੀਫੈਸਟ ਅਤੇ 'kubectl describe' ਆਉਟਪੁੱਟ ਦੇ ਅਨੁਸਾਰ, ਸੰਭਾਵਨਾ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਸੰਭਾਵਿਤ ਮੂਲ ਕਾਰਨਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ ਅਤੇ ਹਰੇਕ ਲਈ verify ਕਮਾਂਡ ਜਾਰੀ ਕਰੋ। ਮੈਨੀਫੈਸਟ: [YAML] ਵਰਣਨ ਕਰੋ: [ਆਊਟਪੁਟ]

3) ਸੁਰੱਖਿਆ/ਇਕਸਾਰਤਾ ਜਾਂਚ:

ਇਸ ਕੁਬਰਨੇਟਸ ਮੈਨੀਫੈਸਟ ਦੀ ਜਾਂਚ ਕਰੋ: ਕੀ ਸਰੋਤ ਸੀਮਾ ਗੁੰਮ ਹੈ, ਕੀ ਇਹ ਪ੍ਰੌਬ ਗੁੰਮ ਹੈ, ਕੀ ਇੱਥੇ ਕੋਈ : ਨਵੀਨਤਮ ਟੈਗ ਹੈ, ਕੀ ਇੱਥੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਆਪਕ RBAC/ਅਧਿਕਾਰਤ ਹੈ, ਕੀ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਗੁਪਤ ਏਮਬੇਡ ਕੀਤਾ ਗਿਆ ਹੈ? ਖੋਜਾਂ ਨੂੰ ਮਹੱਤਵ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਅਤੇ ਸੁਧਾਰ ਨਾਲ ਲਿਖੋ। ਮੈਨੀਫੈਸਟ: [YAML]

4) ਹੈਲਮ ਚਾਰਟ ਵਿੱਚ ਤਬਦੀਲੀ:

ਹੇਠਾਂ ਦਿੱਤੇ ਕੱਚੇ ਮੈਨੀਫੈਸਟਾਂ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਹੈਲਮ ਚਾਰਟ ਵਿੱਚ ਬਦਲੋ: ਕਿਹੜੇ ਮੁੱਲ values.yaml (ਚਿੱਤਰ, ਪ੍ਰਤੀਕ੍ਰਿਤੀ, ਸਰੋਤ, ਵਾਤਾਵਰਣ) ਵਿੱਚ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ? ਚਾਰਟ ਬਣਤਰ ਅਤੇ ਨਮੂਨਾ ਮੁੱਲ ਦਿਖਾਓ. yaml. Manifests: [YAML]

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਮੇਰੀ ਅਰਜ਼ੀ ਲਈ ਕੁਬਰਨੇਟਸ YAML ਲਿਖੋ।"

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

ਮਜਬੂਤ: "ਕੁਬਰਨੇਟਸ ਡਿਪਲਾਇਮੈਂਟ + ਸਰਵਿਸ ਲਿਖੋ। ਚਿੱਤਰ myapp:1.4.2, 3 ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ, 8080 ਪੋਰਟਾਂ। CPU 100m-500m, ਮੈਮੋਰੀ 128Mi-512Mi ਬੇਨਤੀਆਂ/ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਕਰੋ। /healthz ਲਈ ਲਾਈਵਨੇਸ ਪੜਤਾਲ ਪਾਓ, ਤਿਆਰੀ ਦੀ ਜਾਂਚ / ਤੋਂ ਆਬਜੈਕਟ ਨੂੰ ਪੜ੍ਹੋ। ਇਸ ਨੂੰ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ।

ਅੰਤਰ: ਦੂਜਾ ਪ੍ਰੋਂਪਟ ਸੰਸਕਰਣ ਸਕੇਲ, ਸਰੋਤ ਸੀਮਾਵਾਂ, ਸਿਹਤ ਜਾਂਚਾਂ ਅਤੇ ਗੁਪਤ ਨਿਯਮ ਦਿੰਦਾ ਹੈ; ਆਉਟਪੁੱਟ ਉਤਪਾਦਨ ਦੇ ਨੇੜੇ ਹੈ ਅਤੇ ਸੁਰੱਖਿਅਤ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

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

ਸੰਖੇਪ ਵਿੱਚ

ਕੁਬਰਨੇਟਸ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਰ ਗੁੰਝਲਦਾਰ ਆਰਕੈਸਟਰੇਟਰ ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਹੀ ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਕੰਟੇਨਰਾਂ ਨੂੰ ਤੈਨਾਤ, ਸਕੇਲ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ; ਹਰ ਚੀਜ਼ ਨੂੰ ਮੈਨੀਫੈਸਟ YAMLs ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜਿਸ ਨੂੰ ਹੈਲਮ ਟੈਂਪਲੇਟਾਈਜ਼ ਕਰਦਾ ਹੈ। AI ਤੇਜ਼ੀ ਨਾਲ ਡਿਪਲਾਇਮੈਂਟ/ਸਰਵਿਸ ਮੈਨੀਫੈਸਟ ਅਤੇ ਹੈਲਮ ਚਾਰਟ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਰਹੱਸਮਈ ਬੱਗਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ — ਪਰ ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਰੋਤ ਸੀਮਾ, ਸਿਹਤ ਜਾਂਚ, ਅਟੱਲ ਚਿੱਤਰ ਟੈਗ, ਤੰਗ RBAC ਅਤੇ ਗੁਪਤ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਦੀ ਮੰਗ ਕਰਨੀ ਪਵੇਗੀ। --ਡਰਾਈ-ਰਨ, ਡਿਫ ਅਤੇ ਸਹੀ ਸੰਦਰਭ ਜਾਂਚ ਉਹ ਆਦਤਾਂ ਹਨ ਜੋ ਪ੍ਰੋਡ ਕਰੈਸ਼ ਨੂੰ ਰੋਕਦੀਆਂ ਹਨ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

AI ਨੂੰ "ਡਿਪਲਾਇਮੈਂਟ + ਸਰਵਿਸ ਜਨਰੇਸ਼ਨ" ਟੈਮਪਲੇਟ ਨਾਲ ਨਮੂਨਾ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਮੈਨੀਫੈਸਟ ਤਿਆਰ ਕਰਨ ਲਈ ਕਹੋ। ਫਿਰ: (1) "ਸੁਰੱਖਿਆ/ਸੁਰੱਖਿਆ ਜਾਂਚ" ਟੈਂਪਲੇਟ ਨਾਲ ਸਰੋਤ ਸੀਮਾ, ਪੜਤਾਲ, :ਨਵੀਨਤਮ, ਅਤੇ ਗੁਪਤ ਦੀ ਜਾਂਚ ਕਰੋ; (2) ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਇੱਕ ਟੈਸਟ ਕਲੱਸਟਰ/ਮਿਨਿਕਿਊਬ ਉੱਤੇ kubectl apply --dry-run=server ਚਲਾਓ ਅਤੇ ਆਉਟਪੁੱਟ ਪੜ੍ਹੋ; (3) ਦੋ ਸਭ ਤੋਂ ਨਾਜ਼ੁਕ ਸੁਰੱਖਿਆ/ਮਜ਼ਬੂਤ ਆਈਟਮਾਂ ਨੂੰ ਨੋਟ ਕਰੋ ਜੋ ਤੁਹਾਨੂੰ ਗੁੰਮ ਹਨ।

ਚੈੱਕਲਿਸਟ

[ ] ਮੈਂ ਆਪਣੀ ਬੇਨਤੀ ਵਿੱਚ ਚਿੱਤਰ ਸੰਸਕਰਣ, ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ ਦੀ ਗਿਣਤੀ, ਪੋਰਟ ਅਤੇ ਸਰੋਤ ਸੀਮਾਵਾਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਹਨ।
[ ] ਮੈਂ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਜੀਵੰਤਤਾ ਅਤੇ ਤਿਆਰੀ ਜਾਂਚ ਨੂੰ ਜੋੜਿਆ ਹੈ।
[ ] ਚਿੱਤਰ ਟੈਗ ਸਥਿਰ; ਮੈਂ ਇਸਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ: latest.
[ ] ਗੁਪਤ ਨੂੰ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ; ਮੈਂ ਸੀਕ੍ਰੇਟ ਆਬਜੈਕਟ/ਬਾਹਰੀ ਵਾਲਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ।
[ ] ਮੈਂ RBAC/ਅਧਿਕਾਰੀਆਂ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਅਨੁਮਤੀਆਂ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਹੈ।
[ ] ਅਰਜ਼ੀ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ, ਮੈਂ ਪੁਸ਼ਟੀ ਕੀਤੀ ਕਿ ਮੈਂ ਸਹੀ ਸੰਦਰਭ ਵਿੱਚ ਸੀ ਅਤੇ ਉਹ --dry-run/diff ਆਉਟਪੁੱਟ।