kubectl ਨੂੰ ਹੋਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ: ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਗਾਈਡ

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

ਦੀ ਟੀਮ Mail.ru ਤੋਂ Kubernetes aaS ਡੈਨੀਅਲ ਵੇਈਬਲ ਦੁਆਰਾ ਇੱਕ ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਹਾਨੂੰ kubectl ਨਾਲ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸੁਝਾਅ ਅਤੇ ਜੁਗਤਾਂ ਮਿਲਣਗੀਆਂ। ਇਹ ਤੁਹਾਨੂੰ ਕੁਬਰਨੇਟਸ ਦੀ ਡੂੰਘੀ ਸਮਝ ਹਾਸਲ ਕਰਨ ਵਿੱਚ ਵੀ ਮਦਦ ਕਰੇਗਾ।

ਲੇਖਕ ਦੇ ਅਨੁਸਾਰ, ਲੇਖ ਦਾ ਟੀਚਾ ਕੁਬਰਨੇਟਸ ਨਾਲ ਤੁਹਾਡੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਨੂੰ ਨਾ ਸਿਰਫ਼ ਵਧੇਰੇ ਕੁਸ਼ਲ ਬਣਾਉਣਾ ਹੈ, ਸਗੋਂ ਹੋਰ ਮਜ਼ੇਦਾਰ ਵੀ ਹੈ!

ਜਾਣ-ਪਛਾਣ: kubectl ਕੀ ਹੈ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ kubectl ਨੂੰ ਵਧੇਰੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਵਰਤਣਾ ਸਿੱਖ ਸਕੋ, ਤੁਹਾਨੂੰ ਇਹ ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸ ਬਾਰੇ ਇੱਕ ਬੁਨਿਆਦੀ ਸਮਝ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਉਪਭੋਗਤਾ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, kubectl ਇੱਕ ਕੰਟਰੋਲ ਪੈਨਲ ਹੈ ਜੋ ਤੁਹਾਨੂੰ Kubernetes ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, kubectl ਇੱਕ Kubernetes API ਕਲਾਇੰਟ ਹੈ।

Kubernetes API ਇੱਕ HTTP REST API ਹੈ। ਇਹ API ਸੱਚਾ ਕੁਬਰਨੇਟਸ ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਹੈ, ਜਿਸ ਰਾਹੀਂ ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੰਟਰੋਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹਰ ਕੁਬਰਨੇਟਸ ਓਪਰੇਸ਼ਨ ਇੱਕ API ਅੰਤਮ ਬਿੰਦੂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ ਅਤੇ ਉਸ ਅੰਤ ਬਿੰਦੂ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਲਈ, kubectl ਦਾ ਮੁੱਖ ਕੰਮ ਕੁਬਰਨੇਟਸ API ਨੂੰ HTTP ਬੇਨਤੀਆਂ ਕਰਨਾ ਹੈ:

ਕੁਬਰਨੇਟਸ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਰੋਤ-ਅਧਾਰਿਤ ਪ੍ਰਣਾਲੀ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਸਰੋਤਾਂ ਦੀ ਅੰਦਰੂਨੀ ਸਥਿਤੀ ਨੂੰ ਕਾਇਮ ਰੱਖਦਾ ਹੈ ਅਤੇ ਸਾਰੇ ਕੁਬਰਨੇਟਸ ਓਪਰੇਸ਼ਨ CRUD ਓਪਰੇਸ਼ਨ ਹਨ।

ਤੁਸੀਂ ਇਹਨਾਂ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਕੇ ਕੁਬਰਨੇਟਸ ਦੇ ਪੂਰਨ ਨਿਯੰਤਰਣ ਵਿੱਚ ਹੋ, ਅਤੇ ਕੁਬਰਨੇਟਸ ਇਹ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਕਿ ਸਰੋਤਾਂ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦੇ ਅਧਾਰ 'ਤੇ ਕੀ ਕਰਨਾ ਹੈ। ਇਸ ਕਾਰਨ ਕਰਕੇ, ਕੁਬਰਨੇਟਸ API ਸੰਦਰਭ ਨੂੰ ਉਹਨਾਂ ਦੇ ਸੰਬੰਧਿਤ ਕਾਰਜਾਂ ਦੇ ਨਾਲ ਸਰੋਤ ਕਿਸਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਸੰਗਠਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਦੇਖੀਏ.

ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਇੱਕ ReplicaSet ਸਰੋਤ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਨਾਮ ਦੁਆਰਾ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ReplicaSet ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ replicaset.yaml, ਫਿਰ ਕਮਾਂਡ ਚਲਾਓ:

$ kubectl create -f replicaset.yaml

ਇਹ ਇੱਕ ReplicaSet ਸਰੋਤ ਬਣਾਏਗਾ। ਪਰ ਪਰਦੇ ਪਿੱਛੇ ਕੀ ਹੁੰਦਾ ਹੈ?

Kubernetes ਕੋਲ ਇੱਕ ReplicaSet ਰਚਨਾ ਕਾਰਜ ਹੈ। ਕਿਸੇ ਵੀ ਹੋਰ ਓਪਰੇਸ਼ਨ ਵਾਂਗ, ਇਹ ਇੱਕ API ਅੰਤਮ ਬਿੰਦੂ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ. ਇਸ ਕਾਰਵਾਈ ਲਈ ਖਾਸ API ਅੰਤਮ ਬਿੰਦੂ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:

POST /apis/apps/v1/namespaces/{namespace}/replicasets

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

ਇਸ ਲਈ, ਜਦੋਂ ਤੁਸੀਂ ਉਪਰੋਕਤ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, kubectl ਉਪਰੋਕਤ API ਅੰਤਮ ਬਿੰਦੂ ਨੂੰ ਇੱਕ HTTP POST ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ। ReplicaSet ਪਰਿਭਾਸ਼ਾ ਜੋ ਤੁਸੀਂ ਫਾਈਲ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੀ ਹੈ replicaset.yaml, ਬੇਨਤੀ ਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।

ਇਸ ਤਰ੍ਹਾਂ kubectl ਉਹਨਾਂ ਸਾਰੀਆਂ ਕਮਾਂਡਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੇ ਹਨ। ਇਹਨਾਂ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, kubectl ਸਿਰਫ਼ ਉਚਿਤ Kubernetes API ਅੰਤਮ ਬਿੰਦੂਆਂ ਲਈ HTTP ਬੇਨਤੀਆਂ ਕਰਦਾ ਹੈ।

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕੁਬਰਨੇਟਸ ਨੂੰ ਕਿਸੇ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪ੍ਰਬੰਧਿਤ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ curlਕੁਬਰਨੇਟਸ API ਨੂੰ ਹੱਥੀਂ HTTP ਬੇਨਤੀਆਂ ਭੇਜ ਕੇ। Kubectl ਬਸ ਕੁਬਰਨੇਟਸ API ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ।

ਇਹ ਕਿਊਬੈਕਟਲ ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਇਸਦੀ ਬੁਨਿਆਦ ਹੈ। ਪਰ ਕੁਬਰਨੇਟਸ API ਬਾਰੇ ਕੁਝ ਹੋਰ ਹੈ ਜੋ ਕਿ ਹਰੇਕ kubectl ਉਪਭੋਗਤਾ ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਆਉ ਕੁਬਰਨੇਟਸ ਦੇ ਅੰਦਰੂਨੀ ਸੰਸਾਰ ਵਿੱਚ ਇੱਕ ਝਾਤ ਮਾਰੀਏ।

ਕੁਬਰਨੇਟਸ ਦੀ ਅੰਦਰੂਨੀ ਦੁਨੀਆਂ

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

ਇੱਥੇ ਮੁੱਖ ਨੋਡਾਂ ਦੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸੇ ਹਨ:

