ಅಂತರ್ಜಾಲದಲ್ಲಿ ಸಾಕಷ್ಟು ಉಲ್ಲೇಖ ಸಾಹಿತ್ಯವಿದೆ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಸರಳವಾದ ಸಲಹೆಯು ಅತ್ಯಂತ ಮೌಲ್ಯಯುತವಾಗಿದೆ. ತಂಡ ಅನುವಾದಿಸಲಾಗಿದೆ , ಲೇಖನದ ಲೇಖಕರು ಕುಬರ್ನೆಟ್ಸ್ ಜೊತೆ ಕೆಲಸ ಮಾಡಿದ ಒಂದು ವರ್ಷದ ನಂತರ ಸಂಗ್ರಹಿಸಿದರು. ಸುಳಿವುಗಳನ್ನು ಪ್ರಾಮುಖ್ಯತೆಯಿಂದ ವಿಂಗಡಿಸಲಾಗಿಲ್ಲ, ಆದರೆ ಪ್ರತಿಯೊಬ್ಬರೂ ತಮಗಾಗಿ ಉಪಯುಕ್ತವಾದದ್ದನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.
ಕುಬರ್ನೆಟ್ಸ್ ಜೊತೆ ಕೆಲಸ ಮಾಡಲು ಸರಳವಾದ ಆಜ್ಞೆ
ಮೊದಲಿಗೆ, ಕುಬರ್ನೆಟ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಲ್ಲಿ ಬಹುಶಃ ಸರಳ ಮತ್ತು ಅತ್ಯಂತ ಉಪಯುಕ್ತ ಕ್ರಮ. ಕೆಳಗಿನ ಆಜ್ಞೆಯು ಆಜ್ಞೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ kubectl ಬ್ಯಾಷ್ ಶೆಲ್‌ನಲ್ಲಿ:
echo "source <(kubectl completion bash)" >> ~/.bashrc
ಆಟೋಫಿಲ್ kubectl .bashrc ಫೈಲ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಶೆಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ ಪ್ರತಿ ಬಾರಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದು ದೀರ್ಘ ಆಜ್ಞೆಗಳು ಮತ್ತು ನಿಯತಾಂಕಗಳನ್ನು ಟೈಪ್ ಮಾಡುವುದನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ all-namespaces. ಹೆಚ್ಚಿನ ವಿವರಗಳಲ್ಲಿ .
ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಮೆಮೊರಿ ಮತ್ತು CPU ಮಿತಿಗಳು
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತಪ್ಪಾಗಿ ಬರೆಯಲಾಗಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ, ಅದು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಡೇಟಾಬೇಸ್ಗೆ ಹೊಸ ಸಂಪರ್ಕವನ್ನು ತೆರೆಯುತ್ತದೆ ಆದರೆ ಅದನ್ನು ಎಂದಿಗೂ ಮುಚ್ಚುವುದಿಲ್ಲ, ನಂತರ ಕ್ಲಸ್ಟರ್ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಹೊಂದಿದೆ. ಮತ್ತು ನಿಯೋಜನೆಯ ಸಮಯದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಮೆಮೊರಿ ಮಿತಿಯನ್ನು ಹೊಂದಿಸದಿದ್ದರೆ, ಇದು ನೋಡ್ ವೈಫಲ್ಯಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
ಇದನ್ನು ತಡೆಗಟ್ಟಲು, ಪ್ರತಿ ನೇಮ್‌ಸ್ಪೇಸ್ ಆಧಾರದ ಮೇಲೆ ಡೀಫಾಲ್ಟ್ ನಿರ್ಬಂಧಗಳನ್ನು ಹೊಂದಿಸಲು ಕುಬರ್ನೆಟ್ಸ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಾಗಿ ಅವುಗಳನ್ನು yaml ಫೈಲ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಅಂತಹ ಫೈಲ್ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
apiVersion: v1
kind: LimitRange
metadata:
name: mem-limit-range
spec:
limits:
- default:
memory: 512Mi
defaultRequest:
memory: 256Mi
type: Container
ಅಂತಹ ಯಮಲ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಯಾವುದೇ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ಅನ್ವಯಿಸಿ. ಉದಾಹರಣೆಗೆ, ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ limit-example. ಈಗ ಈ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ಯಾವುದೇ ಧಾರಕವು 512Mi ಮಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಈ ಕಂಟೇನರ್‌ಗೆ ಹೆಚ್ಚುವರಿಯಾಗಿ ಮತ್ತೊಂದು ವೈಯಕ್ತಿಕ ಮಿತಿಯನ್ನು ಹೊಂದಿಸದ ಹೊರತು.
ಕುಬರ್ನೆಟ್ಸ್ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಕಸ ಸಂಗ್ರಹಣೆ
ಡೀಫಾಲ್ಟ್ ಆಗಿ ಕುಬೆಲೆಟ್ ಯಾವಾಗ ಕಸ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ var/lib/ಡಾಕರ್ ಲಭ್ಯವಿರುವ ಡಿಸ್ಕ್ ಜಾಗದ 90% ಅನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ. ಇದು ಉತ್ತಮವಾಗಿದೆ, ಆದಾಗ್ಯೂ, ಕುಬರ್ನೆಟ್ಸ್ 1.7 ರವರೆಗೆ ಬಳಸಿದ ಐನೋಡ್‌ಗಳ ಸಂಖ್ಯೆಯ ಮೇಲೆ ಯಾವುದೇ ಡೀಫಾಲ್ಟ್ ಮಿತಿ ಇರಲಿಲ್ಲ, ಇದು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿನ ಫೈಲ್‌ಗಳ ಸಂಖ್ಯೆಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.
ಸಂಭಾವ್ಯವಾಗಿ ನಿಮ್ಮ ಧಾರಕ var/lib/ಡಾಕರ್ ಡಿಸ್ಕ್ ಜಾಗದ 50% ಅನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು, ಆದರೆ ಐನೋಡ್‌ಗಳು ಖಾಲಿಯಾಗಬಹುದು, ಇದು ಕೆಲಸಗಾರರಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
1.4 ರಿಂದ 1.6 ರವರೆಗಿನ ಕುಬೆಲೆಟ್‌ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳಲ್ಲಿ ನೀವು ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ:
--eviction-hard
=memory.available<100Mi,nodefs.available<10%,nodefs.inodesFree<5%
1.7 ಮತ್ತು ನಂತರದ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಡಿಫಾಲ್ಟ್ ಆಗಿ ಹೊಂದಿಸಲಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಹಿಂದಿನ ಆವೃತ್ತಿಗಳು ಐನೋಡ್ ಮಿತಿಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದಿಲ್ಲ.
ಮಿನಿಕುಬೆ... ಸಣ್ಣ ಆದರೆ ಶಕ್ತಿಯುತ ಸ್ಥಳೀಯ ಕುಬರ್ನೆಟ್ಸ್
ಸ್ಥಳೀಯ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಮಿನಿಕ್ಯೂಬ್ ಸುಲಭವಾದ ಮಾರ್ಗವಾಗಿದೆ. ಇದನ್ನು ಸರಳ ಆಜ್ಞೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ:
minikube start
ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ನಿಜವಾದ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಚಾಲನೆಯಲ್ಲಿದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಆ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಚಲಾಯಿಸುವುದು ಹೇಗೆ ಎಂಬುದು ಟ್ರಿಕ್ ಆಗಿದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಸೂಚಿಸದ ಹೊರತು, ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಅಲ್ಲ.
ಚಿತ್ರವನ್ನು ಸ್ಥಳೀಯ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ತಳ್ಳಲು ಡಾಕರ್ ಅನ್ನು ಒತ್ತಾಯಿಸಲು, ಡಾಕರ್ ಯಂತ್ರಕ್ಕೆ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ನೀಡಲಾಗುತ್ತದೆ:
eval $(minikube docker-env)
ಈಗ ನಾವು ಸ್ಥಳೀಯ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.
ಎಲ್ಲರಿಗೂ kubectl ಪ್ರವೇಶವನ್ನು ನೀಡಬೇಡಿ
ಇದು ಸ್ಪಷ್ಟವಾಗಿ ತೋರುತ್ತದೆ, ಆದರೆ ಅನೇಕ ತಂಡಗಳು ತಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಒಂದೇ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ (ಇದಕ್ಕಾಗಿ ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ), ನೀವು ಎಲ್ಲರಿಗೂ ನೀಡಬಾರದು kubectl. ಆಜ್ಞೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು ಉತ್ತಮ, ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ ತನ್ನದೇ ಆದ ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು ಮತ್ತು RBAC ನೀತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರವೇಶವನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು.
ಪ್ರತಿ ಪಾಡ್‌ಗೆ ಪ್ರವೇಶಿಸಲು, ಓದಲು, ರಚಿಸಲು, ಅಳಿಸಲು ಮತ್ತು ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹಕ್ಕುಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮೂಲಕ ನೀವು ಗೊಂದಲಕ್ಕೊಳಗಾಗಬಹುದು. ಆದರೆ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ರಹಸ್ಯಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಮಿತಿಗೊಳಿಸುವುದು, ಅದನ್ನು ನಿರ್ವಾಹಕರಿಗೆ ಮಾತ್ರ ಅನುಮತಿಸುವುದು. ಈ ರೀತಿಯಲ್ಲಿ ನಾವು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿರ್ವಹಿಸಬಲ್ಲವರು ಮತ್ತು ಅದನ್ನು ಸರಳವಾಗಿ ನಿಯೋಜಿಸಬಹುದಾದವರ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುತ್ತೇವೆ.
ಪಾಡ್ ಬಜೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಿ
ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಯಾವುದೇ ಅಲಭ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಹೇಗೆ? PodDisruptionBudget ಮತ್ತು ಮತ್ತೆ PodDisruptionBudget.
ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ನಿಯತಕಾಲಿಕವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನೋಡ್‌ಗಳನ್ನು ಖಾಲಿ ಮಾಡಲಾಗುತ್ತದೆ. ಯಾವುದೂ ನಿಂತಿಲ್ಲ, ಅದು ವಾಸ್ತವ. ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ನಿದರ್ಶನಗಳೊಂದಿಗೆ ಪ್ರತಿ ನಿಯೋಜನೆಯು PDB (PodDisruptionBudget) ಅನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. ಕ್ಲಸ್ಟರ್‌ಗೆ ಅನ್ವಯಿಸಲಾದ ಸರಳವಾದ yaml ಫೈಲ್‌ನಲ್ಲಿ ಇದನ್ನು ರಚಿಸಲಾಗಿದೆ. ನಿರ್ದಿಷ್ಟ PDB ಯ ವ್ಯಾಪ್ತಿಯ ಪ್ರದೇಶವನ್ನು ಲೇಬಲ್ ಆಯ್ಕೆದಾರರು ನಿರ್ಧರಿಸುತ್ತಾರೆ.
ಗಮನಿಸಿ: ಬಜೆಟ್ ಉಲ್ಲಂಘನೆಯು ಹಿಂತಿರುಗಿಸಬಹುದಾದಾಗ ಮಾತ್ರ PDB ಬಜೆಟ್ ಅನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ () ಹಾರ್ಡ್‌ವೇರ್ ವೈಫಲ್ಯಗಳಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, PDB ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.
ಉದಾಹರಣೆ PDB:
apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
name: app-a-pdb
spec:
minAvailable: 2
selector:
matchLabels:
app: app-a
ಎರಡು ಮುಖ್ಯ ನಿಯತಾಂಕಗಳು matchLabels и minAvailable. ಬಜೆಟ್ ಯಾವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾನು ಲೇಬಲ್‌ಗಳೊಂದಿಗೆ ನಿಯೋಜನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ app: app-a и app: app-b, ನಂತರ ಈ PDB ಮೊದಲನೆಯದಕ್ಕೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ.
ನಿಯತಾಂಕ minAvailable ನೋಡ್ ಅನ್ನು ಖಾಲಿ ಮಾಡುವಾಗ (ಸ್ವಚ್ಛಗೊಳಿಸುವಾಗ) ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಖಾಲಿ ಮಾಡುವ ಸಮಯದಲ್ಲಿ, ಎಲ್ಲಾ ನಿದರ್ಶನಗಳನ್ನು ಹೊರಹಾಕಲಾಗುತ್ತದೆ app: app-a, ಎರಡು ಹೊರತುಪಡಿಸಿ.
ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ನ ಎಷ್ಟು ನಿದರ್ಶನಗಳು ರನ್ ಆಗಬೇಕು ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಆರೋಗ್ಯ ಮೇಲ್ವಿಚಾರಣೆ
ಅಂತಹ ಮೇಲ್ವಿಚಾರಣೆ ಎರಡು ವಿಧಗಳಲ್ಲಿ ಸಾಧ್ಯ: ಸಿದ್ಧತೆ ಅಥವಾ ಲೈವ್ನೆಸ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸುವುದು.
ಮೊದಲ ತನಿಖೆ (ಸಿದ್ಧತೆ) ದಟ್ಟಣೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ಕಂಟೇನರ್‌ನ ಸಿದ್ಧತೆಯನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.
ಎರಡನೆಯದು (ಲೈವ್ನೆಸ್) ಕಂಟೇನರ್ ಆರೋಗ್ಯಕರವಾಗಿದೆಯೇ ಅಥವಾ ಮರುಪ್ರಾರಂಭಿಸಬೇಕೆ ಎಂದು ತೋರಿಸುತ್ತದೆ.
ನಿಯೋಜನೆಗಾಗಿ ಸಂಬಂಧಿತ ಸಂರಚನೆಗಳನ್ನು ಸರಳವಾಗಿ yaml ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಅಲ್ಲಿ ನೀವು ಕಾಲಾವಧಿಗಳು, ವಿಳಂಬ ಸಮಯಗಳು ಮತ್ತು ಮರುಪರೀಕ್ಷೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಅವರ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ನೋಡಿ .
ಟ್ಯಾಗ್‌ಗಳು ಎಲ್ಲೆಡೆ ಇವೆ
ಲೇಬಲ್‌ಗಳು ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿನ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಅವರು ವಸ್ತುಗಳನ್ನು ಪರಸ್ಪರ ಮುಕ್ತವಾಗಿ ಸಂವಹನ ಮಾಡಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತಾರೆ, ಜೊತೆಗೆ ಲೇಬಲ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುತ್ತಾರೆ. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ, ನೀವು ಕ್ಲೈಂಟ್‌ಗೆ ಹೋಗಬಹುದು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಟ್ಯಾಗ್‌ಗಳಿಗಾಗಿ ಈವೆಂಟ್‌ಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು.
ನೀವು ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಬಹುತೇಕ ಏನನ್ನೂ ಮಾಡಬಹುದು, ಆದರೆ ಒಂದೇ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು ಬಹು ಪರಿಸರವನ್ನು ರಚಿಸುವುದು ಉತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ.
ನೀವು ಅದೇ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತೀರಿ ಎಂದು ಹೇಳೋಣ dev и qa. ಇದರರ್ಥ ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಬಹುದು app-a, ಏಕಕಾಲದಲ್ಲಿ ಎರಡೂ ಪರಿಸರದಲ್ಲಿ ಕೆಲಸ qa и dev. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸೂಕ್ತವಾದ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ನಾವು ನಿರ್ದಿಷ್ಟ ಪರಿಸರದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ನಿದರ್ಶನವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು environment. ಉದಾಹರಣೆಗೆ app: app-a и environment: dev ಒಂದು ಪರಿಸರಕ್ಕಾಗಿ, ಮತ್ತು app: app-a и environment: qa ಎರಡನೆಯದಕ್ಕೆ.
ಅಪ್ಲಿಕೇಶನ್‌ನ ಎರಡೂ ನಿದರ್ಶನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಏಕಕಾಲದಲ್ಲಿ ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸಲು.
ವಿಷಯಗಳನ್ನು ಕ್ರಮವಾಗಿ ಇರಿಸಿ
ಕುಬರ್ನೆಟ್ಸ್ ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾದ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ, ಆದರೆ ಯಾವುದೇ ವ್ಯವಸ್ಥೆಯು ಅಂತಿಮವಾಗಿ ಹಲವಾರು ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಸಿಲುಕಿಕೊಳ್ಳಬಹುದು. Kubelet ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳು ಮತ್ತು ಪರಿಶೀಲನೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ, ಹಾಗೆಯೇ ತನ್ನದೇ ಆದ.
ಸಹಜವಾಗಿ, ಒಂದು ಅನಾಥ ಸೇವೆಯು ವ್ಯವಸ್ಥೆಯನ್ನು ನಿಧಾನಗೊಳಿಸುವುದಿಲ್ಲ ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ನೆಲದಿಂದ ಅಳೆಯಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಆದರೆ ಒಂದು ಸೇವೆಯ ಬದಲಿಗೆ ಮಿಲಿಯನ್ ಕಾಣಿಸಿಕೊಂಡರೆ, ಕುಬೆಲೆಟ್ ಉಸಿರುಗಟ್ಟಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ಕೆಲವು ಕಾರಣಗಳಿಗಾಗಿ ನೀವು ನಿಯೋಜನೆಯನ್ನು ಅಳಿಸಿದರೆ (ಕಂಟೇನರ್, ಇಮೇಜ್, ಯಾವುದಾದರೂ), ಸಂಪೂರ್ಣ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಯನ್ನು ಮಾಡಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ಗೋ ಭೇಟಿ ಮಾಡಿ
ನಾವು ಮುಖ್ಯ ಸಲಹೆಯನ್ನು ಕೊನೆಯದಾಗಿ ಉಳಿಸಿದ್ದೇವೆ. ಗೋ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಕಲಿಯಿರಿ.
Kubernetes ಅನ್ನು Go ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಎಲ್ಲಾ ವಿಸ್ತರಣೆಗಳನ್ನು Go ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಕ್ಲೈಂಟ್-ಗೋ ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿಯು ಅಧಿಕೃತವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ.
ಇದನ್ನು ವಿಭಿನ್ನ ಮತ್ತು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಗಳಿಗೆ ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕುಬರ್ನೆಟ್ಸ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿಮ್ಮ ರುಚಿಗೆ ವಿಸ್ತರಿಸಲು. ಆದ್ದರಿಂದ, ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು, ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಅಥವಾ ಕಂಟೇನರ್‌ಗಳನ್ನು ಸರಳವಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲು ನಿಮ್ಮ ಸ್ವಂತ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನೀವು ಬಳಸಬಹುದು.
Go ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಕಲಿಯುವುದು ಮತ್ತು ಕ್ಲೈಂಟ್-ಗೋ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದು ಬಹುಶಃ ನೀವು ಹೊಸ ಕುಬರ್ನೆಟ್ ಬಳಕೆದಾರರಿಗೆ ನೀಡಬಹುದಾದ ಪ್ರಮುಖ ಸಲಹೆಯಾಗಿದೆ.
ಇನ್ನೇನು ಓದಬೇಕು:
- .
- ?
- .
ಮೂಲ: www.habr.com