🥇 kubectl ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವುದು ಹೇಗೆ: ವಿವರವಾದ ಮಾರ್ಗದರ್ಶಿ

ನೀವು Kubernetes ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, kubectl ಬಹುಶಃ ನೀವು ಹೆಚ್ಚು ಬಳಸುವ ಉಪಯುಕ್ತತೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಮತ್ತು ನೀವು ನಿರ್ದಿಷ್ಟ ಸಾಧನದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಕಳೆಯುವಾಗ, ಅದನ್ನು ಚೆನ್ನಾಗಿ ಅಧ್ಯಯನ ಮಾಡುವುದು ಮತ್ತು ಅದನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಕಲಿಯುವುದು ಪಾವತಿಸುತ್ತದೆ.

ತಂಡದ Mail.ru ನಿಂದ Kubernetes aaS ಡೇನಿಯಲ್ ವೀಬೆಲ್ ಅವರ ಲೇಖನವನ್ನು ಅನುವಾದಿಸಲಾಗಿದೆ, ಇದರಲ್ಲಿ ನೀವು kubectl ನೊಂದಿಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಕಾಣಬಹುದು. ಕುಬರ್ನೆಟ್ಸ್ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಪಡೆಯಲು ಇದು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಲೇಖಕರ ಪ್ರಕಾರ, ಲೇಖನದ ಗುರಿಯು ಕುಬರ್ನೆಟ್ಸ್‌ನೊಂದಿಗೆ ನಿಮ್ಮ ದೈನಂದಿನ ಕೆಲಸವನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುವುದು ಮಾತ್ರವಲ್ಲದೆ ಹೆಚ್ಚು ಆನಂದದಾಯಕವಾಗಿಸುವುದು!

ಪರಿಚಯ: kubectl ಎಂದರೇನು

ನೀವು kubectl ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಕಲಿಯುವ ಮೊದಲು, ಅದು ಏನು ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನೀವು ಮೂಲಭೂತ ತಿಳುವಳಿಕೆಯನ್ನು ಪಡೆಯಬೇಕು.

ಬಳಕೆದಾರರ ದೃಷ್ಟಿಕೋನದಿಂದ, kubectl ಒಂದು ನಿಯಂತ್ರಣ ಫಲಕವಾಗಿದ್ದು ಅದು ಕುಬರ್ನೆಟ್ಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ತಾಂತ್ರಿಕವಾಗಿ ಹೇಳುವುದಾದರೆ, kubectl ಒಂದು Kubernetes API ಕ್ಲೈಂಟ್ ಆಗಿದೆ.

ಕುಬರ್ನೆಟ್ಸ್ API ಒಂದು HTTP REST API ಆಗಿದೆ. ಈ API ನಿಜವಾದ ಕುಬರ್ನೆಟ್ಸ್ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ, ಅದರ ಮೂಲಕ ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ಪ್ರತಿ ಕುಬರ್ನೆಟ್ಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು API ಅಂತಿಮ ಬಿಂದುವಾಗಿ ಬಹಿರಂಗಪಡಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ಅಂತಿಮ ಬಿಂದುವಿಗೆ HTTP ವಿನಂತಿಯೊಂದಿಗೆ ಮಾಡಬಹುದು.

ಆದ್ದರಿಂದ, kubectl ನ ಮುಖ್ಯ ಕೆಲಸವೆಂದರೆ ಕುಬರ್ನೆಟ್ಸ್ API ಗೆ HTTP ವಿನಂತಿಗಳನ್ನು ಮಾಡುವುದು:

ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪೂರ್ಣವಾಗಿ ಸಂಪನ್ಮೂಲ-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಇದರರ್ಥ ಇದು ಸಂಪನ್ಮೂಲಗಳ ಆಂತರಿಕ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಕುಬರ್ನೆಟ್ಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು CRUD ಕಾರ್ಯಾಚರಣೆಗಳಾಗಿವೆ.

ಈ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ ನೀವು ಕುಬರ್ನೆಟ್‌ಗಳ ಸಂಪೂರ್ಣ ನಿಯಂತ್ರಣದಲ್ಲಿದ್ದೀರಿ ಮತ್ತು ಪ್ರಸ್ತುತ ಸಂಪನ್ಮೂಲಗಳ ಸ್ಥಿತಿಯನ್ನು ಆಧರಿಸಿ ಕುಬರ್ನೆಟ್ಸ್ ಏನು ಮಾಡಬೇಕೆಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತಾರೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, ಕುಬರ್ನೆಟ್ಸ್ API ಉಲ್ಲೇಖವನ್ನು ಅವುಗಳ ಸಂಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಸಂಪನ್ಮೂಲ ಪ್ರಕಾರಗಳ ಪಟ್ಟಿಯಾಗಿ ಆಯೋಜಿಸಲಾಗಿದೆ.

ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

ನೀವು ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಹೇಳೋಣ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಹೆಸರಿನ ಮೂಲಕ ಫೈಲ್‌ನಲ್ಲಿ ರೆಪ್ಲಿಕಾಸೆಟ್ ಅನ್ನು ವಿವರಿಸುತ್ತೀರಿ replicaset.yaml, ನಂತರ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

$ kubectl create -f replicaset.yaml

ಇದು ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸುತ್ತದೆ. ಆದರೆ ತೆರೆಮರೆಯಲ್ಲಿ ಏನಾಗುತ್ತದೆ?

ಕುಬರ್ನೆಟ್ಸ್ ರೆಪ್ಲಿಕಾಸೆಟ್ ರಚನೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಹೊಂದಿದೆ. ಯಾವುದೇ ಇತರ ಕಾರ್ಯಾಚರಣೆಯಂತೆ, ಇದು API ಅಂತಿಮ ಬಿಂದುವಾಗಿ ತೆರೆದುಕೊಳ್ಳುತ್ತದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಗೆ ನಿರ್ದಿಷ್ಟ API ಅಂತಿಮ ಬಿಂದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ಎಲ್ಲಾ ಕುಬರ್ನೆಟ್ಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ API ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು API ಉಲ್ಲೇಖ (ಸೇರಿದಂತೆ ಮೇಲಿನ ಅಂತಿಮ ಬಿಂದು) ಅಂತಿಮ ಬಿಂದುವಿಗೆ ನಿಜವಾದ ವಿನಂತಿಯನ್ನು ಮಾಡಲು, ನೀವು ಮೊದಲು API ಸರ್ವರ್ URL ಅನ್ನು API ಉಲ್ಲೇಖದಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾದ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಮಾರ್ಗಗಳಿಗೆ ಸೇರಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ನೀವು ಮೇಲಿನ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, kubectl ಮೇಲಿನ API ಅಂತಿಮ ಬಿಂದುವಿಗೆ HTTP POST ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ನೀವು ಫೈಲ್‌ನಲ್ಲಿ ಒದಗಿಸಿದ ರೆಪ್ಲಿಕಾಸೆಟ್ ವ್ಯಾಖ್ಯಾನ replicaset.yaml, ವಿನಂತಿಯ ದೇಹದಲ್ಲಿ ಕಳುಹಿಸಲಾಗಿದೆ.

ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳಿಗೆ kubectl ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, kubectl ಸೂಕ್ತವಾದ ಕುಬರ್ನೆಟ್ಸ್ API ಅಂತಿಮ ಬಿಂದುಗಳಿಗೆ HTTP ವಿನಂತಿಗಳನ್ನು ಮಾಡುತ್ತದೆ.

ಇಂತಹ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ curlಕುಬರ್ನೆಟ್ಸ್ API ಗೆ HTTP ವಿನಂತಿಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಕಳುಹಿಸುವ ಮೂಲಕ. Kubectl ಸರಳವಾಗಿ Kubernetes API ಅನ್ನು ಬಳಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