1. ਰਿਪੋਜ਼ਟਰੀ - ਸਰੋਤ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ (ਆਮ ਤੌਰ 'ਤੇ ਇਹ etcd ਹੈ).
2. API ਸਰਵਰ - ਇੱਕ API ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਸਟੋਰੇਜ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।
3. ਕੰਟਰੋਲਰ ਮੈਨੇਜਰ - ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਰੋਤ ਸਥਿਤੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੀਆਂ ਹਨ।
4. ਸ਼ਡਿਊਲਰ — ਵਰਕਰ ਨੋਡਾਂ 'ਤੇ ਪੌਡਾਂ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।

ਅਤੇ ਇੱਥੇ ਵਰਕਰ ਨੋਡਾਂ ਦਾ ਇੱਕ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਹੈ:

1. ਕੁਬੇਲੇਟ - ਵਰਕਿੰਗ ਨੋਡ 'ਤੇ ਕੰਟੇਨਰਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।

ਇਹ ਸਮਝਣ ਲਈ ਕਿ ਇਹ ਭਾਗ ਇਕੱਠੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ।

ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਹੁਣੇ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ kubectl create -f replicaset.yaml, ਜਿਸ ਤੋਂ ਬਾਅਦ kubectl ਨੇ ਇੱਕ HTTP POST ਬੇਨਤੀ ਕੀਤੀ ReplicaSet API ਅੰਤਮ ਬਿੰਦੂ (ਰਿਪਲੀਕਾਸੈੱਟ ਸਰੋਤ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਪਾਸ ਕਰਨਾ)।

ਕਲੱਸਟਰ ਵਿੱਚ ਕੀ ਹੋ ਰਿਹਾ ਹੈ?

1. ਕਰਨ ਤੋਂ ਬਾਅਦ kubectl create -f replicaset.yaml API ਸਰਵਰ ਸਟੋਰੇਜ ਵਿੱਚ ਤੁਹਾਡੀ ReplicaSet ਸਰੋਤ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ:

   

2. ਅੱਗੇ, ReplicaSet ਕੰਟਰੋਲਰ ਨੂੰ ਕੰਟਰੋਲਰ ਮੈਨੇਜਰ ਵਿੱਚ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ReplicaSet ਸਰੋਤਾਂ ਦੀ ਰਚਨਾ, ਸੋਧ ਅਤੇ ਮਿਟਾਉਣ ਦਾ ਕੰਮ ਕਰਦਾ ਹੈ:

   

3. ReplicaSet ਕੰਟਰੋਲਰ ਹਰੇਕ ReplicaSet ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਲਈ ਇੱਕ ਪੌਡ ਪਰਿਭਾਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ (ਰਿਪਲਿਕਾਸੈਟ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਪੌਡ ਟੈਂਪਲੇਟ ਦੇ ਅਨੁਸਾਰ) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਟੋਰੇਜ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ:

   

4. ਸ਼ਡਿਊਲਰ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਹੈ, ਟਰੈਕਿੰਗ ਪੌਡ ਜੋ ਅਜੇ ਤੱਕ ਕਿਸੇ ਵੀ ਵਰਕਰ ਨੋਡਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਗਏ ਹਨ:

   

5. ਸ਼ਡਿਊਲਰ ਹਰੇਕ ਪੋਡ ਲਈ ਇੱਕ ਢੁਕਵਾਂ ਵਰਕਰ ਨੋਡ ਚੁਣਦਾ ਹੈ ਅਤੇ ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਸਟੋਰ ਵਿੱਚ ਪੌਡ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਜੋੜਦਾ ਹੈ:

   

6. ਵਰਕਰ ਨੋਡ 'ਤੇ ਜਿਸ ਨੂੰ ਪੌਡ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਕੁਬੇਲੇਟ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਹ ਇਸ ਨੋਡ ਨੂੰ ਨਿਰਧਾਰਤ ਪੌਡਾਂ ਨੂੰ ਟਰੈਕ ਕਰਦਾ ਹੈ:

   

7. ਕੁਬੇਲੇਟ ਸਟੋਰੇਜ ਤੋਂ ਪੋਡ ਪਰਿਭਾਸ਼ਾ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਕੰਟੇਨਰ ਰਨਟਾਈਮ, ਜਿਵੇਂ ਕਿ ਡੌਕਰ, ਨੂੰ ਨੋਡ 'ਤੇ ਕੰਟੇਨਰ ਲਾਂਚ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ ਦਿੰਦਾ ਹੈ:

   

ਹੇਠਾਂ ਇਸ ਵਰਣਨ ਦਾ ਪਾਠ ਸੰਸਕਰਣ ਹੈ।

ReplicaSet ਰਚਨਾ ਅੰਤਮ ਬਿੰਦੂ ਲਈ API ਬੇਨਤੀ API ਸਰਵਰ ਦੁਆਰਾ ਸੰਸਾਧਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। API ਸਰਵਰ ਬੇਨਤੀ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸਟੋਰੇਜ ਵਿੱਚ ReplicaSet ਸਰੋਤ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ।

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

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

ਨਵੇਂ ਪੌਡਾਂ ਦੀ ਸਿਰਜਣਾ ਇੱਕ ਸ਼ਡਿਊਲਰ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਪੌਡ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ ਜੋ ਅਜੇ ਵਰਕਰ ਨੋਡਾਂ ਲਈ ਤਹਿ ਨਹੀਂ ਹਨ। ਸ਼ਡਿਊਲਰ ਹਰੇਕ ਪੌਡ ਲਈ ਇੱਕ ਢੁਕਵਾਂ ਵਰਕਰ ਨੋਡ ਚੁਣਦਾ ਹੈ ਅਤੇ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਪੌਡ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ।

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

ਆਖਰੀ ਘਟਨਾ ਕੁਬੇਲੇਟਸ ਨੂੰ ਚਾਲੂ ਕਰਦੀ ਹੈ, ਜੋ ਉਹਨਾਂ ਦੇ ਵਰਕਰ ਨੋਡਾਂ ਲਈ ਤਹਿ ਕੀਤੇ ਪੌਡਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦੇ ਹਨ. ਵਰਕਰ ਨੋਡ ਦਾ Kubelet ਜਿਸ 'ਤੇ ਤੁਹਾਡੀ ReplicaSet ਪੌਡਸ ਸਥਾਪਿਤ ਹਨ, ਨੂੰ ਕੰਟੇਨਰ ਰਨਟਾਈਮ, ਜਿਵੇਂ ਕਿ ਡੌਕਰ, ਨੂੰ ਲੋੜੀਂਦੇ ਕੰਟੇਨਰ ਚਿੱਤਰਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਨਿਰਦੇਸ਼ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇਸ ਮੌਕੇ 'ਤੇ, ਤੁਹਾਡੀ ReplicaSet ਐਪਲੀਕੇਸ਼ਨ ਆਖਰਕਾਰ ਚੱਲ ਰਹੀ ਹੈ!

ਕੁਬਰਨੇਟਸ API ਦੀ ਭੂਮਿਕਾ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਿੱਚ ਦੇਖਿਆ ਸੀ, ਕੁਬਰਨੇਟਸ ਕੰਪੋਨੈਂਟਸ (ਏਪੀਆਈ ਸਰਵਰ ਅਤੇ ਸਟੋਰੇਜ ਨੂੰ ਛੱਡ ਕੇ) ਸਟੋਰੇਜ ਵਿੱਚ ਸਰੋਤਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਦੇਖਦੇ ਹਨ ਅਤੇ ਸਟੋਰੇਜ ਵਿੱਚ ਸਰੋਤਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਬਦਲਦੇ ਹਨ।

ਬੇਸ਼ੱਕ, ਇਹ ਹਿੱਸੇ ਸਟੋਰੇਜ ਨਾਲ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਇੰਟਰੈਕਟ ਨਹੀਂ ਕਰਦੇ, ਪਰ ਸਿਰਫ ਕੁਬਰਨੇਟਸ API ਦੁਆਰਾ।

ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਉਦਾਹਰਣਾਂ 'ਤੇ ਗੌਰ ਕਰੋ:

1. ReplicaSet ਕੰਟਰੋਲਰ API ਐਂਡਪੁਆਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਸੈੱਟਾਂ ਦੀ ਸੂਚੀ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਲ watch ReplicaSet ਸਰੋਤਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ।
2. ReplicaSet ਕੰਟਰੋਲਰ API ਐਂਡਪੁਆਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ Pod ਬਣਾਓ (ਪੋਡ ਬਣਾਓ) ਪੌਡ ਬਣਾਉਣ ਲਈ.
3. ਸ਼ਡਿਊਲਰ API ਐਂਡਪੁਆਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਪੈਚ ਪੋਡ (ਪੌਡ ਸੰਪਾਦਿਤ ਕਰੋ) ਚੁਣੇ ਹੋਏ ਵਰਕਰ ਨੋਡ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦੇ ਨਾਲ ਪੌਡ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ।

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਉਹੀ API ਹੈ ਜੋ kubectl ਪਹੁੰਚ ਕਰਦਾ ਹੈ। ਅੰਦਰੂਨੀ ਭਾਗਾਂ ਅਤੇ ਬਾਹਰੀ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਇੱਕੋ API ਦੀ ਵਰਤੋਂ ਕਰਨਾ Kubernetes ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਇੱਕ ਬੁਨਿਆਦੀ ਸੰਕਲਪ ਹੈ।

ਹੁਣ ਅਸੀਂ ਸੰਖੇਪ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਕੁਬਰਨੇਟਸ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

1. ਸਟੋਰੇਜ ਸਟੋਰ ਸਟੇਟ, ਯਾਨੀ, ਕੁਬਰਨੇਟਸ ਸਰੋਤ।
2. API ਸਰਵਰ ਕੁਬਰਨੇਟਸ API ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰੇਜ ਲਈ ਇੱਕ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
3. ਕੁਬਰਨੇਟਸ ਦੇ ਹੋਰ ਸਾਰੇ ਭਾਗ ਅਤੇ ਉਪਭੋਗਤਾ API ਦੁਆਰਾ Kubernetes ਸਥਿਤੀ (ਸਰੋਤ) ਨੂੰ ਪੜ੍ਹਦੇ, ਨਿਰੀਖਣ ਕਰਦੇ ਅਤੇ ਹੇਰਾਫੇਰੀ ਕਰਦੇ ਹਨ।

ਇਹਨਾਂ ਸੰਕਲਪਾਂ ਨੂੰ ਜਾਣਨ ਨਾਲ ਤੁਹਾਨੂੰ kubectl ਨੂੰ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਸਮਝਣ ਅਤੇ ਇਸਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਲਾਭ ਲੈਣ ਵਿੱਚ ਮਦਦ ਮਿਲੇਗੀ।

ਆਓ ਹੁਣ ਕੁਝ ਖਾਸ ਟਿਪਸ ਅਤੇ ਟ੍ਰਿਕਸ ਦੇਖੀਏ ਜੋ ਕਿਊਬੈਕਟਲ ਨਾਲ ਤੁਹਾਡੀ ਉਤਪਾਦਕਤਾ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਨਗੇ।

1. ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੰਪੁੱਟ ਨੂੰ ਤੇਜ਼ ਕਰੋ

kubectl ਦੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਸਭ ਤੋਂ ਲਾਭਦਾਇਕ, ਪਰ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤੀਆਂ ਤਕਨੀਕਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ।

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

ਦੇਖੋ ਕਿ ਕਿਊਬੈਕਟਲ ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ:

ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ Bash ਅਤੇ Zsh ਸ਼ੈੱਲਾਂ ਲਈ ਕੰਮ ਕਰਦੀ ਹੈ।

ਅਧਿਕਾਰਤ ਗਾਈਡ ਸਵੈ-ਮੁਕੰਮਲਤਾ ਸਥਾਪਤ ਕਰਨ ਲਈ ਵਿਸਤ੍ਰਿਤ ਹਦਾਇਤਾਂ ਸ਼ਾਮਲ ਹਨ, ਪਰ ਹੇਠਾਂ ਅਸੀਂ ਇੱਕ ਛੋਟਾ ਅੰਸ਼ ਪ੍ਰਦਾਨ ਕਰਾਂਗੇ।

ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ

ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਇੱਕ ਸ਼ੈੱਲ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ ਇੱਕ ਸੰਪੂਰਨਤਾ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਮ ਕਰਦੀ ਹੈ। ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਸਕ੍ਰਿਪਟ ਇੱਕ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਕਮਾਂਡ ਲਈ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ।

Kubectl ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ Bash ਅਤੇ Zsh ਲਈ ਐਕਸਟੈਂਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਤਿਆਰ ਅਤੇ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ:

$ kubectl completion bash

ਜਾਂ:

$ kubectl completion zsh

ਸਿਧਾਂਤ ਵਿੱਚ, ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਢੁਕਵੇਂ ਕਮਾਂਡ ਸ਼ੈੱਲ ਨਾਲ ਜੋੜਨਾ ਕਾਫ਼ੀ ਹੈ ਤਾਂ ਕਿ kubectl ਕਮਾਂਡਾਂ ਦੀ ਪੂਰਤੀ ਕਰ ਸਕੇ।

ਅਭਿਆਸ ਵਿੱਚ, Bash (Linux ਅਤੇ MacOS ਵਿਚਕਾਰ ਅੰਤਰਾਂ ਸਮੇਤ) ਅਤੇ Zsh ਲਈ ਕੁਨੈਕਸ਼ਨ ਵਿਧੀ ਵੱਖਰੀ ਹੈ। ਹੇਠਾਂ ਅਸੀਂ ਇਹਨਾਂ ਸਾਰੇ ਵਿਕਲਪਾਂ ਨੂੰ ਦੇਖਾਂਗੇ।

ਲੀਨਕਸ 'ਤੇ ਬੈਸ਼

Bash ਸੰਪੂਰਨਤਾ ਸਕ੍ਰਿਪਟ bash-completion ਪੈਕੇਜ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਇਸਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

$ sudo apt-get install bash-completion

ਜਾਂ:

$ yum install bash-completion

ਤੁਸੀਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਪੈਕੇਜ ਨੂੰ ਹੇਠਲੀ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਫਲਤਾਪੂਰਵਕ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਹੈ:

$ type _init_completion

ਜੇਕਰ ਇਹ ਸ਼ੈੱਲ ਫੰਕਸ਼ਨ ਕੋਡ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਤਾਂ bash-completion ਠੀਕ ਤਰ੍ਹਾਂ ਇੰਸਟਾਲ ਹੈ। ਜੇਕਰ ਕਮਾਂਡ "ਨਹੀਂ ਲੱਭੀ" ਗਲਤੀ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਆਪਣੀ ਫਾਈਲ ਵਿੱਚ ਹੇਠਲੀ ਲਾਈਨ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

ਕੀ ਇਸ ਲਾਈਨ ਨੂੰ ਫਾਈਲ ਵਿੱਚ ਜੋੜਨਾ ਜ਼ਰੂਰੀ ਹੈ? ~ / .bashrc ਜਾਂ ਨਹੀਂ ਪੈਕੇਜ ਮੈਨੇਜਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ bash-completion ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਸੀ। ਇਹ APT ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਪਰ YUM ਲਈ ਨਹੀਂ।

bash-completion ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਸਭ ਕੁਝ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ kubectl ਕੰਪਲੀਸ਼ਨ ਸਕ੍ਰਿਪਟ ਸਾਰੇ ਸ਼ੈੱਲ ਸੈਸ਼ਨਾਂ ਵਿੱਚ ਸਮਰੱਥ ਹੋਵੇ।

ਅਜਿਹਾ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ ਫਾਈਲ ਵਿੱਚ ਹੇਠਲੀ ਲਾਈਨ ਜੋੜਨਾ ~ / .bashrc:

source <(kubectl completion bash)

ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ ਕਿਊਬੈਕਟਲ ਐਕਸਟੈਂਸ਼ਨ ਸਕ੍ਰਿਪਟ ਨੂੰ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਜੋੜਨਾ /etc/bash_completion.d (ਜੇਕਰ ਇਹ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਤਾਂ ਇਸਨੂੰ ਬਣਾਓ):

$ kubectl completion bash >/etc/bash_completion.d/kubectl

ਕੈਟਾਲਾਗ ਵਿੱਚ ਸਾਰੀਆਂ ਐਡ-ਆਨ ਸਕ੍ਰਿਪਟਾਂ /etc/bash_completion.d bash-completion ਵਿੱਚ ਆਟੋਮੈਟਿਕ ਹੀ ਸ਼ਾਮਿਲ ਹੁੰਦੇ ਹਨ।

ਦੋਵੇਂ ਵਿਕਲਪ ਬਰਾਬਰ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।

ਸ਼ੈੱਲ ਨੂੰ ਰੀਸਟਾਰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, kubectl ਕਮਾਂਡ ਕੰਪਲੀਸ਼ਨ ਕੰਮ ਕਰੇਗੀ।

MacOS 'ਤੇ Bash

MacOS 'ਤੇ ਸੈੱਟਅੱਪ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੈ। ਤੱਥ ਇਹ ਹੈ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ, MacOS Bash ਸੰਸਕਰਣ 3.2 ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ kubectl ਆਟੋਕੰਪਲੀਸ਼ਨ ਸਕ੍ਰਿਪਟ ਲਈ ਘੱਟੋ-ਘੱਟ 4.1 ਦੇ Bash ਸੰਸਕਰਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਅਤੇ ਇਹ Bash 3.2 ਵਿੱਚ ਕੰਮ ਨਹੀਂ ਕਰਦੀ ਹੈ।

MacOS 'ਤੇ Bash ਦੇ ਪੁਰਾਣੇ ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਸੰਬੰਧਿਤ ਲਾਇਸੈਂਸ ਸੰਬੰਧੀ ਸਮੱਸਿਆਵਾਂ ਹਨ। Bash ਸੰਸਕਰਣ 4 GPLv3 ਦੇ ਅਧੀਨ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹੈ, ਜੋ ਕਿ ਐਪਲ ਦੁਆਰਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।

MacOS 'ਤੇ kubectl ਆਟੋਕੰਪਲੀਸ਼ਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ Bash ਦਾ ਇੱਕ ਹੋਰ ਤਾਜ਼ਾ ਸੰਸਕਰਣ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਤੁਸੀਂ ਅੱਪਡੇਟ ਕੀਤੇ ਬੈਸ਼ ਨੂੰ ਆਪਣੇ ਡਿਫਾਲਟ ਸ਼ੈੱਲ ਵਜੋਂ ਵੀ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਤੁਹਾਨੂੰ ਭਵਿੱਖ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਾਏਗਾ। ਇਹ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ, ਵੇਰਵੇ ਲੇਖ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਹਨ "MacOS 'ਤੇ Bash ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ".

ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ Bash ਦਾ ਇੱਕ ਤਾਜ਼ਾ ਸੰਸਕਰਣ ਵਰਤ ਰਹੇ ਹੋ (ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰੋ bash --version).

Bash ਸੰਪੂਰਨਤਾ ਸਕ੍ਰਿਪਟ ਪ੍ਰੋਜੈਕਟ ਦੁਆਰਾ ਬਦਲਦੀ ਹੈ bash-ਪੂਰਨਤਾ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਇਸਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਤੁਸੀਂ ਵਰਤ ਕੇ bash-completion ਇੰਸਟਾਲ ਕਰ ਸਕਦੇ ਹੋ ਹੋਮਬ੍ਰੁ:

$ brew install bash-completion@2

ਇਹ ਇਸ ਲਈ ਹੈ @2 bash-completion ਵਰਜਨ 2 ਦਾ ਮਤਲਬ ਹੈ। kubectl ਆਟੋਕੰਪਲੀਸ਼ਨ ਲਈ bash-completion v2 ਦੀ ਲੋੜ ਹੈ, ਅਤੇ bash-completion v2 ਲਈ ਘੱਟੋ-ਘੱਟ Bash ਵਰਜਨ 4.1 ਦੀ ਲੋੜ ਹੈ।

ਕਮਾਂਡ ਆਉਟਪੁੱਟ brew-install ਇੱਕ Caveats ਭਾਗ ਰੱਖਦਾ ਹੈ, ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ ਫਾਈਲ ਵਿੱਚ ਕੀ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

ਹਾਲਾਂਕਿ, ਮੈਂ ਇਹਨਾਂ ਲਾਈਨਾਂ ਨੂੰ ਨਾ ਜੋੜਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ~/.bash_profileਅਤੇ ਅੰਦਰ ~/.bashrc. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਵੈ-ਸੰਪੂਰਨਤਾ ਨਾ ਸਿਰਫ਼ ਮੁੱਖ ਵਿੱਚ, ਸਗੋਂ ਚਾਈਲਡ ਕਮਾਂਡ ਸ਼ੈੱਲਾਂ ਵਿੱਚ ਵੀ ਉਪਲਬਧ ਹੋਵੇਗੀ।

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

$ type _init_completion

ਜੇਕਰ ਤੁਸੀਂ ਆਉਟਪੁੱਟ ਵਿੱਚ ਇੱਕ ਸ਼ੈੱਲ ਫੰਕਸ਼ਨ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਸਭ ਕੁਝ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੁਣ ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ kubectl ਆਟੋਕੰਪਲੇਸ਼ਨ ਸਾਰੇ ਸੈਸ਼ਨਾਂ ਵਿੱਚ ਸਮਰੱਥ ਹੈ।

ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ ਲਾਈਨ ਨੂੰ ਆਪਣੇ ਵਿੱਚ ਜੋੜੋ ~/.bashrc:

source <(kubectl completion bash)

ਦੂਸਰਾ ਤਰੀਕਾ ਹੈ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਆਟੋਕੰਪਲੀਟ ਸਕ੍ਰਿਪਟ ਜੋੜਨਾ /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

ਇਹ ਵਿਧੀ ਤਾਂ ਹੀ ਕੰਮ ਕਰੇਗੀ ਜੇਕਰ ਤੁਸੀਂ Homebrew ਦੀ ਵਰਤੋਂ ਕਰਕੇ bash-completion ਨੂੰ ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, bash-completion ਇਸ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਸਾਰੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ Homebrew ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ kubectl, ਫਿਰ ਪਿਛਲਾ ਕਦਮ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਸਵੈ-ਪੂਰਤੀ ਸਕ੍ਰਿਪਟ ਆਪਣੇ ਆਪ ਫੋਲਡਰ ਵਿੱਚ ਰੱਖੀ ਜਾਵੇਗੀ /usr/local/etc/bash_completion.d ਇੰਸਟਾਲੇਸ਼ਨ ਦੌਰਾਨ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, kubectl autocompletion ਜਿਵੇਂ ਹੀ ਤੁਸੀਂ bash-completion ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦੇਵੇਗਾ।

ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਸਾਰੇ ਵਿਕਲਪ ਬਰਾਬਰ ਹਨ.

zsh

Zsh ਲਈ ਸਵੈ-ਪੂਰਤੀ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਕਿਸੇ ਨਿਰਭਰਤਾ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਕਮਾਂਡ ਸ਼ੈੱਲ ਲੋਡ ਕਰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਤੁਸੀਂ ਆਪਣੇ ਵਿੱਚ ਇੱਕ ਲਾਈਨ ਜੋੜ ਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ ~/.zshrc ਫਾਈਲ:

source <(kubectl completion zsh)

ਜੇਕਰ ਤੁਹਾਨੂੰ ਕੋਈ ਗਲਤੀ ਮਿਲਦੀ ਹੈ not found: compdef ਆਪਣੇ ਸ਼ੈੱਲ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਬਿਲਟਇਨ ਫੰਕਸ਼ਨ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਦੀ ਲੋੜ ਹੈ compdef. ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੀ ਫਾਈਲ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਜੋੜ ਕੇ ਇਸਨੂੰ ਸਮਰੱਥ ਕਰ ਸਕਦੇ ਹੋ ~/.zshrc ਹੇਠ ਦਿੱਤੇ:

autoload -Uz compinit
compinit

2. ਸਰੋਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਤੁਰੰਤ ਦੇਖੋ

ਜਦੋਂ ਤੁਸੀਂ YAML ਸਰੋਤ ਪਰਿਭਾਸ਼ਾਵਾਂ ਬਣਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਸਰੋਤਾਂ ਲਈ ਖੇਤਰਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਰਥ ਜਾਣਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਜਾਣਕਾਰੀ ਨੂੰ ਲੱਭਣ ਲਈ ਇੱਕ ਥਾਂ API ਸੰਦਰਭ ਵਿੱਚ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਾਰੇ ਸਰੋਤਾਂ ਲਈ ਪੂਰੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ।

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

ਕਮਾਂਡ ਫਾਰਮੈਟ ਇਸ ਪ੍ਰਕਾਰ ਹੈ:

$ kubectl explain resource[.field]...

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

ਮੂਲ ਰੂਪ ਵਿੱਚ kubectl explain ਖੇਤਾਂ ਦੇ ਆਲ੍ਹਣੇ ਦਾ ਸਿਰਫ਼ ਪਹਿਲਾ ਪੱਧਰ ਦਿਖਾਉਂਦਾ ਹੈ।

ਦੇਖੋ ਕਿ ਇਹ ਕਿਹੋ ਜਿਹਾ ਲੱਗਦਾ ਹੈ ਇੱਥੇ ਹੋ ਸਕਦਾ ਹੈ.

ਜੇਕਰ ਤੁਸੀਂ ਵਿਕਲਪ ਜੋੜਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਪੂਰੇ ਰੁੱਖ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ --recursive:

$ kubectl explain deployment.spec --recursive

ਜੇ ਤੁਸੀਂ ਬਿਲਕੁਲ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਕਿਹੜੇ ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ:

$ kubectl api-resources

ਇਹ ਕਮਾਂਡ ਸਰੋਤ ਨਾਮਾਂ ਨੂੰ ਬਹੁਵਚਨ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ deployments ਦੀ ਬਜਾਏ deployment. ਇਹ ਉਦਾਹਰਨ ਲਈ, ਛੋਟਾ ਨਾਮ ਵੀ ਦਿਖਾਉਂਦਾ ਹੈ deploy, ਉਹਨਾਂ ਸਰੋਤਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਕੋਲ ਇਹ ਹੈ। ਇਹਨਾਂ ਅੰਤਰਾਂ ਬਾਰੇ ਚਿੰਤਾ ਨਾ ਕਰੋ। ਇਹ ਸਾਰੇ ਨਾਮਕਰਨ ਵਿਕਲਪ kubectl ਦੇ ਬਰਾਬਰ ਹਨ। ਭਾਵ, ਤੁਸੀਂ ਉਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ kubectl explain.

ਹੇਠ ਲਿਖੀਆਂ ਸਾਰੀਆਂ ਕਮਾਂਡਾਂ ਬਰਾਬਰ ਹਨ:

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. ਇੱਕ ਕਸਟਮ ਕਾਲਮ ਆਉਟਪੁੱਟ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਕਰੋ

ਡਿਫੌਲਟ ਕਮਾਂਡ ਆਉਟਪੁੱਟ ਫਾਰਮੈਟ kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

ਇਹ ਫਾਰਮੈਟ ਸੁਵਿਧਾਜਨਕ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ ਸੀਮਤ ਮਾਤਰਾ ਵਿੱਚ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੈ। ਪੂਰੇ ਸਰੋਤ ਪਰਿਭਾਸ਼ਾ ਫਾਰਮੈਟ ਦੀ ਤੁਲਨਾ ਵਿੱਚ, ਇੱਥੇ ਸਿਰਫ਼ ਕੁਝ ਖੇਤਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ।

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

ਇੱਕ ਕਸਟਮ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਵਿਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

ਤੁਸੀਂ ਹਰੇਕ ਆਉਟਪੁੱਟ ਕਾਲਮ ਨੂੰ ਇੱਕ ਜੋੜੇ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ <header>:<jsonpath>ਕਿੱਥੇ <header> ਕਾਲਮ ਦਾ ਨਾਮ ਹੈ, ਅਤੇ <jsonpath> - ਇੱਕ ਸਰੋਤ ਖੇਤਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਾਲਾ ਇੱਕ ਸਮੀਕਰਨ।

ਆਉ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਨ ਵੇਖੀਏ:

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

ਆਉਟਪੁੱਟ ਵਿੱਚ ਪੌਡਾਂ ਦੇ ਨਾਮ ਵਾਲਾ ਇੱਕ ਕਾਲਮ ਹੁੰਦਾ ਹੈ।

ਵਿਕਲਪ ਸਮੀਕਰਨ ਖੇਤਰ ਵਿੱਚੋਂ ਪੌਡ ਨਾਮ ਚੁਣਦਾ ਹੈ metadata.name. ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਪੌਡ ਦਾ ਨਾਮ ਬਾਲ ਨਾਮ ਖੇਤਰ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ metadata ਪੌਡ ਦੇ ਸਰੋਤ ਵਰਣਨ ਵਿੱਚ। ਵਿੱਚ ਹੋਰ ਵੇਰਵੇ ਮਿਲ ਸਕਦੇ ਹਨ API ਗਾਈਡ ਜਾਂ ਕਮਾਂਡ ਟਾਈਪ ਕਰੋ kubectl explain pod.metadata.name.

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

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

ਸਮੀਕਰਨ ਨੋਡ ਨਾਮ ਨੂੰ ਚੁਣਦਾ ਹੈ spec.nodeName - ਜਦੋਂ ਇੱਕ ਪੋਡ ਇੱਕ ਨੋਡ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਦਾ ਨਾਮ ਖੇਤਰ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ spec.nodeName ਪੌਡ ਸਰੋਤ ਨਿਰਧਾਰਨ. ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਜਾਣਕਾਰੀ ਆਉਟਪੁੱਟ ਵਿੱਚ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ kubectl explain pod.spec.nodeName.

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਕੁਬਰਨੇਟਸ ਸਰੋਤ ਖੇਤਰ ਕੇਸ ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੇ ਹਨ।

ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਸਰੋਤ ਖੇਤਰ ਨੂੰ ਇੱਕ ਕਾਲਮ ਵਜੋਂ ਦੇਖ ਸਕਦੇ ਹੋ। ਬਸ ਸਰੋਤ ਨਿਰਧਾਰਨ ਦੀ ਸਮੀਖਿਆ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਆਪਣੀ ਪਸੰਦ ਦੇ ਕਿਸੇ ਵੀ ਖੇਤਰ ਨਾਲ ਅਜ਼ਮਾਓ।

ਪਰ ਪਹਿਲਾਂ, ਆਓ ਫੀਲਡ ਚੋਣ ਸਮੀਕਰਨਾਂ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ।

JSONPath ਸਮੀਕਰਨ

ਸਰੋਤ ਖੇਤਰਾਂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਸਮੀਕਰਨਾਂ 'ਤੇ ਆਧਾਰਿਤ ਹਨ JSONPath.

JSONPath JSON ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਭਾਸ਼ਾ ਹੈ। ਇੱਕ ਸਿੰਗਲ ਖੇਤਰ ਦੀ ਚੋਣ ਕਰਨਾ JSONPath ਲਈ ਸਭ ਤੋਂ ਸਰਲ ਵਰਤੋਂ ਵਾਲਾ ਕੇਸ ਹੈ। ਉਸ ਕੋਲ ਬਹੁਤ ਕੁਝ ਹੈ ਹੋਰ ਸੰਭਾਵਨਾਵਾਂ, ਚੋਣਕਾਰ, ਫਿਲਟਰ ਆਦਿ ਸਮੇਤ।

Kubectl ਵਿਆਖਿਆ ਸੀਮਤ ਗਿਣਤੀ ਵਿੱਚ JSONPath ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦੀ ਹੈ। ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਅਤੇ ਉਦਾਹਰਣਾਂ ਦਾ ਵਰਣਨ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

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

ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ

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

1. ਪੌਡਾਂ ਲਈ ਕੰਟੇਨਰ ਚਿੱਤਰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ:

   $ kubectl get pods 
     -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
   
   NAME                        IMAGES
   engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
   engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
   web-ui-6db964458-8pdw4      wordpress

   ਇਹ ਕਮਾਂਡ ਹਰੇਕ ਪੋਡ ਲਈ ਕੰਟੇਨਰ ਚਿੱਤਰ ਦੇ ਨਾਮ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ।

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

2. ਨੋਡ ਉਪਲਬਧਤਾ ਜ਼ੋਨਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ:

   $ kubectl get nodes 
     -o 
   custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'
   
   NAME                          ZONE
   ip-10-0-118-34.ec2.internal   us-east-1b
   ip-10-0-36-80.ec2.internal    us-east-1a
   ip-10-0-80-67.ec2.internal    us-east-1b

   ਇਹ ਕਮਾਂਡ ਲਾਭਦਾਇਕ ਹੈ ਜੇਕਰ ਤੁਹਾਡਾ ਕਲੱਸਟਰ ਜਨਤਕ ਕਲਾਉਡ ਵਿੱਚ ਹੋਸਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਹਰੇਕ ਨੋਡ ਲਈ ਉਪਲਬਧਤਾ ਜ਼ੋਨ ਦਿਖਾਉਂਦਾ ਹੈ।

   ਉਪਲਬਧਤਾ ਜ਼ੋਨ ਇੱਕ ਕਲਾਉਡ ਸੰਕਲਪ ਹੈ ਜੋ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਜ਼ੋਨ ਨੂੰ ਇੱਕ ਭੂਗੋਲਿਕ ਖੇਤਰ ਤੱਕ ਸੀਮਿਤ ਕਰਦਾ ਹੈ।

   ਹਰੇਕ ਨੋਡ ਲਈ ਉਪਲਬਧਤਾ ਜ਼ੋਨ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਲੇਬਲ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ - failure-domain.beta.kubernetes.io/zone. ਜੇਕਰ ਕਲੱਸਟਰ ਇੱਕ ਜਨਤਕ ਕਲਾਉਡ ਵਿੱਚ ਚੱਲ ਰਿਹਾ ਹੈ, ਤਾਂ ਇਹ ਲੇਬਲ ਆਪਣੇ ਆਪ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਨੋਡ ਲਈ ਉਪਲਬਧਤਾ ਜ਼ੋਨਾਂ ਦੇ ਨਾਮ ਨਾਲ ਭਰਿਆ ਜਾਂਦਾ ਹੈ।

   ਲੇਬਲ Kubernetes ਸਰੋਤ ਨਿਰਧਾਰਨ ਦਾ ਹਿੱਸਾ ਨਹੀਂ ਹਨ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਇਸ ਵਿੱਚ ਨਹੀਂ ਮਿਲੇਗੀ API ਗਾਈਡ. ਹਾਲਾਂਕਿ, ਉਹਨਾਂ ਨੂੰ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਕਿਸੇ ਹੋਰ ਲੇਬਲ ਵਾਂਗ) ਜੇਕਰ ਤੁਸੀਂ YAML ਜਾਂ JSON ਫਾਰਮੈਟ ਵਿੱਚ ਨੋਡਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ਬੇਨਤੀ ਕਰਦੇ ਹੋ:

   $ kubectl get nodes -o yaml
   # или
   $ kubectl get nodes -o json

   ਸਰੋਤ ਵਿਵਰਣ ਸਿੱਖਣ ਦੇ ਨਾਲ-ਨਾਲ ਸਰੋਤਾਂ ਬਾਰੇ ਹੋਰ ਜਾਣਨ ਦਾ ਇਹ ਵਧੀਆ ਤਰੀਕਾ ਹੈ।

4. ਆਸਾਨੀ ਨਾਲ ਕਲੱਸਟਰਾਂ ਅਤੇ ਨਾਮ-ਸਥਾਨਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰੋ

ਜਦੋਂ kubectl Kubernetes API ਨੂੰ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਕੁਨੈਕਸ਼ਨ ਲਈ ਸਾਰੇ ਲੋੜੀਂਦੇ ਪੈਰਾਮੀਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਪਹਿਲਾਂ kubeconfig ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।

ਮੂਲ ਰੂਪ ਵਿੱਚ kubeconfig ਫਾਇਲ ਹੈ ~/.kube/config. ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਫਾਈਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕਮਾਂਡ ਦੁਆਰਾ ਬਣਾਈ ਜਾਂ ਅਪਡੇਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਜਦੋਂ ਤੁਸੀਂ ਮਲਟੀਪਲ ਕਲੱਸਟਰਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੀ kubeconfig ਫਾਈਲ ਵਿੱਚ ਉਹਨਾਂ ਸਾਰੇ ਕਲੱਸਟਰਾਂ ਨਾਲ ਜੁੜਨ ਲਈ ਸੈਟਿੰਗਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਤੁਹਾਨੂੰ kubectl ਕਮਾਂਡ ਨੂੰ ਦੱਸਣ ਲਈ ਇੱਕ ਤਰੀਕੇ ਦੀ ਲੋੜ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਸ ਕਲਸਟਰ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ।