ಇದು kubectl ಎಂದರೇನು ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಮೂಲಭೂತ ಅಂಶವಾಗಿದೆ. ಆದರೆ ಪ್ರತಿ kubectl ಬಳಕೆದಾರರು ತಿಳಿದಿರಬೇಕಾದ Kubernetes API ಬಗ್ಗೆ ಬೇರೆ ಏನಾದರೂ ಇದೆ. ಕುಬರ್ನೆಟ್ಸ್‌ನ ಆಂತರಿಕ ಪ್ರಪಂಚವನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡೋಣ.

ಕುಬರ್ನೆಟ್ಸ್ನ ಆಂತರಿಕ ಪ್ರಪಂಚ

ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಪ್ರತ್ಯೇಕ ಪ್ರಕ್ರಿಯೆಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸ್ವತಂತ್ರ ಘಟಕಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ. ಕೆಲವು ಘಟಕಗಳು ಮಾಸ್ಟರ್ ನೋಡ್‌ಗಳಲ್ಲಿ ರನ್ ಆಗುತ್ತವೆ, ಇತರವು ವರ್ಕರ್ ನೋಡ್‌ಗಳಲ್ಲಿ, ಪ್ರತಿಯೊಂದು ಘಟಕವು ತನ್ನದೇ ಆದ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಮುಖ್ಯ ನೋಡ್‌ಗಳಲ್ಲಿನ ಪ್ರಮುಖ ಅಂಶಗಳು ಇಲ್ಲಿವೆ:

ಭಂಡಾರ - ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಇತ್ಯಾದಿ).
API ಸರ್ವರ್ - API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
ನಿಯಂತ್ರಕ ವ್ಯವಸ್ಥಾಪಕ - ಸಂಪನ್ಮೂಲ ಸ್ಥಿತಿಗಳು ವಿಶೇಷಣಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಶೆಡ್ಯೂಲರ್ - ವರ್ಕರ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಪಾಡ್‌ಗಳನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ.

ಮತ್ತು ವರ್ಕರ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಅಂಶ ಇಲ್ಲಿದೆ:

ಕುಬೆಲೆಟ್ - ವರ್ಕಿಂಗ್ ನೋಡ್‌ನಲ್ಲಿ ಕಂಟೇನರ್‌ಗಳ ಉಡಾವಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಈ ಘಟಕಗಳು ಹೇಗೆ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

ನೀವು ಇದೀಗ ಪೂರ್ಣಗೊಳಿಸಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ kubectl create -f replicaset.yaml, ಅದರ ನಂತರ kubectl ಒಂದು HTTP POST ವಿನಂತಿಯನ್ನು ಮಾಡಿದೆ ರೆಪ್ಲಿಕಾಸೆಟ್ API ಅಂತಿಮ ಬಿಂದು (ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನವನ್ನು ಹಾದುಹೋಗುವುದು).

ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ?

ಮಾಡಿದ ನಂತರ kubectl create -f replicaset.yaml API ಸರ್ವರ್ ನಿಮ್ಮ ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನವನ್ನು ಶೇಖರಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ:
ಮುಂದೆ, ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವನ್ನು ನಿಯಂತ್ರಕ ನಿರ್ವಾಹಕದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ, ಇದು ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲಗಳ ರಚನೆ, ಮಾರ್ಪಾಡು ಮತ್ತು ಅಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:
ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವು ಪ್ರತಿ ರೆಪ್ಲಿಕಾಸೆಟ್ ಪ್ರತಿಕೃತಿಗೆ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ರಚಿಸುತ್ತದೆ (ರೆಪ್ಲಿಕಾಸೆಟ್ ವ್ಯಾಖ್ಯಾನದಲ್ಲಿನ ಪಾಡ್ ಟೆಂಪ್ಲೇಟ್ ಪ್ರಕಾರ) ಮತ್ತು ಅವುಗಳನ್ನು ಶೇಖರಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ:
ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಇದುವರೆಗೆ ಯಾವುದೇ ವರ್ಕರ್ ನೋಡ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸದ ಪಾಡ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ:
ಶೆಡ್ಯೂಲರ್ ಪ್ರತಿ ಪಾಡ್‌ಗೆ ಸೂಕ್ತವಾದ ವರ್ಕರ್ ನೋಡ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಅಂಗಡಿಯಲ್ಲಿನ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಈ ಮಾಹಿತಿಯನ್ನು ಸೇರಿಸುತ್ತಾರೆ:
ಪಾಡ್ ನಿಯೋಜಿಸಲಾದ ವರ್ಕರ್ ನೋಡ್‌ನಲ್ಲಿ, ಕುಬೆಲೆಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ, ಇದು ಈ ನೋಡ್‌ಗೆ ನಿಯೋಜಿಸಲಾದ ಪಾಡ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ:
ಕುಬೆಲೆಟ್ ಸಂಗ್ರಹಣೆಯಿಂದ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ನೋಡ್‌ನಲ್ಲಿ ಕಂಟೇನರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಡಾಕರ್‌ನಂತಹ ಕಂಟೇನರ್ ರನ್‌ಟೈಮ್‌ಗೆ ಸೂಚನೆ ನೀಡುತ್ತದೆ:

ಈ ವಿವರಣೆಯ ಪಠ್ಯ ಆವೃತ್ತಿಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ರೆಪ್ಲಿಕಾಸೆಟ್ ರಚನೆಯ ಅಂತಿಮ ಬಿಂದುವಿಗೆ API ವಿನಂತಿಯನ್ನು API ಸರ್ವರ್‌ನಿಂದ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ. API ಸರ್ವರ್ ವಿನಂತಿಯನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ReplicaSet ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ಈ ಈವೆಂಟ್ ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಇದು ನಿಯಂತ್ರಕ ವ್ಯವಸ್ಥಾಪಕರ ಉಪಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವು ಅಂಗಡಿಯಲ್ಲಿನ ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲಗಳ ರಚನೆ, ನವೀಕರಣ ಮತ್ತು ಅಳಿಸುವಿಕೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇದು ಸಂಭವಿಸಿದಾಗ ಈವೆಂಟ್ ಅಧಿಸೂಚನೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.

ಅಗತ್ಯವಿರುವ ಸಂಖ್ಯೆಯ ರೆಪ್ಲಿಕಾಸೆಟ್ ಪಾಡ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕದ ಕೆಲಸವಾಗಿದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಯಾವುದೇ ಪಾಡ್‌ಗಳು ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ, ಆದ್ದರಿಂದ ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವು ಈ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ರಚಿಸುತ್ತದೆ (ರೆಪ್ಲಿಕಾಸೆಟ್ ವ್ಯಾಖ್ಯಾನದಲ್ಲಿನ ಪಾಡ್ ಟೆಂಪ್ಲೇಟ್ ಪ್ರಕಾರ) ಮತ್ತು ಅವುಗಳನ್ನು ಶೇಖರಣೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ಹೊಸ ಪಾಡ್‌ಗಳ ರಚನೆಯು ಶೆಡ್ಯೂಲರ್‌ನಿಂದ ಪ್ರಚೋದಿಸಲ್ಪಡುತ್ತದೆ, ಅದು ವರ್ಕರ್ ನೋಡ್‌ಗಳಿಗೆ ಇನ್ನೂ ನಿಗದಿಪಡಿಸದ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಶೆಡ್ಯೂಲರ್ ಪ್ರತಿ ಪಾಡ್‌ಗೆ ಸೂಕ್ತವಾದ ವರ್ಕರ್ ನೋಡ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಪಾಡ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ನವೀಕರಿಸುತ್ತಾರೆ.

ಈ ಹಂತದವರೆಗೆ, ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಎಲ್ಲಿಯೂ ವರ್ಕ್‌ಲೋಡ್ ಕೋಡ್ ಚಾಲನೆಯಲ್ಲಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇಲ್ಲಿಯವರೆಗೆ ಮಾಡಿರುವುದು ಎಲ್ಲವೂ - ಇದು ಮಾಸ್ಟರ್ ನೋಡ್‌ನಲ್ಲಿನ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳ ರಚನೆ ಮತ್ತು ನವೀಕರಣವಾಗಿದೆ.

ಕೊನೆಯ ಈವೆಂಟ್ ಕುಬೆಲೆಟ್‌ಗಳನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ, ಇದು ಅವರ ವರ್ಕರ್ ನೋಡ್‌ಗಳಿಗೆ ನಿಗದಿಪಡಿಸಲಾದ ಪಾಡ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ರೆಪ್ಲಿಕಾಸೆಟ್ ಪಾಡ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿರುವ ವರ್ಕರ್ ನೋಡ್‌ನ ಕುಬೆಲೆಟ್ ಅಗತ್ಯವಿರುವ ಕಂಟೇನರ್ ಚಿತ್ರಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಅವುಗಳನ್ನು ರನ್ ಮಾಡಲು ಡಾಕರ್‌ನಂತಹ ಕಂಟೇನರ್ ರನ್‌ಟೈಮ್‌ಗೆ ಸೂಚಿಸಬೇಕು.

ಈ ಹಂತದಲ್ಲಿ, ನಿಮ್ಮ ರೆಪ್ಲಿಕಾಸೆಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅಂತಿಮವಾಗಿ ಚಾಲನೆಯಲ್ಲಿದೆ!

ಕುಬರ್ನೆಟ್ಸ್ API ನ ಪಾತ್ರ

ನೀವು ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ನೋಡಿದಂತೆ, ಕುಬರ್ನೆಟ್ಸ್ ಘಟಕಗಳು (API ಸರ್ವರ್ ಮತ್ತು ಸಂಗ್ರಹಣೆಯನ್ನು ಹೊರತುಪಡಿಸಿ) ಸಂಗ್ರಹಣೆಯಲ್ಲಿನ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ವೀಕ್ಷಿಸುತ್ತವೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯಲ್ಲಿನ ಸಂಪನ್ಮೂಲಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತವೆ.

ಸಹಜವಾಗಿ, ಈ ಘಟಕಗಳು ನೇರವಾಗಿ ಸಂಗ್ರಹಣೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವುದಿಲ್ಲ, ಆದರೆ ಕುಬರ್ನೆಟ್ಸ್ API ಮೂಲಕ ಮಾತ್ರ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳನ್ನು ಪರಿಗಣಿಸಿ:

ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವು API ಅಂತಿಮ ಬಿಂದುವನ್ನು ಬಳಸುತ್ತದೆ ರೆಪ್ಲಿಕಾಸೆಟ್‌ಗಳ ಪಟ್ಟಿ ನಿಯತಾಂಕದೊಂದಿಗೆ watch ರೆಪ್ಲಿಕಾಸೆಟ್ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು.
ರೆಪ್ಲಿಕಾಸೆಟ್ ನಿಯಂತ್ರಕವು API ಅಂತಿಮ ಬಿಂದುವನ್ನು ಬಳಸುತ್ತದೆ ಪಾಡ್ ರಚಿಸಿ ಪಾಡ್‌ಗಳನ್ನು ರಚಿಸಲು (ಪಾಡ್ ರಚಿಸಿ).
ಶೆಡ್ಯೂಲರ್ API ಅಂತಿಮ ಬಿಂದುವನ್ನು ಬಳಸುತ್ತದೆ ಪ್ಯಾಚ್ ಪಾಡ್ (ಪಾಡ್ ಎಡಿಟ್ ಮಾಡಿ) ಆಯ್ದ ವರ್ಕರ್ ನೋಡ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯೊಂದಿಗೆ ಪಾಡ್‌ಗಳನ್ನು ನವೀಕರಿಸಲು.

ನೀವು ನೋಡುವಂತೆ, ಇದು kubectl ಪ್ರವೇಶಿಸುವ ಅದೇ API ಆಗಿದೆ. ಆಂತರಿಕ ಘಟಕಗಳು ಮತ್ತು ಬಾಹ್ಯ ಬಳಕೆದಾರರಿಗೆ ಒಂದೇ API ಅನ್ನು ಬಳಸುವುದು ಕುಬರ್ನೆಟ್ಸ್ ವಿನ್ಯಾಸದಲ್ಲಿ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.

ಕುಬರ್ನೆಟ್ಸ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈಗ ನಾವು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಬಹುದು:

ಶೇಖರಣಾ ಮಳಿಗೆಗಳು ಹೇಳುತ್ತವೆ, ಅಂದರೆ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳು.
API ಸರ್ವರ್ ಕುಬರ್ನೆಟ್ಸ್ API ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಣೆಗೆ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಎಲ್ಲಾ ಇತರ ಕುಬರ್ನೆಟ್ಸ್ ಘಟಕಗಳು ಮತ್ತು ಬಳಕೆದಾರರು API ಮೂಲಕ ಕುಬರ್ನೆಟ್ಸ್ ಸ್ಥಿತಿಯನ್ನು (ಸಂಪನ್ಮೂಲಗಳು) ಓದುತ್ತಾರೆ, ವೀಕ್ಷಿಸುತ್ತಾರೆ ಮತ್ತು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುತ್ತಾರೆ.

ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ ನೀವು kubectl ಅನ್ನು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಪಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಈಗ ನಾವು kubectl ನೊಂದಿಗೆ ನಿಮ್ಮ ಉತ್ಪಾದಕತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುವ ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ನೋಡೋಣ.

1. ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಇನ್‌ಪುಟ್ ಅನ್ನು ವೇಗಗೊಳಿಸಿ

kubectl ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸಲು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾದ, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಕಡೆಗಣಿಸಲ್ಪಡುವ ತಂತ್ರವೆಂದರೆ ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ.

ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಟ್ಯಾಬ್ ಕೀಲಿಯನ್ನು ಬಳಸಿಕೊಂಡು kubectl ಆಜ್ಞೆಗಳ ಭಾಗಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪೂರ್ಣಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಉಪಕಮಾಂಡ್‌ಗಳು, ಆಯ್ಕೆಗಳು ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಿಗಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಸಂಪನ್ಮೂಲ ಹೆಸರುಗಳಂತಹ ಸಂಕೀರ್ಣವಾದದ್ದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

kubectl ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಿ:

Bash ಮತ್ತು Zsh ಶೆಲ್‌ಗಳಿಗೆ ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಅಧಿಕೃತ ಮಾರ್ಗದರ್ಶಿ ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿಸಲು ವಿವರವಾದ ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಆದರೆ ಕೆಳಗೆ ನಾವು ಒಂದು ಸಣ್ಣ ಆಯ್ದ ಭಾಗವನ್ನು ಒದಗಿಸುತ್ತೇವೆ.

ಆಜ್ಞೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಶೆಲ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು ಅದು ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ವಿಸ್ತರಣಾ ಸ್ಕ್ರಿಪ್ಟ್ ಎನ್ನುವುದು ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದ್ದು ಅದು ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಗಾಗಿ ವಿಸ್ತರಣೆಯ ನಡವಳಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.

ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು Kubectl ಸ್ವಯಂಚಾಲಿತವಾಗಿ Bash ಮತ್ತು Zsh ಗಾಗಿ ವಿಸ್ತರಣೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ:

$ kubectl completion bash

ಅಥವಾ:

$ kubectl completion zsh

ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಈ ಆಜ್ಞೆಗಳ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸೂಕ್ತವಾದ ಕಮಾಂಡ್ ಶೆಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಸಾಕು, ಇದರಿಂದಾಗಿ kubectl ಆಜ್ಞೆಗಳಿಗೆ ಪೂರಕವಾಗಿರುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಸಂಪರ್ಕ ವಿಧಾನವು Bash (Linux ಮತ್ತು MacOS ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಒಳಗೊಂಡಂತೆ) ಮತ್ತು Zsh ಗೆ ವಿಭಿನ್ನವಾಗಿದೆ. ಕೆಳಗೆ ನಾವು ಈ ಎಲ್ಲಾ ಆಯ್ಕೆಗಳನ್ನು ನೋಡುತ್ತೇವೆ.