ਇੱਕ ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ, ਤੁਸੀਂ ਇੱਕ ਤੋਂ ਵੱਧ ਨੇਮਸਪੇਸ ਬਣਾ ਸਕਦੇ ਹੋ—ਭੌਤਿਕ ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ ਇੱਕ ਕਿਸਮ ਦਾ ਵਰਚੁਅਲ ਕਲੱਸਟਰ। Kubectl ਇਹ ਵੀ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ kubeconfig ਫਾਇਲ ਦੇ ਅਧਾਰ 'ਤੇ ਕਿਹੜਾ ਨੇਮਸਪੇਸ ਵਰਤਣਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ kubectl ਕਮਾਂਡ ਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਇੱਕ ਤਰੀਕੇ ਦੀ ਵੀ ਲੋੜ ਹੈ ਕਿ ਕਿਸ ਨੇਮਸਪੇਸ ਨਾਲ ਕੰਮ ਕਰਨਾ ਹੈ।

ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਅਸੀਂ ਦੱਸਾਂਗੇ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ।

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

kubeconfig ਫਾਈਲਾਂ

ਆਓ ਦੇਖੀਏ ਕਿ kubeconfig ਫਾਈਲ ਵਿੱਚ ਅਸਲ ਵਿੱਚ ਕੀ ਹੈ:

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, kubeconfig ਫਾਈਲ ਵਿੱਚ ਪ੍ਰਸੰਗਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ। ਸੰਦਰਭ ਵਿੱਚ ਤਿੰਨ ਤੱਤ ਹੁੰਦੇ ਹਨ:

• ਕਲੱਸਟਰ — ਕਲੱਸਟਰ ਸਰਵਰ ਦਾ API URL।
• ਉਪਭੋਗਤਾ - ਕਲੱਸਟਰ ਵਿੱਚ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣੀਕਰਨ ਪ੍ਰਮਾਣ ਪੱਤਰ।
• ਨੇਮਸਪੇਸ - ਕਲੱਸਟਰ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਵੇਲੇ ਵਰਤੀ ਜਾਂਦੀ ਨੇਮਸਪੇਸ।

ਅਭਿਆਸ ਵਿੱਚ, ਉਹ ਅਕਸਰ ਆਪਣੇ kubeconfig ਵਿੱਚ ਪ੍ਰਤੀ ਕਲੱਸਟਰ ਇੱਕ ਸੰਦਰਭ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਤੁਹਾਡੇ ਕੋਲ ਪ੍ਰਤੀ ਕਲੱਸਟਰ ਦੇ ਕਈ ਸੰਦਰਭ ਹੋ ਸਕਦੇ ਹਨ, ਉਪਭੋਗਤਾ ਜਾਂ ਨੇਮਸਪੇਸ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਗਏ ਹਨ। ਹਾਲਾਂਕਿ, ਇਹ ਬਹੁ-ਸੰਦਰਭ ਸੰਰਚਨਾ ਅਸਧਾਰਨ ਹੈ, ਇਸਲਈ ਆਮ ਤੌਰ 'ਤੇ ਕਲੱਸਟਰਾਂ ਅਤੇ ਸੰਦਰਭਾਂ ਵਿਚਕਾਰ ਇੱਕ-ਨਾਲ-ਇੱਕ ਮੈਪਿੰਗ ਹੁੰਦੀ ਹੈ।

ਕਿਸੇ ਵੀ ਸਮੇਂ, ਪ੍ਰਸੰਗਾਂ ਵਿੱਚੋਂ ਇੱਕ ਮੌਜੂਦਾ ਹੈ:

ਜਦੋਂ kubectl ਇੱਕ ਸੰਰਚਨਾ ਫਾਇਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ, ਇਹ ਹਮੇਸ਼ਾਂ ਮੌਜੂਦਾ ਸੰਦਰਭ ਤੋਂ ਜਾਣਕਾਰੀ ਲੈਂਦਾ ਹੈ। ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, kubectl Hare ਕਲੱਸਟਰ ਨਾਲ ਜੁੜ ਜਾਵੇਗਾ।

ਇਸ ਅਨੁਸਾਰ, ਕਿਸੇ ਹੋਰ ਕਲੱਸਟਰ ਵਿੱਚ ਜਾਣ ਲਈ, ਤੁਹਾਨੂੰ kubeconfig ਫਾਈਲ ਵਿੱਚ ਮੌਜੂਦਾ ਸੰਦਰਭ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ:

ਹੁਣ kubectl Fox ਕਲੱਸਟਰ ਨਾਲ ਜੁੜ ਜਾਵੇਗਾ।

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

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, kubectl ਫੌਕਸ ਕਲੱਸਟਰ ਦੇ ਪ੍ਰੋਡ ਨੇਮਸਪੇਸ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ (ਪਹਿਲਾਂ ਟੈਸਟ ਨੇਮਸਪੇਸ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਸੀ)।

ਨੋਟ ਕਰੋ ਕਿ kubectl ਵਿਕਲਪ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ --cluster, --user, --namespace и --context, ਜੋ ਕਿ ਤੁਹਾਨੂੰ ਵਿਅਕਤੀਗਤ ਤੱਤਾਂ ਅਤੇ ਮੌਜੂਦਾ ਸੰਦਰਭ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਭਾਵੇਂ ਕਿ kubeconfig ਵਿੱਚ ਕੀ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਦੇਖੋ kubectl options.

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

kubectx ਦੀ ਵਰਤੋਂ ਕਰੋ

ਕਲੱਸਟਰਾਂ ਅਤੇ ਨਾਮ-ਸਥਾਨਾਂ ਦੇ ਵਿਚਕਾਰ ਬਦਲਣ ਲਈ ਇੱਕ ਬਹੁਤ ਮਸ਼ਹੂਰ ਉਪਯੋਗਤਾ।

ਸਹੂਲਤ ਕਮਾਂਡ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ kubectx и kubens ਕ੍ਰਮਵਾਰ ਮੌਜੂਦਾ ਸੰਦਰਭ ਅਤੇ ਨਾਮ-ਸਥਾਨ ਨੂੰ ਬਦਲਣ ਲਈ।