Linux ನಲ್ಲಿ ಬಾಷ್

ಬ್ಯಾಷ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ಮೊದಲು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ:

$ sudo apt-get install bash-completion

ಅಥವಾ:

$ yum install bash-completion

ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ಪರೀಕ್ಷಿಸಬಹುದು:

$ type _init_completion

ಇದು ಶೆಲ್ ಫಂಕ್ಷನ್ ಕೋಡ್ ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಿದರೆ, ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಆಜ್ಞೆಯು "ಕಂಡುಬಂದಿಲ್ಲ" ದೋಷವನ್ನು ನೀಡಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಸಾಲನ್ನು ನಿಮ್ಮ ಫೈಲ್‌ಗೆ ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ ~ / .bashrc:

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

ಈ ಸಾಲನ್ನು ಫೈಲ್‌ಗೆ ಸೇರಿಸುವುದು ಅಗತ್ಯವೇ? ~ / .bashrc ಅಥವಾ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸಲು ನೀವು ಬಳಸಿದ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಇದು APT ಗೆ ಅವಶ್ಯಕವಾಗಿದೆ, ಆದರೆ YUM ಗೆ ಅಲ್ಲ.

bash-completion ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನೀವು ಎಲ್ಲವನ್ನೂ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಶೆಲ್ ಸೆಷನ್‌ಗಳಲ್ಲಿ kubectl ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಇದನ್ನು ಮಾಡಲು ಒಂದು ಮಾರ್ಗವೆಂದರೆ ಕೆಳಗಿನ ಸಾಲನ್ನು ಫೈಲ್‌ಗೆ ಸೇರಿಸುವುದು ~ / .bashrc:

source <(kubectl completion bash)

ಇನ್ನೊಂದು ಮಾರ್ಗವೆಂದರೆ kubectl ವಿಸ್ತರಣೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಡೈರೆಕ್ಟರಿಗೆ ಸೇರಿಸುವುದು /etc/bash_completion.d (ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ರಚಿಸಿ):

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

ಕ್ಯಾಟಲಾಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಆಡ್-ಆನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು /etc/bash_completion.d ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.

ಎರಡೂ ಆಯ್ಕೆಗಳು ಸಮಾನವಾಗಿ ಅನ್ವಯಿಸುತ್ತವೆ.

ಶೆಲ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿದ ನಂತರ, kubectl ಆಜ್ಞೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

MacOS ನಲ್ಲಿ ಬ್ಯಾಷ್

MacOS ನಲ್ಲಿ ಸೆಟಪ್ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ. ವಾಸ್ತವವೆಂದರೆ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, MacOS Bash ಆವೃತ್ತಿ 3.2 ಅನ್ನು ಬಳಸುತ್ತದೆ, ಮತ್ತು kubectl ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಕನಿಷ್ಠ 4.1 ರ ಬ್ಯಾಷ್ ಆವೃತ್ತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಷ್ 3.2 ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.

MacOS ನಲ್ಲಿ Bash ನ ಹಳೆಯ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುವುದರೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಪರವಾನಗಿ ಸಮಸ್ಯೆಗಳಿವೆ. Bash ಆವೃತ್ತಿ 4 GPLv3 ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿ ಪಡೆದಿದೆ, ಇದನ್ನು Apple ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

MacOS ನಲ್ಲಿ kubectl ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು, ನೀವು Bash ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿದೆ. ನೀವು ನವೀಕರಿಸಿದ ಬ್ಯಾಷ್ ಅನ್ನು ನಿಮ್ಮ ಡೀಫಾಲ್ಟ್ ಶೆಲ್ ಆಗಿ ಹೊಂದಿಸಬಹುದು, ಇದು ಭವಿಷ್ಯದಲ್ಲಿ ನಿಮಗೆ ಬಹಳಷ್ಟು ಸಮಸ್ಯೆಗಳನ್ನು ಉಳಿಸುತ್ತದೆ. ಇದು ಕಷ್ಟವೇನಲ್ಲ, ವಿವರಗಳನ್ನು ಲೇಖನದಲ್ಲಿ ನೀಡಲಾಗಿದೆ "MacOS ನಲ್ಲಿ ಬ್ಯಾಷ್ ಅನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ».

ಮುಂದುವರಿಯುವ ಮೊದಲು, ನೀವು ಬ್ಯಾಷ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ (ಔಟ್‌ಪುಟ್ ಪರಿಶೀಲಿಸಿ bash --version).

ಬ್ಯಾಷ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಸ್ಕ್ರಿಪ್ಟ್ ಯೋಜನೆಯ ಪ್ರಕಾರ ಬದಲಾಗುತ್ತದೆ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ, ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ಮೊದಲು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ.

ನೀವು ಬಳಸಿ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸಬಹುದು ಹೋಂಬ್ರೆವ್:

$ brew install bash-completion@2

ಇದು @2 ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಆವೃತ್ತಿ 2. kubectl ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಗೆ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ v2 ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ v2 ಗೆ ಕನಿಷ್ಠ Bash ಆವೃತ್ತಿ 4.1 ಅಗತ್ಯವಿದೆ.

ಕಮಾಂಡ್ ಔಟ್ಪುಟ್ brew-install ಒಂದು ಕೇವಿಯಟ್ಸ್ ವಿಭಾಗವನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಫೈಲ್‌ಗೆ ಏನನ್ನು ಸೇರಿಸಬೇಕು ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ ~/.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 ಬಳಸಿಕೊಂಡು ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸಿದರೆ ಮಾತ್ರ ಈ ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಈ ಡೈರೆಕ್ಟರಿಯಿಂದ ಎಲ್ಲಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ.

ನೀವು ಸ್ಥಾಪಿಸಿದರೆ kubectl Homebrew ಬಳಸಿ, ನಂತರ ಹಿಂದಿನ ಹಂತವನ್ನು ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ /usr/local/etc/bash_completion.d ಅನುಸ್ಥಾಪನೆಯ ಸಮಯದಲ್ಲಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸಿದ ತಕ್ಷಣ kubectl ಸ್ವಯಂಪೂರ್ಣತೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಪರಿಣಾಮವಾಗಿ, ಈ ಎಲ್ಲಾ ಆಯ್ಕೆಗಳು ಸಮಾನವಾಗಿವೆ.

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 ಅಭಿವ್ಯಕ್ತಿಗಳು

ಸಂಪನ್ಮೂಲ ಕ್ಷೇತ್ರಗಳನ್ನು ಆಯ್ಕೆಮಾಡಲು ಅಭಿವ್ಯಕ್ತಿಗಳು ಆಧರಿಸಿವೆ JSONಪಥ್.

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'

[] ಆಪರೇಟರ್ ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ. ಅನೇಕ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲ ಕ್ಷೇತ್ರಗಳು ಪಟ್ಟಿಗಳಾಗಿವೆ ಮತ್ತು ಆ ಪಟ್ಟಿಗಳ ಸದಸ್ಯರನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಈ ಆಪರೇಟರ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಪಟ್ಟಿಯ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಇದನ್ನು [*] ನಂತಹ ವೈಲ್ಡ್‌ಕಾರ್ಡ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಅಪ್ಲಿಕೇಶನ್ ಉದಾಹರಣೆಗಳು

ಕಸ್ಟಮ್ ಕಾಲಮ್ ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪವನ್ನು ಬಳಸುವ ಸಾಧ್ಯತೆಗಳು ಅಂತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ನೀವು ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಯಾವುದೇ ಕ್ಷೇತ್ರ ಅಥವಾ ಸಂಪನ್ಮೂಲ ಕ್ಷೇತ್ರಗಳ ಸಂಯೋಜನೆಯನ್ನು ಪ್ರದರ್ಶಿಸಬಹುದು. ಕೆಲವು ಮಾದರಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಇಲ್ಲಿವೆ, ಆದರೆ ಅವುಗಳನ್ನು ನೀವೇ ಅನ್ವೇಷಿಸಲು ಮತ್ತು ನಿಮಗಾಗಿ ಕೆಲಸ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹುಡುಕಲು ಮುಕ್ತವಾಗಿರಿ.