ਜਿਵੇਂ ਕਿ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਮੌਜੂਦਾ ਸੰਦਰਭ ਨੂੰ ਬਦਲਣ ਦਾ ਮਤਲਬ ਹੈ ਕਲੱਸਟਰ ਨੂੰ ਬਦਲਣਾ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਪ੍ਰਤੀ ਕਲੱਸਟਰ ਸਿਰਫ ਇੱਕ ਪ੍ਰਸੰਗ ਹੈ।

ਇੱਥੇ ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ, ਇਹ ਕਮਾਂਡਾਂ ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ kubeconfig ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਦੀਆਂ ਹਨ।

ਸਥਾਪਤ ਕਰਨ ਲਈ kubectx'ਤੇ ਦਿੱਤੀਆਂ ਹਿਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ ਗਿਤੁਬ.

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

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

ਸ਼ੈੱਲ ਉਪਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਤੁਹਾਨੂੰ ਮੌਜੂਦਾ ਸੰਦਰਭ ਅਤੇ ਨੇਮਸਪੇਸ ਨੂੰ ਬਦਲਣ ਲਈ ਵੱਖਰੇ ਟੂਲਸ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ kubectl ਇਸਦੇ ਲਈ ਕਮਾਂਡ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਹਾਂ, ਟੀਮ kubectl config kubeconfig ਫਾਇਲਾਂ ਨੂੰ ਸੋਧਣ ਲਈ ਉਪ-ਕਮਾਂਡ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਹਨ:

• kubectl config get-contexts: ਸਾਰੇ ਸੰਦਰਭ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ;
• kubectl config current-context: ਮੌਜੂਦਾ ਸੰਦਰਭ ਪ੍ਰਾਪਤ ਕਰੋ;
• kubectl config use-context: ਮੌਜੂਦਾ ਸੰਦਰਭ ਬਦਲੋ;
• kubectl config set-context: ਸੰਦਰਭ ਤੱਤ ਬਦਲੋ।

ਹਾਲਾਂਕਿ, ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਦੀ ਸਿੱਧੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਇਹ ਲੰਬੇ ਹਨ। ਤੁਸੀਂ ਉਹਨਾਂ ਲਈ ਸ਼ੈੱਲ ਉਪਨਾਮ ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ ਚਲਾਉਣ ਲਈ ਆਸਾਨ ਹਨ।

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

ਨੋਟ ਕਰੋ ਕਿ ਉਪਨਾਮ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਫਰੀ ਲੁੱਕਅਪ ਇੰਟਰਫੇਸ (ਜਿਵੇਂ ਕਿ ਕਿਊਬੈਕਟੈਕਸ ਦਾ ਇੰਟਰਐਕਟਿਵ ਮੋਡ) ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ fzf ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ fzf ਇੰਸਟਾਲ ਕਰੋਇਹਨਾਂ ਉਪਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ।

ਇੱਥੇ ਉਪਨਾਮਾਂ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਹਨ:

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

ਇਹਨਾਂ ਉਪਨਾਮਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਆਪਣੀ ਫਾਈਲ ਵਿੱਚ ਉਪਰੋਕਤ ਪਰਿਭਾਸ਼ਾਵਾਂ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ~/.bashrc ਜ ~/.zshrc ਅਤੇ ਆਪਣੇ ਸ਼ੈੱਲ ਨੂੰ ਰੀਬੂਟ ਕਰੋ।

ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

Kubectl ਤੁਹਾਨੂੰ ਪਲੱਗਇਨ ਲੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਮੂਲ ਕਮਾਂਡਾਂ ਵਾਂਗ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ, ਉਦਾਹਰਨ ਲਈ, kubectl-foo ਪਲੱਗਇਨ ਨੂੰ ਇੰਸਟਾਲ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਮਾਂਡ ਚਲਾ ਕੇ ਚਲਾ ਸਕਦੇ ਹੋ। kubectl foo.

ਇਸ ਤਰੀਕੇ ਨਾਲ ਸੰਦਰਭ ਅਤੇ ਨੇਮਸਪੇਸ ਨੂੰ ਬਦਲਣਾ ਸੁਵਿਧਾਜਨਕ ਹੋਵੇਗਾ, ਉਦਾਹਰਨ ਲਈ ਚਲਾ ਕੇ kubectl ctx ਪ੍ਰਸੰਗ ਨੂੰ ਬਦਲਣ ਲਈ ਅਤੇ kubectl ns ਨੇਮਸਪੇਸ ਨੂੰ ਬਦਲਣ ਲਈ।

ਮੈਂ ਦੋ ਪਲੱਗਇਨ ਲਿਖੇ ਹਨ ਜੋ ਇਹ ਕਰਦੇ ਹਨ:

• kubectl-ctx
• kubectl-ns

ਪਲੱਗਇਨ ਦਾ ਕੰਮ ਪਿਛਲੇ ਭਾਗ ਦੇ ਉਪਨਾਮਾਂ 'ਤੇ ਅਧਾਰਤ ਹੈ।

ਇੱਥੇ ਉਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ:

ਨੋਟ ਕਰੋ ਕਿ ਪਲੱਗਇਨ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਮੁਫਤ ਖੋਜ ਇੰਟਰਫੇਸ (ਜਿਵੇਂ ਕਿ ਕਿਊਬੈਕਟੈਕਸ ਦਾ ਇੰਟਰਐਕਟਿਵ ਮੋਡ) ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ fzf ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ fzf ਇੰਸਟਾਲ ਕਰੋਇਹਨਾਂ ਉਪਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ।

ਪਲੱਗਇਨ ਸਥਾਪਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਨਾਮ ਵਾਲੀਆਂ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ kubectl-ctx и kubectl-ns ਤੁਹਾਡੇ PATH ਵੇਰੀਏਬਲ ਵਿੱਚ ਕਿਸੇ ਵੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਬਣਾਉ ਜਿਵੇਂ ਕਿ. chmod +x. ਇਸ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਤੁਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਰ ਸਕੋਗੇ kubectl ctx и kubectl ns.

5. ਆਟੋਏਲੀਅਸ ਨਾਲ ਇਨਪੁਟ ਘਟਾਓ

ਸ਼ੈੱਲ ਉਪਨਾਮ ਇਨਪੁਟ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਦਾ ਵਧੀਆ ਤਰੀਕਾ ਹੈ। ਪ੍ਰੋਜੈਕਟ kubectl-ਉਪਨਾਮ ਬੁਨਿਆਦੀ kubectl ਕਮਾਂਡਾਂ ਲਈ ਲਗਭਗ 800 ਸ਼ਾਰਟਕੱਟ ਹਨ।

ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚ ਰਹੇ ਹੋਵੋਗੇ - ਤੁਹਾਨੂੰ 800 ਉਪਨਾਮ ਕਿਵੇਂ ਯਾਦ ਹਨ? ਪਰ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਯਾਦ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਇੱਕ ਸਧਾਰਨ ਸਕੀਮ ਦੇ ਅਨੁਸਾਰ ਬਣਾਏ ਗਏ ਹਨ, ਜੋ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ:

ਉਦਾਹਰਨ ਲਈ:

1. kgpooyaml - kubectl get pods oyaml
2. ksysgsvcw — kubectl -n kube-ਸਿਸਟਮ ਨੂੰ svc ਡਬਲਯੂ
3. ksysrmcm -kubectl -n kube-ਸਿਸਟਮ rm cm
4. kgdepalsl - kubectl ਪ੍ਰਾਪਤ ਤੈਨਾਤੀ ਸਾਰੇ sl

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

ਮੌਜੂਦਾ ਵਿਸਤ੍ਰਿਤ ਚਿੱਤਰ 'ਤੇ ਹੈ GitHub. ਉੱਥੇ ਵੀ ਤੁਸੀਂ ਲੱਭ ਸਕਦੇ ਹੋ ਉਪਨਾਮਾਂ ਦੀ ਪੂਰੀ ਸੂਚੀ.

ਉਦਾਹਰਨ ਲਈ, ਉਰਫ kgpooyamlall ਕਮਾਂਡ ਦੇ ਬਰਾਬਰ ਹੈ kubectl get pods -o yaml --all-namespaces.

ਵਿਕਲਪਾਂ ਦਾ ਅਨੁਸਾਰੀ ਕ੍ਰਮ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ: ਕਮਾਂਡ kgpooyamlall ਕਮਾਂਡ ਦੇ ਬਰਾਬਰ ਹੈ kgpoalloyaml.

ਤੁਹਾਨੂੰ ਉਪਨਾਮ ਵਜੋਂ ਸਾਰੇ ਭਾਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਉਦਾਹਰਣ ਲਈ k, kg, klo, ksys, kgpo ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਕਮਾਂਡ ਲਾਈਨ 'ਤੇ ਉਪਨਾਮ ਅਤੇ ਨਿਯਮਤ ਕਮਾਂਡਾਂ ਜਾਂ ਵਿਕਲਪਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ:

ਉਦਾਹਰਨ ਲਈ:

1. ਦੀ ਬਜਾਏ kubectl proxy ਤੁਸੀਂ ਲਿਖ ਸਕਦੇ ਹੋ k proxy.
2. ਦੀ ਬਜਾਏ kubectl get roles ਤੁਸੀਂ ਲਿਖ ਸਕਦੇ ਹੋ kg roles (ਰੋਲਜ਼ ਸਰੋਤ ਲਈ ਵਰਤਮਾਨ ਵਿੱਚ ਕੋਈ ਉਪਨਾਮ ਨਹੀਂ ਹੈ)।
3. ਕਿਸੇ ਖਾਸ ਪੌਡ ਲਈ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ kgpo my-pod — kubectl get pod my-pod.

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਕੁਝ ਉਪਨਾਮਾਂ ਲਈ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਉਪਨਾਮ kgpol ਮਤਲਬ kubectl get pods -l. ਵਿਕਲਪ -l ਇੱਕ ਦਲੀਲ ਦੀ ਲੋੜ ਹੈ - ਇੱਕ ਲੇਬਲ ਨਿਰਧਾਰਨ। ਜੇਕਰ ਤੁਸੀਂ ਉਪਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਤਾਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ kgpol app=ui.