ಪಾಡ್‌ಗಳಿಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತಿದೆ:
```
$ 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
```
ಈ ಆಜ್ಞೆಯು ಪ್ರತಿ ಪಾಡ್‌ಗೆ ಕಂಟೇನರ್ ಇಮೇಜ್ ಹೆಸರುಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಒಂದು ಪಾಡ್ ಹಲವಾರು ಧಾರಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ, ನಂತರ ಚಿತ್ರದ ಹೆಸರುಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಿ ಒಂದು ಸಾಲಿನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ನೋಡ್ ಲಭ್ಯತೆಯ ವಲಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತಿದೆ:
```
$ 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. ಕ್ಲಸ್ಟರ್ ಸಾರ್ವಜನಿಕ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ, ಈ ಲೇಬಲ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ನೋಡ್‌ಗೆ ಲಭ್ಯತೆಯ ವಲಯಗಳ ಹೆಸರುಗಳಿಂದ ತುಂಬಿಸಲಾಗುತ್ತದೆ.

ಲೇಬಲ್‌ಗಳು ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲ ವಿವರಣೆಯ ಭಾಗವಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಅವುಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗುವುದಿಲ್ಲ API ಮಾರ್ಗದರ್ಶಿ. ಆದಾಗ್ಯೂ, ನೀವು YAML ಅಥವಾ JSON ಸ್ವರೂಪದಲ್ಲಿ ನೋಡ್‌ಗಳ ಕುರಿತು ಮಾಹಿತಿಯನ್ನು ವಿನಂತಿಸಿದರೆ ಅವುಗಳನ್ನು (ಯಾವುದೇ ಲೇಬಲ್‌ಗಳಂತೆ) ನೋಡಬಹುದು:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
ಸಂಪನ್ಮೂಲ ವಿಶೇಷಣಗಳನ್ನು ಕಲಿಯುವುದರ ಜೊತೆಗೆ ಸಂಪನ್ಮೂಲಗಳ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಇದು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.

4. ಕ್ಲಸ್ಟರ್‌ಗಳು ಮತ್ತು ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳ ನಡುವೆ ಸುಲಭವಾಗಿ ಬದಲಿಸಿ

Kubectl Kubernetes API ಗೆ ವಿನಂತಿಯನ್ನು ಮಾಡಿದಾಗ, ಸಂಪರ್ಕಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ಪಡೆಯಲು ಅದು ಮೊದಲು kubeconfig ಫೈಲ್ ಅನ್ನು ಓದುತ್ತದೆ.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ kubeconfig ಫೈಲ್ ಆಗಿದೆ ~/.kube/config. ವಿಶಿಷ್ಟವಾಗಿ ಈ ಫೈಲ್ ಅನ್ನು ವಿಶೇಷ ಆಜ್ಞೆಯಿಂದ ರಚಿಸಲಾಗಿದೆ ಅಥವಾ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ನೀವು ಬಹು ಕ್ಲಸ್ಟರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ನಿಮ್ಮ kubeconfig ಫೈಲ್ ಆ ಎಲ್ಲಾ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲು ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನೀವು ಯಾವ ಕ್ಲಸ್ಟರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು kubectl ಆಜ್ಞೆಗೆ ಹೇಳಲು ನಿಮಗೆ ಒಂದು ಮಾರ್ಗ ಬೇಕು.

ಒಂದು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ, ನೀವು ಬಹು ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು-ಭೌತಿಕ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಒಂದು ರೀತಿಯ ವರ್ಚುವಲ್ ಕ್ಲಸ್ಟರ್. kubeconfig ಫೈಲ್ ಅನ್ನು ಆಧರಿಸಿ ಯಾವ ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಬಳಸಬೇಕೆಂದು Kubectl ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದರರ್ಥ kubectl ಆಜ್ಞೆಗೆ ಯಾವ ನೇಮ್‌ಸ್ಪೇಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ಹೇಳಲು ನಿಮಗೆ ಒಂದು ಮಾರ್ಗ ಬೇಕು.

ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕೆಲಸ ಮಾಡುವುದು ಎಂಬುದನ್ನು ನಾವು ವಿವರಿಸುತ್ತೇವೆ.

KUBECONFIG ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ನೀವು ಬಹು kubeconfig ಫೈಲ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿರಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಒಂದು ಸಾಮಾನ್ಯ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ. ನಿಯತಾಂಕದೊಂದಿಗೆ kubectl ಅನ್ನು ಚಾಲನೆ ಮಾಡುವ ಮೂಲಕ ನೀವು ಡೀಫಾಲ್ಟ್ kubeconfig ಫೈಲ್ ಅನ್ನು ಸಹ ಬದಲಾಯಿಸಬಹುದು --kubeconfig. ನೋಡು ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು.

kubeconfig ಫೈಲ್‌ಗಳು

kubeconfig ಫೈಲ್ ನಿಖರವಾಗಿ ಏನನ್ನು ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ:

ನೀವು ನೋಡುವಂತೆ, kubeconfig ಫೈಲ್ ಸಂದರ್ಭಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ. ಸನ್ನಿವೇಶವು ಮೂರು ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

ಕ್ಲಸ್ಟರ್ - ಕ್ಲಸ್ಟರ್ ಸರ್ವರ್‌ನ API URL.
ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಬಳಕೆದಾರ - ಬಳಕೆದಾರ ದೃಢೀಕರಣ ರುಜುವಾತುಗಳು.
ನೇಮ್‌ಸ್ಪೇಸ್ - ಕ್ಲಸ್ಟರ್‌ಗೆ ಸೇರುವಾಗ ಬಳಸುವ ನೇಮ್‌ಸ್ಪೇಸ್.

ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಅವರು ತಮ್ಮ kubeconfig ನಲ್ಲಿ ಪ್ರತಿ ಕ್ಲಸ್ಟರ್‌ಗೆ ಒಂದು ಸಂದರ್ಭವನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸುತ್ತಾರೆ. ಆದಾಗ್ಯೂ, ನೀವು ಪ್ರತಿ ಕ್ಲಸ್ಟರ್‌ಗೆ ಬಹು ಸಂದರ್ಭಗಳನ್ನು ಹೊಂದಬಹುದು, ಬಳಕೆದಾರ ಅಥವಾ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಿಂದ ಪ್ರತ್ಯೇಕಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಈ ಬಹು-ಸಂದರ್ಭ ಸಂರಚನೆಯು ಅಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಲಸ್ಟರ್‌ಗಳು ಮತ್ತು ಸಂದರ್ಭಗಳ ನಡುವೆ ಒಂದರಿಂದ ಒಂದು ಮ್ಯಾಪಿಂಗ್ ಇರುತ್ತದೆ.

ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಒಂದು ಪ್ರಸ್ತುತವಾಗಿದೆ:

kubectl ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಓದಿದಾಗ, ಅದು ಯಾವಾಗಲೂ ಪ್ರಸ್ತುತ ಸಂದರ್ಭದಿಂದ ಮಾಹಿತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, kubectl Hare ಕ್ಲಸ್ಟರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ.

ಅಂತೆಯೇ, ಮತ್ತೊಂದು ಕ್ಲಸ್ಟರ್‌ಗೆ ಬದಲಾಯಿಸಲು, ನೀವು kubeconfig ಫೈಲ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಸಂದರ್ಭವನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ:

ಈಗ kubectl ಫಾಕ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ.

ಒಂದೇ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಬೇರೆ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ಬದಲಾಯಿಸಲು, ಪ್ರಸ್ತುತ ಸಂದರ್ಭಕ್ಕಾಗಿ ನೀವು ನೇಮ್‌ಸ್ಪೇಸ್ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ:

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, 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 ಅನ್ನು ಬಳಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ (kubectx ನ ಸಂವಾದಾತ್ಮಕ ಮೋಡ್‌ನಂತೆ). ಇದರರ್ಥ ನಿಮಗೆ ಬೇಕು 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 ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಬದಲಾಯಿಸಲು.

ಇದನ್ನು ಮಾಡುವ ಎರಡು ಪ್ಲಗಿನ್‌ಗಳನ್ನು ನಾನು ಬರೆದಿದ್ದೇನೆ:

ಪ್ಲಗಿನ್‌ಗಳ ಕೆಲಸವು ಹಿಂದಿನ ವಿಭಾಗದಿಂದ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಆಧರಿಸಿದೆ.

ಅವರು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಸಂವಾದಾತ್ಮಕ ಉಚಿತ ಹುಡುಕಾಟ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಒದಗಿಸಲು ಪ್ಲಗಿನ್‌ಗಳು fzf ಅನ್ನು ಬಳಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ (kubectx ನ ಸಂವಾದಾತ್ಮಕ ಮೋಡ್‌ನಂತೆ). ಇದರರ್ಥ ನಿಮಗೆ ಬೇಕು fzf ಅನ್ನು ಸ್ಥಾಪಿಸಿಈ ಉಪನಾಮಗಳನ್ನು ಬಳಸಲು.

ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು, ನೀವು ಹೆಸರಿನ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ kubectl-ctx и kubectl-ns ನಿಮ್ಮ PATH ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿನ ಯಾವುದೇ ಡೈರೆಕ್ಟರಿಗೆ ಮತ್ತು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಂತೆ ಮಾಡಿ ಉದಾ. chmod +x. ಇದರ ನಂತರ ತಕ್ಷಣವೇ ನೀವು ಬಳಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ kubectl ctx и kubectl ns.

5. ಆಟೋಲಿಯಾಸ್‌ಗಳೊಂದಿಗೆ ಇನ್‌ಪುಟ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿ

ಶೆಲ್ ಅಲಿಯಾಸ್ ಇನ್‌ಪುಟ್ ಅನ್ನು ವೇಗಗೊಳಿಸಲು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ. ಯೋಜನೆ kubectl-ಅಲಿಯಾಸ್ ಮೂಲಭೂತ kubectl ಆದೇಶಗಳಿಗಾಗಿ ಸುಮಾರು 800 ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ನೀವು ಆಶ್ಚರ್ಯ ಪಡಬಹುದು - ನೀವು 800 ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಹೇಗೆ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೀರಿ? ಆದರೆ ನೀವು ಎಲ್ಲವನ್ನೂ ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಅವುಗಳನ್ನು ಸರಳವಾದ ಯೋಜನೆಯ ಪ್ರಕಾರ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಅದನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

ಉದಾಹರಣೆಗೆ:

ಕೆಜಿಪೂಯಂಲ್ - ಕುಬೆಕ್ಟ್ಲ್ ಪಾಡ್ಸ್ ಒಯಾಮ್ಲ್ ಪಡೆಯಿರಿ
ksysgsvcw — kubectl -n kube-system get svc w
ksysrmcm -kubectl -n kube-system rm cm
kgdepallsl - kubectl ಎಲ್ಲಾ SL ನಿಯೋಜನೆಯನ್ನು ಪಡೆಯಿರಿ

ನೀವು ನೋಡುವಂತೆ, ಅಲಿಯಾಸ್ ಘಟಕಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟಿದೆ, ಪ್ರತಿಯೊಂದೂ kubectl ಆಜ್ಞೆಯ ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಅಲಿಯಾಸ್ ಮೂಲ ಆಜ್ಞೆ, ಕಾರ್ಯಾಚರಣೆ ಮತ್ತು ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ ಒಂದು ಘಟಕವನ್ನು ಹೊಂದಬಹುದು ಮತ್ತು ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಬಹು ಘಟಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಮೇಲಿನ ರೇಖಾಚಿತ್ರದ ಪ್ರಕಾರ ನೀವು ಈ ಘಟಕಗಳನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಸರಳವಾಗಿ "ಜನಪ್ರಿಯಗೊಳಿಸು".

ಪ್ರಸ್ತುತ ವಿವರವಾದ ರೇಖಾಚಿತ್ರವು ನಲ್ಲಿದೆ GitHub. ಅಲ್ಲಿ ನೀವು ಸಹ ಕಾಣಬಹುದು ಅಲಿಯಾಸ್‌ಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ.

ಉದಾಹರಣೆಗೆ, ಕೆಜಿಪೂಯಂಲಾಲ್ ಎಂಬ ಅಲಿಯಾಸ್ ಆಜ್ಞೆಗೆ ಸಮನಾಗಿರುತ್ತದೆ kubectl get pods -o yaml --all-namespaces.

ಆಯ್ಕೆಗಳ ಸಂಬಂಧಿತ ಕ್ರಮವು ಮುಖ್ಯವಲ್ಲ: ಆಜ್ಞೆ kgpooyamlall ಆಜ್ಞೆಗೆ ಸಮನಾಗಿರುತ್ತದೆ kgpoalloyaml.

ನೀವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಅಲಿಯಾಸ್‌ಗಳಾಗಿ ಬಳಸಬೇಕಾಗಿಲ್ಲ. ಉದಾಹರಣೆಗೆ k, kg, klo, ksys, kgpo ಸಹ ಬಳಸಬಹುದು. ಇದಲ್ಲದೆ, ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಅಲಿಯಾಸ್ ಮತ್ತು ನಿಯಮಿತ ಆಜ್ಞೆಗಳು ಅಥವಾ ಆಯ್ಕೆಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು:

ಉದಾಹರಣೆಗೆ:

ಬದಲಾಗಿ kubectl proxy ನೀವು ಬರೆಯಬಹುದು k proxy.
ಬದಲಾಗಿ kubectl get roles ನೀವು ಬರೆಯಬಹುದು kg roles (ಪ್ರಸ್ತುತ ಪಾತ್ರಗಳ ಸಂಪನ್ಮೂಲಕ್ಕೆ ಯಾವುದೇ ಅಲಿಯಾಸ್ ಇಲ್ಲ).
ನಿರ್ದಿಷ್ಟ ಪಾಡ್‌ಗಾಗಿ ಡೇಟಾವನ್ನು ಪಡೆಯಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು 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 ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಬಳಸಿದರೆ, ಸಂಪನ್ಮೂಲ ಹೆಸರುಗಳಂತಹ ವಿಷಯಗಳಿಗಾಗಿ ನೀವು ಬಹುಶಃ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಬಳಸಿದ್ದೀರಿ. ಆದರೆ ಅಲಿಯಾಸ್ ಬಳಸಿದಾಗ ಇದನ್ನು ಮಾಡಬಹುದೇ?

ಇದು ಬಹಳ ಮುಖ್ಯವಾದ ಪ್ರಶ್ನೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ನೀವು ಅಲಿಯಾಸ್‌ಗಳ ಕೆಲವು ಪ್ರಯೋಜನಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ.

ಉತ್ತರವು ನೀವು ಯಾವ ಶೆಲ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ:

Zsh ಗಾಗಿ, ಅಲಿಯಾಸ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಬ್ಯಾಷ್‌ಗಾಗಿ, ದುರದೃಷ್ಟವಶಾತ್, ಕೆಲಸ ಮಾಡಲು ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಪಡೆಯಲು ಕೆಲವು ಕೆಲಸದ ಅಗತ್ಯವಿದೆ.

ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಅಲಿಯಾಸ್‌ಗಳಿಗಾಗಿ ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ಬ್ಯಾಷ್‌ನ ಸಮಸ್ಯೆಯೆಂದರೆ ಅದು ಅಲಿಯಾಸ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು (ಪ್ರತಿ ಬಾರಿ ನೀವು ಟ್ಯಾಬ್ ಅನ್ನು ಒತ್ತಿ) ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಅಲಿಯಾಸ್ ಸೂಚಿಸುವ ಆಜ್ಞೆಯನ್ನು ಅಲ್ಲ (ಉದಾಹರಣೆಗೆ Zsh ಮಾಡುವಂತೆ). ಎಲ್ಲಾ 800 ಅಲಿಯಾಸ್‌ಗಳಿಗೆ ನೀವು ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿಲ್ಲದಿರುವುದರಿಂದ, ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.

ಯೋಜನೆಯು ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಈ ಸಮಸ್ಯೆಗೆ ಸಾಮಾನ್ಯ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಅಲಿಯಾಸ್‌ಗಾಗಿ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಕಾರ್ಯವಿಧಾನಕ್ಕೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ, ಆಂತರಿಕವಾಗಿ ಅಲಿಯಾಸ್ ಅನ್ನು ಆಜ್ಞೆಗೆ ವಿಸ್ತರಿಸುತ್ತದೆ ಮತ್ತು ಪೂರ್ಣಗೊಂಡ ಆಜ್ಞೆಗಾಗಿ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಆಯ್ಕೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದರರ್ಥ ಅಲಿಯಾಸ್‌ಗಾಗಿ ಪ್ಯಾಡಿಂಗ್ ಪೂರ್ಣ ಆಜ್ಞೆಯಂತೆಯೇ ವರ್ತಿಸುತ್ತದೆ.

ಕೆಳಗಿನವುಗಳಲ್ಲಿ, ನಾನು ಮೊದಲು ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು ಮತ್ತು ಎಲ್ಲಾ kubectl ಅಲಿಯಾಸ್‌ಗಳಿಗೆ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಅದನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತೇನೆ.

ಸಂಪೂರ್ಣ ಅಲಿಯಾಸ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಮೊದಲನೆಯದಾಗಿ, ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅವಲಂಬಿಸಿರುತ್ತದೆ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ. ಆದ್ದರಿಂದ, ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಮೊದಲು, ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. Linux ಮತ್ತು MacOS ಗಾಗಿ ಈ ಹಿಂದೆ ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳನ್ನು ನೀಡಲಾಗಿದೆ.

MacOS ಬಳಕೆದಾರರಿಗೆ ಪ್ರಮುಖ ಟಿಪ್ಪಣಿ: kubectl ಸ್ವಯಂಪೂರ್ಣತೆಯ ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತೆ, ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ Bash 3.2 ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ, ಇದು MacOS ನಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಆಗಿದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ v2 (brew install bash-completion@2), ಇದಕ್ಕೆ ಕನಿಷ್ಠ ಬ್ಯಾಷ್ 4.1 ಅಗತ್ಯವಿದೆ. ಇದರರ್ಥ MacOS ನಲ್ಲಿ ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅನ್ನು ಬಳಸಲು ನೀವು Bash ನ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿದೆ.

ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ bash_completion.sh ನಿಂದ GitHub ರೆಪೊಸಿಟರಿ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಫೈಲ್‌ನಲ್ಲಿ ಸೇರಿಸಿ ~/.bashrc:

source ~/bash_completion.sh

ಶೆಲ್ ಅನ್ನು ರೀಬೂಟ್ ಮಾಡಿದ ನಂತರ, ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ.

kubectl ಅಲಿಯಾಸ್‌ಗಳಿಗಾಗಿ ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ತಾಂತ್ರಿಕವಾಗಿ ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಒಂದು ಹೊದಿಕೆ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ _complete_alias. ಈ ಕಾರ್ಯವು ಅಲಿಯಾಸ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅಲಿಯಾಸ್ ಆಜ್ಞೆಗಾಗಿ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಸುಳಿವುಗಳನ್ನು ನೀಡುತ್ತದೆ.

ನಿರ್ದಿಷ್ಟ ಅಲಿಯಾಸ್ನೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ಸಂಯೋಜಿಸಲು, ನೀವು ಅಂತರ್ನಿರ್ಮಿತ ಬ್ಯಾಷ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಸಂಪೂರ್ಣ, ಸ್ಥಾಪಿಸಲು _complete_alias ಅಲಿಯಾಸ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕಾರ್ಯವಾಗಿ.

ಉದಾಹರಣೆಯಾಗಿ, kubectl ಆಜ್ಞೆಯನ್ನು ಸೂಚಿಸುವ ಅಲಿಯಾಸ್ k ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ. ಅನುಸ್ಥಾಪಿಸಲು _complete_alias ಈ ಅಲಿಯಾಸ್‌ಗೆ ಪೂರಕ ಕಾರ್ಯವಾಗಿ, ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬೇಕು:

$ complete -F _complete_alias k

ಇದರ ಫಲಿತಾಂಶವೆಂದರೆ ನೀವು ಅಲಿಯಾಸ್ k ಅನ್ನು ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ _complete_alias, ಇದು ಅಲಿಯಾಸ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಆದೇಶಕ್ಕಾಗಿ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಸುಳಿವುಗಳನ್ನು ನೀಡುತ್ತದೆ kubectl.

ಎರಡನೆಯ ಉದಾಹರಣೆಯಾಗಿ, ಅಲಿಯಾಸ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ kg, ಇದು ಸೂಚಿಸುತ್ತದೆ kubectl get:

$ complete -F _complete_alias kg

ಹಿಂದಿನ ಉದಾಹರಣೆಯಂತೆಯೇ, ನೀವು ಕೆಜಿಯನ್ನು ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ನೀವು ಪಡೆಯುವ ಅದೇ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಸುಳಿವುಗಳನ್ನು ನೀವು ಪಡೆಯುತ್ತೀರಿ kubectl get.

ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿರುವ ಯಾವುದೇ ಅಲಿಯಾಸ್‌ಗೆ ನೀವು ಸಂಪೂರ್ಣ-ಅಲಿಯಾಸ್ ಅನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

ಆದ್ದರಿಂದ, ಎಲ್ಲಾ kubectl ಅಲಿಯಾಸ್‌ಗಳಿಗೆ ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ನೀವು ಪ್ರತಿಯೊಂದಕ್ಕೂ ಮೇಲಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ಕೆಳಗಿನ ತುಣುಕು ನಿಖರವಾಗಿ ಇದನ್ನು ಮಾಡುತ್ತದೆ, ನೀವು kubectl-ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಹೊಂದಿಸಿದ್ದರೆ ~/.kubectl-aliases:

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

ಈ ಕೋಡ್ ತುಂಡನ್ನು ನಿಮ್ಮಲ್ಲಿ ಇರಿಸಬೇಕಾಗುತ್ತದೆ ~/.bashrc, ಕಮಾಂಡ್ ಶೆಲ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯು ಎಲ್ಲಾ 800 kubectl ಅಲಿಯಾಸ್‌ಗಳಿಗೆ ಲಭ್ಯವಾಗುತ್ತದೆ.

6. ಪ್ಲಗಿನ್‌ಗಳೊಂದಿಗೆ kubectl ಅನ್ನು ವಿಸ್ತರಿಸುವುದು

ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಆವೃತ್ತಿ 1.12, kubectl ಬೆಂಬಲಿಸುತ್ತದೆ ಪ್ಲಗಿನ್ ಕಾರ್ಯವಿಧಾನ, ಇದು ಹೆಚ್ಚುವರಿ ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಅದರ ಕಾರ್ಯಗಳನ್ನು ವಿಸ್ತರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ನಿಮಗೆ ಪರಿಚಯವಿದ್ದರೆ Git ಪ್ಲಗಿನ್ ಕಾರ್ಯವಿಧಾನಗಳು, ನಂತರ kubectl ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಅದೇ ತತ್ತ್ವದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.

ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು, ಅವುಗಳನ್ನು ಎಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ಕವರ್ ಮಾಡುತ್ತೇವೆ.

ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

Kubectl ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹೆಸರಿನೊಂದಿಗೆ ಸರಳವಾದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್‌ಗಳಾಗಿ ವಿತರಿಸಲಾಗುತ್ತದೆ kubectl-x. ಪೂರ್ವಪ್ರತ್ಯಯ kubectl- ಪ್ಲಗಿನ್‌ಗೆ ಕರೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಹೊಸ kubectl ಉಪಕಮಾಂಡ್‌ನ ನಂತರ ಅಗತ್ಯವಿದೆ.

ಉದಾಹರಣೆಗೆ, ಹಲೋ ಪ್ಲಗಿನ್ ಎಂಬ ಫೈಲ್ ಅನ್ನು ವಿತರಿಸಲಾಗುತ್ತದೆ kubectl-hello.

ಪ್ಲಗಿನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು, ನೀವು ಫೈಲ್ ಅನ್ನು ನಕಲಿಸಬೇಕಾಗುತ್ತದೆ kubectl-x ನಿಮ್ಮ PATH ನಲ್ಲಿರುವ ಯಾವುದೇ ಡೈರೆಕ್ಟರಿಗೆ ಮತ್ತು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಂತೆ ಮಾಡಿ, ಉದಾಹರಣೆಗೆ chmod +x. ಇದರ ನಂತರ ತಕ್ಷಣವೇ ನೀವು ಪ್ಲಗಿನ್ ಅನ್ನು ಕರೆಯಬಹುದು kubectl x.

ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಪ್ರಸ್ತುತ ಸ್ಥಾಪಿಸಲಾದ ಎಲ್ಲಾ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಲು ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು:

$ kubectl plugin list

ನೀವು ಒಂದೇ ಹೆಸರಿನೊಂದಿಗೆ ಬಹು ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಅಥವಾ ಕಾರ್ಯಗತಗೊಳಿಸದ ಪ್ಲಗಿನ್ ಫೈಲ್ ಇದ್ದರೆ ಈ ಆಜ್ಞೆಯು ಎಚ್ಚರಿಕೆಗಳನ್ನು ಸಹ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

Krew ಬಳಸಿಕೊಂಡು ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತು ಸ್ಥಾಪಿಸುವುದು

Kubectl ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಸಾಫ್ಟ್‌ವೇರ್ ಪ್ಯಾಕೇಜ್‌ಗಳಂತೆ ಹಂಚಿಕೊಳ್ಳಬಹುದು ಅಥವಾ ಮರುಬಳಕೆ ಮಾಡಬಹುದು. ಆದರೆ ಇತರರು ಹಂಚಿಕೊಂಡ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ನೀವು ಎಲ್ಲಿ ಕಾಣಬಹುದು?

ಪ್ರಾಜೆಕ್ಟ್ ಕ್ರೂ kubectl ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲು, ಹುಡುಕಲು, ಸ್ಥಾಪಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಏಕೀಕೃತ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ. ಯೋಜನೆಯು ತನ್ನನ್ನು "ಕುಬೆಕ್ಟ್ಲ್ ಪ್ಲಗಿನ್‌ಗಳಿಗಾಗಿ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್" ಎಂದು ಕರೆದುಕೊಳ್ಳುತ್ತದೆ (ಕ್ರೂ ಇದನ್ನು ಹೋಲುತ್ತದೆ ಬ್ರೂ).

Krew ಎನ್ನುವುದು kubectl ಪ್ಲಗಿನ್‌ಗಳ ಪಟ್ಟಿಯಾಗಿದ್ದು ಅದನ್ನು ನೀವು ಆಯ್ಕೆ ಮಾಡಬಹುದು ಮತ್ತು ಸ್ಥಾಪಿಸಬಹುದು. ಅದೇ ಸಮಯದಲ್ಲಿ, ಕ್ರೂ ಕೂಡ kubectl ಗಾಗಿ ಪ್ಲಗಿನ್ ಆಗಿದೆ.

ಇದರರ್ಥ Krew ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮೂಲಭೂತವಾಗಿ ಯಾವುದೇ ಇತರ 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 ಕ್ರೂ ಬಳಸಿ ಸ್ಥಾಪಿಸಲಾದ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಮಾತ್ರ ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಆದರೆ ಆಜ್ಞೆ kubectl plugin list ಎಲ್ಲಾ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ, ಅಂದರೆ, ಕ್ರೂ ಬಳಸಿ ಸ್ಥಾಪಿಸಲಾದ ಮತ್ತು ಇತರ ವಿಧಾನಗಳಿಂದ ಸ್ಥಾಪಿಸಲಾದವು.

ಬೇರೆಡೆ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹುಡುಕಲಾಗುತ್ತಿದೆ

ಕ್ರೂ ಯುವ ಪ್ರಾಜೆಕ್ಟ್ ಆಗಿದೆ, ಪ್ರಸ್ತುತ ಅದರಲ್ಲಿದೆ ಪಟ್ಟಿ ಕೇವಲ 30 ಪ್ಲಗಿನ್‌ಗಳು. ನಿಮಗೆ ಬೇಕಾದುದನ್ನು ನೀವು ಕಂಡುಹಿಡಿಯಲಾಗದಿದ್ದರೆ, ನೀವು GitHub ನಂತಹ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬೇರೆಡೆ ಕಾಣಬಹುದು.

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 ಅನ್ನು ಕರೆಯಲು ಸಾಧ್ಯವಾಗುವ ಅನುಕೂಲ. ಆದಾಗ್ಯೂ, ನೀವು ಬಳಸಿಕೊಂಡು ನೈಜ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿ. ನೀವು Go ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಸಹ ಬಳಸಬಹುದು ಕ್ಲೈ-ರನ್ಟೈಮ್ ಲೈಬ್ರರಿ, ಇದು kubectl ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬರೆಯಲು ನಿರ್ದಿಷ್ಟವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

ನಿಮ್ಮ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಹೇಗೆ ಹಂಚಿಕೊಳ್ಳುವುದು

ನಿಮ್ಮ ಪ್ಲಗಿನ್‌ಗಳು ಇತರರಿಗೆ ಉಪಯುಕ್ತವಾಗಬಹುದು ಎಂದು ನೀವು ಭಾವಿಸಿದರೆ, ಅದನ್ನು GitHub ನಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಲು ಮುಕ್ತವಾಗಿರಿ. ಅವುಗಳನ್ನು ವಿಷಯಕ್ಕೆ ಸೇರಿಸಲು ಮರೆಯದಿರಿ kubectl-plugins.

ನಿಮ್ಮ ಪ್ಲಗಿನ್ ಅನ್ನು ಸೇರಿಸಲು ಸಹ ನೀವು ವಿನಂತಿಸಬಹುದು ಕ್ರೂ ಪಟ್ಟಿ. ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂಬುದರ ಸೂಚನೆಗಳು ಇಲ್ಲಿವೆ GitHub ರೆಪೊಸಿಟರಿಗಳು.

ಕಮಾಂಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ

ಪ್ಲಗಿನ್‌ಗಳು ಪ್ರಸ್ತುತ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ಅಂದರೆ, ನೀವು ಪ್ಲಗಿನ್‌ನ ಪೂರ್ಣ ಹೆಸರು ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಪೂರ್ಣ ಹೆಸರುಗಳನ್ನು ನಮೂದಿಸಬೇಕು.

ಈ ಕಾರ್ಯಕ್ಕಾಗಿ GitHub kubectl ರೆಪೊಸಿಟರಿ ಹೊಂದಿದೆ ಮುಕ್ತ ವಿನಂತಿ. ಆದ್ದರಿಂದ ಭವಿಷ್ಯದಲ್ಲಿ ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.

ಒಳ್ಳೆಯದಾಗಲಿ!!!

ವಿಷಯದ ಬಗ್ಗೆ ಇನ್ನೇನು ಓದಬೇಕು:

ಮೂಲ: www.habr.com

kubectl ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವುದು ಹೇಗೆ: ವಿವರವಾದ ಮಾರ್ಗದರ್ಶಿ