ਕਿਉਂਕਿ ਕੁਝ ਉਪਨਾਮਾਂ ਲਈ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਉਪਨਾਮ a, f, ਅਤੇ l ਆਖਰੀ ਵਾਰ ਵਰਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ।

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

ਇੰਸਟਾਲੇਸ਼ਨ

kubectl-aliases ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ .kubectl_aliases GitHub ਤੋਂ ਅਤੇ ਇਸ ਨੂੰ ਫਾਈਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ~/.bashrc ਜ ~/.zshrc:

source ~/.kubectl_aliases

ਸਵੈ-ਸੰਪੂਰਨਤਾ

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਕਿਹਾ ਹੈ, ਤੁਸੀਂ ਅਕਸਰ ਕਮਾਂਡ ਲਾਈਨ 'ਤੇ ਉਪਨਾਮ ਲਈ ਵਾਧੂ ਸ਼ਬਦ ਜੋੜਦੇ ਹੋ। ਉਦਾਹਰਣ ਲਈ:

$ kgpooyaml test-pod-d4b77b989

ਜੇਕਰ ਤੁਸੀਂ kubectl ਕਮਾਂਡ ਸੰਪੂਰਨਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਸਰੋਤ ਨਾਮਾਂ ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਲਈ ਸਵੈ-ਪੂਰਤੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਪਰ ਕੀ ਇਹ ਉਦੋਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਉਪਨਾਮ ਵਰਤੇ ਜਾਂਦੇ ਹਨ?

ਇਹ ਇੱਕ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਸਵਾਲ ਹੈ ਕਿਉਂਕਿ ਜੇਕਰ ਸਵੈ-ਮੁਕੰਮਲਤਾ ਕੰਮ ਨਹੀਂ ਕਰਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਪਨਾਮਾਂ ਦੇ ਕੁਝ ਲਾਭ ਗੁਆ ਦੇਵੋਗੇ।

ਜਵਾਬ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਸ ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ:

1. Zsh ਲਈ, ਉਰਫ ਸੰਪੂਰਨਤਾ ਬਾਕਸ ਤੋਂ ਬਾਹਰ ਕੰਮ ਕਰਦੀ ਹੈ।
2. Bash ਲਈ, ਬਦਕਿਸਮਤੀ ਨਾਲ, ਕੰਮ ਕਰਨ ਲਈ ਸਵੈ-ਸੰਪੂਰਨਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੁਝ ਕੰਮ ਦੀ ਲੋੜ ਹੈ।

Bash ਵਿੱਚ ਉਪਨਾਮਾਂ ਲਈ ਸਵੈ-ਮੁਕੰਮਲਤਾ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ

Bash ਨਾਲ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇਹ ਉਪਨਾਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ (ਹਰ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਟੈਬ ਦਬਾਉਂਦੇ ਹੋ) ਉਪਨਾਮ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ Zsh ਕਰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ)। ਕਿਉਂਕਿ ਤੁਹਾਡੇ ਕੋਲ ਸਾਰੇ 800 ਉਪਨਾਮਾਂ ਲਈ ਮੁਕੰਮਲ ਹੋਣ ਵਾਲੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਨਹੀਂ ਹਨ, ਆਟੋਕੰਪਲੇਸ਼ਨ ਕੰਮ ਨਹੀਂ ਕਰਦੀ ਹੈ।

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

ਹੇਠਾਂ ਦਿੱਤੇ ਵਿੱਚ, ਮੈਂ ਪਹਿਲਾਂ ਦੱਸਾਂਗਾ ਕਿ ਪੂਰਾ-ਉਪਨਾਮ ਕਿਵੇਂ ਸਥਾਪਤ ਕਰਨਾ ਹੈ ਅਤੇ ਫਿਰ ਸਾਰੇ ਕਿਊਬੈਕਟਲ ਉਪਨਾਮਾਂ ਲਈ ਸੰਪੂਰਨਤਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਲਈ ਇਸਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈ।

ਪੂਰਾ-ਉਪਨਾਮ ਸਥਾਪਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਪੂਰਾ-ਉਪਨਾਮ ਨਿਰਭਰ ਕਰਦਾ ਹੈ bash-ਪੂਰਨਤਾ. ਇਸ ਲਈ, ਸੰਪੂਰਨ-ਉਪਨਾਮ ਸਥਾਪਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਬੈਸ਼-ਕੰਪਲੀਸ਼ਨ ਇੰਸਟਾਲ ਹੈ। ਲੀਨਕਸ ਅਤੇ ਮੈਕੋਸ ਲਈ ਇੰਸਟਾਲੇਸ਼ਨ ਨਿਰਦੇਸ਼ ਪਹਿਲਾਂ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ।

MacOS ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਨੋਟ: kubectl ਆਟੋਕੰਪਲਸ਼ਨ ਸਕ੍ਰਿਪਟ ਦੀ ਤਰ੍ਹਾਂ, ਪੂਰਾ-ਅਨਾਮ Bash 3.2 ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਜੋ ਕਿ MacOS 'ਤੇ ਡਿਫੌਲਟ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਪੂਰਾ-ਉਪਨਾਮ bash-completion v2 ('ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ)brew install bash-completion@2), ਜਿਸ ਲਈ ਘੱਟੋ-ਘੱਟ Bash 4.1 ਦੀ ਲੋੜ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ MacOS 'ਤੇ ਸੰਪੂਰਨ-ਉਪਨਾਮ ਵਰਤਣ ਲਈ ਤੁਹਾਨੂੰ Bash ਦਾ ਨਵਾਂ ਸੰਸਕਰਣ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਤੁਹਾਨੂੰ ਸਕ੍ਰਿਪਟ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ bash_completion.sh ਤੱਕ GitHub ਰਿਪੋਜ਼ਟਰੀ ਅਤੇ ਇਸਨੂੰ ਆਪਣੀ ਫਾਈਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ~/.bashrc:

source ~/bash_completion.sh

ਸ਼ੈੱਲ ਨੂੰ ਰੀਬੂਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਪੂਰਾ ਉਪਨਾਮ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਥਾਪਿਤ ਹੋ ਜਾਵੇਗਾ।

kubectl ਉਪਨਾਮਾਂ ਲਈ ਸਵੈ-ਸੰਪੂਰਨਤਾ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ

ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਪੂਰਾ-ਉਪਨਾਮ ਇੱਕ ਰੈਪਰ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ _complete_alias. ਇਹ ਫੰਕਸ਼ਨ ਉਪਨਾਮ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਨਾਮ ਕਮਾਂਡ ਲਈ ਸੰਪੂਰਨਤਾ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ।

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

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ, ਆਉ ਉਰਫ k ਨੂੰ ਲੈ ਲਈਏ, ਜੋ ਕਿ kubectl ਕਮਾਂਡ ਲਈ ਹੈ। ਇੰਸਟਾਲ ਕਰਨ ਲਈ _complete_alias ਇਸ ਉਪਨਾਮ ਲਈ ਇੱਕ ਪੂਰਕ ਫੰਕਸ਼ਨ ਵਜੋਂ, ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਚਲਾਉਣੀ ਚਾਹੀਦੀ ਹੈ:

$ complete -F _complete_alias k

ਇਸਦਾ ਨਤੀਜਾ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ ਜਦੋਂ ਵੀ ਤੁਸੀਂ ਇੱਕ ਉਰਫ k ਨੂੰ ਆਟੋਕੰਪਲੀਟ ਕਰਦੇ ਹੋ, ਫੰਕਸ਼ਨ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ _complete_alias, ਜੋ ਉਪਨਾਮ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਅਤੇ ਕਮਾਂਡ ਲਈ ਸੰਪੂਰਨਤਾ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ kubectl.

ਦੂਜੀ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਆਓ ਉਪਨਾਮ ਨੂੰ ਲੈਂਦੇ ਹਾਂ kg, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ kubectl get:

$ complete -F _complete_alias kg

ਜਿਵੇਂ ਪਿਛਲੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਜਦੋਂ ਤੁਸੀਂ ਕਿਲੋਗ੍ਰਾਮ ਨੂੰ ਸਵੈ-ਮੁਕੰਮਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਉਹੀ ਸੰਪੂਰਨਤਾ ਸੰਕੇਤ ਮਿਲਦੇ ਹਨ ਜੋ ਤੁਸੀਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ kubectl get.

ਯਾਦ ਰੱਖੋ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਸਿਸਟਮ 'ਤੇ ਕਿਸੇ ਵੀ ਉਪਨਾਮ ਲਈ ਮੁਕੰਮਲ-ਉਪਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਇਸਲਈ, ਸਾਰੇ kubectl ਉਪਨਾਮਾਂ ਲਈ ਸਵੈ-ਸੰਪੂਰਨਤਾ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਲਈ ਉਪਰੋਕਤ ਕਮਾਂਡ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਨਿਮਨਲਿਖਤ ਸਨਿੱਪਟ ਬਿਲਕੁਲ ਇਸ ਤਰ੍ਹਾਂ ਕਰਦਾ ਹੈ, ਬਸ਼ਰਤੇ ਤੁਸੀਂ kubectl-aliases ਨੂੰ ਸੈੱਟ ਕੀਤਾ ਹੋਵੇ ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

ਕੋਡ ਦੇ ਇਸ ਟੁਕੜੇ ਨੂੰ ਤੁਹਾਡੇ ਵਿੱਚ ਰੱਖੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ ~/.bashrc, ਕਮਾਂਡ ਸ਼ੈੱਲ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ ਅਤੇ ਆਟੋਕੰਪਲੇਸ਼ਨ ਸਾਰੇ 800 ਕਿਊਬੈਕਟਲ ਉਪਨਾਮਾਂ ਲਈ ਉਪਲਬਧ ਹੋ ਜਾਵੇਗਾ।

6. ਪਲੱਗਇਨ ਨਾਲ kubectl ਦਾ ਵਿਸਤਾਰ ਕਰਨਾ

ਤੋਂ ਸ਼ੁਰੂ ਹੋ ਰਿਹਾ ਹੈ ਸੰਸਕਰਣ 1.12, kubectl ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਪਲੱਗਇਨ ਵਿਧੀ, ਜੋ ਤੁਹਾਨੂੰ ਵਾਧੂ ਕਮਾਂਡਾਂ ਨਾਲ ਇਸਦੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਧਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਜੇ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ Git ਪਲੱਗਇਨ ਵਿਧੀ, ਫਿਰ kubectl ਪਲੱਗਇਨ ਉਸੇ ਸਿਧਾਂਤ 'ਤੇ ਬਣਾਏ ਗਏ ਹਨ।

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

ਪਲੱਗਇਨ ਸਥਾਪਤ ਕਰ ਰਿਹਾ ਹੈ

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

ਉਦਾਹਰਨ ਲਈ, ਹੈਲੋ ਪਲੱਗਇਨ ਨੂੰ ਇੱਕ ਫਾਈਲ ਦੇ ਰੂਪ ਵਿੱਚ ਵੰਡਿਆ ਜਾਵੇਗਾ ਜਿਸਨੂੰ ਕਹਿੰਦੇ ਹਨ kubectl-hello.

ਪਲੱਗਇਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਫਾਈਲ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ kubectl-x ਆਪਣੇ PATH ਵਿੱਚ ਕਿਸੇ ਵੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਭੇਜੋ ਅਤੇ ਇਸਨੂੰ ਚਲਾਉਣਯੋਗ ਬਣਾਓ, ਉਦਾਹਰਨ ਲਈ ਨਾਲ chmod +x. ਇਸ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਤੁਸੀਂ ਪਲੱਗਇਨ ਨਾਲ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ kubectl x.

ਤੁਸੀਂ ਉਹਨਾਂ ਸਾਰੇ ਪਲੱਗਇਨਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨ ਲਈ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਵਰਤਮਾਨ ਵਿੱਚ ਤੁਹਾਡੇ ਸਿਸਟਮ ਤੇ ਇੰਸਟਾਲ ਹਨ:

$ kubectl plugin list

ਇਹ ਕਮਾਂਡ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਵੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗੀ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕੋ ਨਾਮ ਨਾਲ ਕਈ ਪਲੱਗਇਨ ਹਨ, ਜਾਂ ਜੇਕਰ ਕੋਈ ਪਲੱਗਇਨ ਫਾਈਲ ਹੈ ਜੋ ਚੱਲਣਯੋਗ ਨਹੀਂ ਹੈ।

ਕ੍ਰੂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਲੱਗਇਨ ਲੱਭਣਾ ਅਤੇ ਸਥਾਪਿਤ ਕਰਨਾ

Kubectl ਪਲੱਗਇਨਾਂ ਨੂੰ ਸਾਫਟਵੇਅਰ ਪੈਕੇਜਾਂ ਵਾਂਗ ਸਾਂਝਾ ਜਾਂ ਮੁੜ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪਰ ਤੁਸੀਂ ਪਲੱਗਇਨ ਕਿੱਥੇ ਲੱਭ ਸਕਦੇ ਹੋ ਜੋ ਦੂਜਿਆਂ ਨੇ ਸਾਂਝੇ ਕੀਤੇ ਹਨ?

ਪ੍ਰੋਜੈਕਟ ਕਰੂ kubectl ਪਲੱਗਇਨਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਨ, ਖੋਜਣ, ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਪ੍ਰਬੰਧਨ ਲਈ ਇੱਕ ਏਕੀਕ੍ਰਿਤ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਨ ਦਾ ਉਦੇਸ਼ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਆਪਣੇ ਆਪ ਨੂੰ "ਕੁਬੈਕਟਲ ਪਲੱਗਇਨਾਂ ਲਈ ਪੈਕੇਜ ਮੈਨੇਜਰ" ਕਹਿੰਦਾ ਹੈ (ਕਰੂ ਇਸ ਦੇ ਸਮਾਨ ਹੈ ਬਰਿਊ).

Krew kubectl ਪਲੱਗਇਨਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ ਜੋ ਤੁਸੀਂ ਚੁਣ ਸਕਦੇ ਹੋ ਅਤੇ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਦੇ ਨਾਲ ਹੀ, Krew ਵੀ kubectl ਲਈ ਇੱਕ ਪਲੱਗਇਨ ਹੈ।

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕ੍ਰੂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਕਿਸੇ ਹੋਰ kubectl ਪਲੱਗਇਨ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ 'ਤੇ ਵਿਸਤ੍ਰਿਤ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਲੱਭ ਸਕਦੇ ਹੋ GitHub ਪੰਨਾ.

ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਕਰੂ ਕਮਾਂਡਾਂ ਹਨ:

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ Krew ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਲੱਗਇਨ ਸਥਾਪਤ ਕਰਨਾ ਉੱਪਰ ਦੱਸੇ ਗਏ ਮਿਆਰੀ ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਲੱਗਇਨ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਦਖਲ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।

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

ਹੋਰ ਕਿਤੇ ਪਲੱਗਇਨ ਲੱਭ ਰਿਹਾ ਹੈ

ਕ੍ਰੂ ਇੱਕ ਨੌਜਵਾਨ ਪ੍ਰੋਜੈਕਟ ਹੈ, ਜੋ ਇਸ ਸਮੇਂ ਇਸ ਵਿੱਚ ਹੈ ਸੂਚੀ ਸਿਰਫ਼ 30 ਪਲੱਗਇਨ। ਜੇ ਤੁਸੀਂ ਉਹ ਨਹੀਂ ਲੱਭ ਸਕਦੇ ਜੋ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕਿਤੇ ਹੋਰ ਪਲੱਗਇਨ ਲੱਭ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ GitHub।

ਮੈਂ ਗਿਟਹਬ ਸੈਕਸ਼ਨ ਨੂੰ ਦੇਖਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ kubectl-plugins. ਉੱਥੇ ਤੁਹਾਨੂੰ ਦਰਜਨਾਂ ਉਪਲਬਧ ਪਲੱਗਇਨ ਮਿਲਣਗੇ ਜੋ ਦੇਖਣ ਯੋਗ ਹਨ।

ਆਪਣੇ ਖੁਦ ਦੇ ਪਲੱਗਇਨ ਲਿਖਣਾ

ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਕਰ ਸਕਦੇ ਹੋ ਪਲੱਗਇਨ ਬਣਾਓ - ਇਹ ਔਖਾ ਨਹੀਂ ਹੈ। ਤੁਹਾਨੂੰ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਉਹ ਕਰਦਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ, ਇਸਨੂੰ ਨਾਮ ਦਿਓ kubectl-x ਅਤੇ ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ ਇੰਸਟਾਲ ਕਰੋ।

ਫਾਈਲ ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ, ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ, ਜਾਂ ਇੱਕ ਕੰਪਾਇਲ ਕੀਤੀ GO ਐਪਲੀਕੇਸ਼ਨ ਹੋ ਸਕਦੀ ਹੈ - ਇਸ ਨਾਲ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ। ਸਿਰਫ ਸ਼ਰਤ ਇਹ ਹੈ ਕਿ ਇਸਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਚਲੋ ਹੁਣੇ ਇੱਕ ਉਦਾਹਰਣ ਪਲੱਗਇਨ ਬਣਾਈਏ। ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ, ਤੁਸੀਂ ਹਰੇਕ ਪੌਡ ਲਈ ਕੰਟੇਨਰਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਲਈ kubectl ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਸੀ। ਇਸ ਕਮਾਂਡ ਨੂੰ ਪਲੱਗਇਨ ਵਿੱਚ ਬਦਲਣਾ ਆਸਾਨ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ. kubectl img.

ਇੱਕ ਫਾਈਲ ਬਣਾਓ kubectl-img ਹੇਠ ਦਿੱਤੀ ਸਮੱਗਰੀ:

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

ਹੁਣ ਨਾਲ ਫਾਈਲ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਬਣਾਓ chmod +x kubectl-img ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ PATH ਵਿੱਚ ਕਿਸੇ ਵੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਭੇਜੋ। ਇਸ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਤੁਸੀਂ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ kubectl img.

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

ਆਪਣੇ ਪਲੱਗਇਨ ਨੂੰ ਕਿਵੇਂ ਸਾਂਝਾ ਕਰਨਾ ਹੈ

ਜੇ ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਪਲੱਗਇਨ ਦੂਜਿਆਂ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੇ ਹਨ, ਤਾਂ ਇਸਨੂੰ GitHub 'ਤੇ ਸਾਂਝਾ ਕਰਨ ਲਈ ਬੇਝਿਜਕ ਮਹਿਸੂਸ ਕਰੋ। ਉਹਨਾਂ ਨੂੰ ਵਿਸ਼ੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ kubectl-plugins.

ਤੁਸੀਂ ਇਹ ਵੀ ਬੇਨਤੀ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡਾ ਪਲੱਗਇਨ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਵੇ ਕਰੂ ਸੂਚੀ. ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਹਦਾਇਤਾਂ ਵਿੱਚ ਹਨ GitHub ਰਿਪੋਜ਼ਟਰੀਆਂ.

ਕਮਾਂਡ ਦੀ ਪੂਰਤੀ

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

ਇਸ ਫੰਕਸ਼ਨ ਲਈ GitHub kubectl ਰਿਪੋਜ਼ਟਰੀ ਹੈ ਖੁੱਲ੍ਹੀ ਬੇਨਤੀ. ਇਸ ਲਈ ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਭਵਿੱਖ ਵਿੱਚ ਕਿਸੇ ਸਮੇਂ ਲਾਗੂ ਕੀਤੀ ਜਾਵੇਗੀ।

ਖੁਸ਼ਕਿਸਮਤੀ!!!

ਵਿਸ਼ੇ 'ਤੇ ਹੋਰ ਕੀ ਪੜ੍ਹਨਾ ਹੈ:

1. ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਆਟੋਸਕੇਲਿੰਗ ਦੇ ਤਿੰਨ ਪੱਧਰ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ.
2. ਲਾਗੂ ਕਰਨ ਲਈ ਇੱਕ ਨਮੂਨੇ ਦੇ ਨਾਲ ਪਾਇਰੇਸੀ ਦੀ ਭਾਵਨਾ ਵਿੱਚ ਕੁਬਰਨੇਟਸ.
3. ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਾਡਾ ਚੈਨਲ.

ਸਰੋਤ: www.habr.com