ಕುಬರ್ನೆಟ್ಸ್ನ ಬೆಳೆಯುತ್ತಿರುವ ಜನಪ್ರಿಯತೆಯ ಬಗ್ಗೆ

ಹಲೋ, ಹಬ್ರ್!

ಬೇಸಿಗೆಯ ಕೊನೆಯಲ್ಲಿ, ನಾವು ವಿಷಯದ ಮೇಲೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ ಎಂದು ನಾವು ನಿಮಗೆ ನೆನಪಿಸಲು ಬಯಸುತ್ತೇವೆ ಕುಬರ್ನೆಟ್ಸ್ ಮತ್ತು ಜೂನ್ ಆರಂಭದಲ್ಲಿ ಈ ಯೋಜನೆಯಲ್ಲಿ ವ್ಯವಹಾರಗಳ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವ Stackoverflow ನಿಂದ ಲೇಖನವನ್ನು ಪ್ರಕಟಿಸಲು ನಿರ್ಧರಿಸಿದೆ.

ಓದುವುದನ್ನು ಆನಂದಿಸಿ!

ಈ ಲೇಖನವನ್ನು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, ಕುಬರ್ನೆಟ್ಸ್ ವಯಸ್ಸು ಸುಮಾರು. ಆರು ವರ್ಷ, ಮತ್ತು ಕಳೆದ ಎರಡು ವರ್ಷಗಳಲ್ಲಿ ಅದರ ಜನಪ್ರಿಯತೆಯು ತುಂಬಾ ಬೆಳೆದಿದೆ, ಅದು ಸ್ಥಿರವಾಗಿ ಸ್ಥಾನ ಪಡೆದಿದೆ ಅತ್ಯಂತ ನೆಚ್ಚಿನ ವೇದಿಕೆಗಳು. ಕುಬರ್ನೆಟ್ಸ್ ಈ ವರ್ಷ ಮೂರನೇ ಸ್ಥಾನದಲ್ಲಿದೆ. ರೀಕ್ಯಾಪ್ ಮಾಡಲು: ಕುಬರ್ನೆಟ್ಸ್ ಎನ್ನುವುದು ಕಂಟೈನರೈಸ್ಡ್ ವರ್ಕ್‌ಲೋಡ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲು ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಟಿಂಗ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ವೇದಿಕೆಯಾಗಿದೆ.

ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ವಿಶೇಷ ವಿನ್ಯಾಸವಾಗಿ ಕಂಟೈನರ್‌ಗಳು ಪ್ರಾರಂಭವಾದವು; ಧಾರಕಗಳನ್ನು 2007 ರಿಂದ ಸೇರಿಸಲಾಗಿದೆ cgroups, ಮತ್ತು 2002 ರಿಂದ - ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು. 2008 ರ ಹೊತ್ತಿಗೆ ಅದು ಲಭ್ಯವಾದಾಗ ಕಂಟೇನರ್‌ಗಳನ್ನು ಇನ್ನಷ್ಟು ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಯಿತು ಎಲ್‌ಎಕ್ಸ್‌ಸಿ, ಮತ್ತು ಗೂಗಲ್ ತನ್ನದೇ ಆದ ಆಂತರಿಕ ಕಾರ್ಪೊರೇಟ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿತು ಬೋರ್ಗ್, ಅಲ್ಲಿ "ಎಲ್ಲಾ ಕೆಲಸಗಳನ್ನು ಕಂಟೇನರ್‌ಗಳಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ." ಇಲ್ಲಿಂದ ನಾವು ಡಾಕರ್‌ನ ಮೊದಲ ಬಿಡುಗಡೆಯಾದ 2013 ಕ್ಕೆ ವೇಗವಾಗಿ ಮುಂದಕ್ಕೆ ಹೋಗುತ್ತೇವೆ ಮತ್ತು ಕಂಟೈನರ್‌ಗಳು ಅಂತಿಮವಾಗಿ ಜನಪ್ರಿಯ ಸಾಮೂಹಿಕ ಪರಿಹಾರವಾಯಿತು. ಆ ಸಮಯದಲ್ಲಿ, ಕಂಟೇನರ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಮುಖ್ಯ ಸಾಧನವಾಗಿತ್ತು ಮೆಸೊಸ್, ಅವರು ಹುಚ್ಚುಚ್ಚಾಗಿ ಜನಪ್ರಿಯವಾಗಿಲ್ಲದಿದ್ದರೂ. ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಮೊದಲು 2015 ರಲ್ಲಿ ಬಿಡುಗಡೆ ಮಾಡಲಾಯಿತು, ನಂತರ ಈ ಉಪಕರಣವು ಕಂಟೇನರ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಕ್ಷೇತ್ರದಲ್ಲಿ ವಾಸ್ತವಿಕ ಮಾನದಂಡವಾಯಿತು.

ಕುಬರ್ನೆಟ್ಸ್ ಏಕೆ ಜನಪ್ರಿಯವಾಗಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸೋಣ, ಕೆಲವು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ. ಉತ್ಪಾದನೆಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ನಿಯೋಜಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಡೆವಲಪರ್‌ಗಳು ಕೊನೆಯ ಬಾರಿಗೆ ಯಾವಾಗ ಒಪ್ಪಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಯಿತು? ಪರಿಕರಗಳನ್ನು ಬಾಕ್ಸ್‌ನಿಂದ ಹೊರಗೆ ಒದಗಿಸಿರುವುದರಿಂದ ಅವುಗಳನ್ನು ಬಳಸುವ ಎಷ್ಟು ಡೆವಲಪರ್‌ಗಳು ನಿಮಗೆ ತಿಳಿದಿದೆ? ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳದ ಎಷ್ಟು ಕ್ಲೌಡ್ ನಿರ್ವಾಹಕರು ಇಂದು ಇದ್ದಾರೆ? ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಗಳನ್ನು ನಾವು ಈ ಲೇಖನದಲ್ಲಿ ನೋಡುತ್ತೇವೆ.

YAML ನಂತೆ ಮೂಲಸೌಕರ್ಯ

ಪಪಿಟ್ ಮತ್ತು ಚೆಫ್‌ನಿಂದ ಕುಬರ್ನೆಟ್ಸ್‌ಗೆ ಹೋದ ಜಗತ್ತಿನಲ್ಲಿ, "ಮೂಲಸೌಕರ್ಯವನ್ನು ಕೋಡ್‌ನಂತೆ" ನಿಂದ "ಮೂಲಸೌಕರ್ಯ ಡೇಟಾ" ಗೆ-ನಿರ್ದಿಷ್ಟವಾಗಿ, YAML ನಂತೆ ಚಲಿಸುವುದು ದೊಡ್ಡ ಬದಲಾವಣೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಪಾಡ್‌ಗಳು, ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು, ನಿಯೋಜಿಸಲಾದ ನಿದರ್ಶನಗಳು, ಸಂಪುಟಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸುಲಭವಾಗಿ YAML ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

apiVersion: v1
kind: Pod
metadata:
  name: site
  labels:
    app: web
spec:
  containers:
    - name: front-end
      image: nginx
      ports:
        - containerPort: 80

ಈ ವೀಕ್ಷಣೆಯು DevOps ಅಥವಾ SRE ವೃತ್ತಿಪರರಿಗೆ ಪೈಥಾನ್ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯದೆಯೇ ತಮ್ಮ ಕೆಲಸದ ಹೊರೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

ಮೂಲಸೌಕರ್ಯವನ್ನು ಡೇಟಾದಂತೆ ಸಂಘಟಿಸುವ ಇತರ ಅನುಕೂಲಗಳು:

• GitOps ಅಥವಾ Git ಕಾರ್ಯಾಚರಣೆಗಳ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ. ಈ ವಿಧಾನವು ಎಲ್ಲಾ ಕುಬರ್ನೆಟ್ಸ್ YAML ಫೈಲ್‌ಗಳನ್ನು ಜಿಟ್ ರೆಪೊಸಿಟರಿಗಳಲ್ಲಿ ಇರಿಸಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಬದಲಾವಣೆಯನ್ನು ಯಾವಾಗ ಮಾಡಲಾಗಿದೆ, ಯಾರು ಅದನ್ನು ಮಾಡಿದ್ದಾರೆ ಮತ್ತು ನಿಖರವಾಗಿ ಏನು ಬದಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು. ಇದು ಸಂಸ್ಥೆಯಾದ್ಯಂತ ಕಾರ್ಯಾಚರಣೆಗಳ ಪಾರದರ್ಶಕತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತೊಡೆದುಹಾಕುವ ಮೂಲಕ ಕಾರ್ಯಾಚರಣೆಯ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಉದ್ಯೋಗಿಗಳು ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹುಡುಕಬೇಕು. ಅದೇ ಸಮಯದಲ್ಲಿ, ಪುಲ್ ವಿನಂತಿಯನ್ನು ವಿಲೀನಗೊಳಿಸುವ ಮೂಲಕ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
• ಸ್ಕೇಲೆಬಿಲಿಟಿ. ಸಂಪನ್ಮೂಲಗಳನ್ನು YAML ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿದಾಗ, ಕ್ಲಸ್ಟರ್ ಆಪರೇಟರ್‌ಗಳಿಗೆ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲದಲ್ಲಿ ಒಂದು ಅಥವಾ ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಬದಲಾಯಿಸುವುದು ತುಂಬಾ ಸುಲಭವಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಅದು ಹೇಗೆ ಮಾಪಕವಾಗುತ್ತದೆ. ಕುಬರ್ನೆಟ್ಸ್ ಪಾಡ್‌ಗಳ ಸಮತಲ ಸ್ವಯಂ ಸ್ಕೇಲಿಂಗ್‌ಗೆ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಕಡಿಮೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಮಟ್ಟದ ದಟ್ಟಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ದಿಷ್ಟ ನಿಯೋಜನೆ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಪಾಡ್‌ಗಳ ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ಅನುಕೂಲಕರವಾಗಿ ನಿರ್ಧರಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಟ್ರಾಫಿಕ್‌ನಲ್ಲಿ ಹಠಾತ್ ಸ್ಪೈಕ್‌ನಿಂದಾಗಿ ಹೆಚ್ಚುವರಿ ಸಾಮರ್ಥ್ಯದ ಅಗತ್ಯವಿರುವ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನೀವು ನಿಯೋಜಿಸಿದ್ದರೆ, ನಂತರ maxReplicas ಅನ್ನು 10 ರಿಂದ 20 ಕ್ಕೆ ಬದಲಾಯಿಸಬಹುದು:

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp-deployment
  minReplicas: 1
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

• ಭದ್ರತೆ ಮತ್ತು ನಿರ್ವಹಣೆ. Kubernetes ನಲ್ಲಿ ವಿಷಯಗಳನ್ನು ಹೇಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು YAML ಉತ್ತಮವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಕೆಲಸದ ಹೊರೆಗಳು ನಿರ್ವಾಹಕರಲ್ಲದ ಬಳಕೆದಾರರಾಗಿ ರನ್ ಆಗುತ್ತಿದೆಯೇ ಎಂಬುದಕ್ಕೆ ಪ್ರಮುಖ ಭದ್ರತಾ ಕಾಳಜಿಯು ಸಂಬಂಧಿಸಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಮಗೆ ಉಪಕರಣಗಳು ಬೇಕಾಗಬಹುದು ಘರ್ಷಣೆ, YAML/JSON ವ್ಯಾಲಿಡೇಟರ್, ಜೊತೆಗೆ ನೀತಿ ಏಜೆಂಟ್ ತೆರೆಯಿರಿ, ಸಂದರ್ಭವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀತಿ ಮೌಲ್ಯಮಾಪಕ ಭದ್ರತಾ ಸಂದರ್ಭ ನಿಮ್ಮ ಕೆಲಸದ ಹೊರೆಗಳು ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ವಾಹಕರ ಸವಲತ್ತುಗಳೊಂದಿಗೆ ರನ್ ಮಾಡಲು ಅನುಮತಿಸುವುದಿಲ್ಲ. ಇದು ಅಗತ್ಯವಿದ್ದರೆ, ಬಳಕೆದಾರರು ಸರಳ ನೀತಿಯನ್ನು ಅನ್ವಯಿಸಬಹುದು ನಾನು ಪ್ರಾರ್ಥಿಸುವೆ, ಹೀಗೆ:

package main

deny[msg] {
  input.kind = "Deployment"
  not input.spec.template.spec.securityContext.runAsNonRoot = true
  msg = "Containers must not run as root"
}

• ಕ್ಲೌಡ್ ಪ್ರೊವೈಡರ್ನೊಂದಿಗೆ ಏಕೀಕರಣಕ್ಕಾಗಿ ಆಯ್ಕೆಗಳು. ಇಂದಿನ ಉನ್ನತ ತಂತ್ರಜ್ಞಾನದಲ್ಲಿನ ಅತ್ಯಂತ ಗಮನಾರ್ಹ ಪ್ರವೃತ್ತಿಯೆಂದರೆ ಸಾರ್ವಜನಿಕ ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರ ಮೇಲೆ ಕೆಲಸದ ಹೊರೆಗಳನ್ನು ಚಲಾಯಿಸುವುದು. ಘಟಕವನ್ನು ಬಳಸುವುದು ಮೇಘ ಒದಗಿಸುವವರು ಕುಬರ್ನೆಟ್ಸ್ ಯಾವುದೇ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಅದು ಚಲಿಸುವ ಕ್ಲೌಡ್ ಪ್ರೊವೈಡರ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು AWS ನಲ್ಲಿ ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ ಮತ್ತು ಸೇವೆಯ ಮೂಲಕ ಆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಲು ಬಯಸಿದರೆ, ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇವೆಯನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತಾರೆ LoadBalancerಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಅಮೆಜಾನ್ ಎಲಾಸ್ಟಿಕ್ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ಅಪ್ಲಿಕೇಶನ್ ಪಾಡ್‌ಗಳಿಗೆ ದಟ್ಟಣೆಯನ್ನು ಮರುನಿರ್ದೇಶಿಸಲು.

ವಿಸ್ತರಣೆ

ಕುಬರ್ನೆಟ್ಸ್ ಬಹಳ ವಿಸ್ತಾರವಾಗಿದೆ ಮತ್ತು ಅಭಿವರ್ಧಕರು ಇದನ್ನು ಇಷ್ಟಪಡುತ್ತಾರೆ. ಪಾಡ್‌ಗಳು, ನಿಯೋಜನೆಗಳು, ಮುಂತಾದ ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳ ಒಂದು ಸೆಟ್ ಇದೆ. StatefulSets, ರಹಸ್ಯಗಳು, ConfigMaps, ಇತ್ಯಾದಿ ನಿಜ, ಬಳಕೆದಾರರು ಮತ್ತು ಡೆವಲಪರ್‌ಗಳು ರೂಪದಲ್ಲಿ ಇತರ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸೇರಿಸಬಹುದು ಕಸ್ಟಮ್ ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನಗಳು.

ಉದಾಹರಣೆಗೆ, ನಾವು ಸಂಪನ್ಮೂಲವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಯಸಿದರೆ CronTab, ನಂತರ ನೀವು ಈ ರೀತಿ ಮಾಡಬಹುದು:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: crontabs.my.org
spec:
  group: my.org
  versions:
    - name: v1
      served: true
      storage: true
      Schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                cronSpec:
                  type: string
                  pattern: '^(d+|*)(/d+)?(s+(d+|*)(/d+)?){4}$'
                replicas:
                  type: integer
                  minimum: 1
                  maximum: 10
  scope: Namespaced
  names:
    plural: crontabs
    singular: crontab
    kind: CronTab
    shortNames:
    - ct

ನಂತರ ನಾವು ಈ ರೀತಿಯ CronTab ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಬಹುದು:

apiVersion: "my.org/v1"
kind: CronTab
metadata:
  name: my-cron-object
spec:
  cronSpec: "* * * * */5"
  image: my-cron-image
  replicas: 5

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

ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮದೇ ಆದ ಆಪರೇಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಸಮುದಾಯದಲ್ಲಿ ಹಲವಾರು ಸಾಧನಗಳಿವೆ. ಅವುಗಳಲ್ಲಿ - ಆಪರೇಟರ್ ಫ್ರೇಮ್ವರ್ಕ್ ಮತ್ತು ಅವನ ಆಪರೇಟರ್ SDK. ಈ SDK ಒಂದು ಅಡಿಪಾಯವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದರಿಂದ ಡೆವಲಪರ್ ತ್ವರಿತವಾಗಿ ಆಪರೇಟರ್ ಅನ್ನು ರಚಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು. ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ಈ ರೀತಿಯದನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು ಎಂದು ಹೇಳೋಣ:

$ operator-sdk new my-operator --repo github.com/myuser/my-operator

ಇದು YAML ಫೈಲ್‌ಗಳು ಮತ್ತು ಗೋಲಾಂಗ್ ಕೋಡ್ ಸೇರಿದಂತೆ ನಿಮ್ಮ ಆಪರೇಟರ್‌ಗಾಗಿ ಎಲ್ಲಾ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ:

.
|____cmd
| |____manager
| | |____main.go
|____go.mod
|____deploy
| |____role.yaml
| |____role_binding.yaml
| |____service_account.yaml
| |____operator.yaml
|____tools.go
|____go.sum
|____.gitignore
|____version
| |____version.go
|____build
| |____bin
| | |____user_setup
| | |____entrypoint
| |____Dockerfile
|____pkg
| |____apis
| | |____apis.go
| |____controller
| | |____controller.go

ನಂತರ ನೀವು ಅಗತ್ಯವಿರುವ API ಗಳು ಮತ್ತು ನಿಯಂತ್ರಕವನ್ನು ಈ ರೀತಿ ಸೇರಿಸಬಹುದು:

$ operator-sdk add api --api-version=myapp.com/v1alpha1 --kind=MyAppService

$ operator-sdk add controller --api-version=myapp.com/v1alpha1 --kind=MyAppService

ನಂತರ, ಅಂತಿಮವಾಗಿ, ಆಪರೇಟರ್ ಅನ್ನು ಜೋಡಿಸಿ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಕಂಟೇನರ್‌ನ ನೋಂದಾವಣೆಗೆ ಕಳುಹಿಸಿ:

$ operator-sdk build your.container.registry/youruser/myapp-operator

ಡೆವಲಪರ್ ಇನ್ನಷ್ಟು ನಿಯಂತ್ರಣವನ್ನು ಬಯಸಿದರೆ, Go ಫೈಲ್‌ಗಳಲ್ಲಿನ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಿಯಂತ್ರಕದ ನಿಶ್ಚಿತಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು, ನೀವು ಫೈಲ್ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬಹುದು controller.go.

ಮತ್ತೊಂದು ಯೋಜನೆ ಕುಡೋ, ಕೇವಲ ಘೋಷಣೆಯ YAML ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೇಳಿಕೆಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Apache Kafka ಗಾಗಿ ಆಪರೇಟರ್ ಅನ್ನು ಸರಿಸುಮಾರು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ. ಇದರೊಂದಿಗೆ, ನೀವು ಕೇವಲ ಒಂದೆರಡು ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಕುಬರ್ನೆಟ್ಸ್ ಮೇಲೆ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬಹುದು:

$ kubectl kudo install zookeeper
$ kubectl kudo install kafka

ತದನಂತರ ಅದನ್ನು ಮತ್ತೊಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಿ:

$ kubectl kudo install kafka --instance=my-kafka-name 
            -p ZOOKEEPER_URI=zk-zookeeper-0.zk-hs:2181 
            -p ZOOKEEPER_PATH=/my-path -p BROKER_CPUS=3000m 
            -p BROKER_COUNT=5 -p BROKER_MEM=4096m 
            -p DISK_SIZE=40Gi -p MIN_INSYNC_REPLICAS=3 
            -p NUM_NETWORK_THREADS=10 -p NUM_IO_THREADS=20

ನಾವೀನ್ಯತೆ

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

ಹೊಸ ಸಾಮರ್ಥ್ಯಗಳು ವೈವಿಧ್ಯಮಯ ಕೆಲಸದ ಹೊರೆಗಳಾದ್ಯಂತ ಹೆಚ್ಚು ಮೃದುವಾಗಿ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ನೇರವಾಗಿ ಉತ್ಪಾದನೆಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವಾಗ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಆನಂದಿಸುತ್ತಾರೆ.

ಸಮುದಾಯ

ಕುಬರ್ನೆಟ್ಸ್ ಜನಪ್ರಿಯತೆಯ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಅದರ ಸಮುದಾಯದ ಶಕ್ತಿ. 2015 ರಲ್ಲಿ, ಆವೃತ್ತಿ 1.0 ಅನ್ನು ತಲುಪಿದ ನಂತರ, ಕುಬರ್ನೆಟ್ಸ್ ಪ್ರಾಯೋಜಿಸಿದರು ಮೇಘ ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟಿಂಗ್ ಪ್ರತಿಷ್ಠಾನ.

ವಿವಿಧ ಸಮುದಾಯಗಳೂ ಇವೆ SIG (ವಿಶೇಷ ಆಸಕ್ತಿ ಗುಂಪುಗಳು) ಯೋಜನೆಯು ವಿಕಸನಗೊಳ್ಳುತ್ತಿದ್ದಂತೆ ಕುಬರ್ನೆಟ್ಸ್‌ನ ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದೆ. ಈ ಗುಂಪುಗಳು ನಿರಂತರವಾಗಿ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸೇರಿಸುತ್ತಿವೆ, ಕುಬರ್ನೆಟ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿದೆ.

ಕ್ಲೌಡ್ ನೇಟಿವ್ ಫೌಂಡೇಶನ್ ಕ್ಲೌಡ್ ನೇಟಿವ್ ಕಾನ್/ಕುಬೆಕಾನ್ ಅನ್ನು ಸಹ ಆಯೋಜಿಸುತ್ತದೆ, ಇದು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, ವಿಶ್ವದ ಅತಿದೊಡ್ಡ ಓಪನ್ ಸೋರ್ಸ್ ಕಾನ್ಫರೆನ್ಸ್ ಆಗಿದೆ. ವಿಶಿಷ್ಟವಾಗಿ ವರ್ಷಕ್ಕೆ ಮೂರು ಬಾರಿ ನಡೆಯುತ್ತದೆ, ಇದು ಕುಬರ್ನೆಟ್ಸ್ ಮತ್ತು ಅದರ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಸುಧಾರಿಸಲು ಬಯಸುವ ಸಾವಿರಾರು ವೃತ್ತಿಪರರನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ, ಜೊತೆಗೆ ಪ್ರತಿ ಮೂರು ತಿಂಗಳಿಗೊಮ್ಮೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಕಲಿಯುತ್ತದೆ.

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

ಅಂತಿಮವಾಗಿ, ಇಡೀ ಸಮುದಾಯದ ಪ್ರಜ್ಞಾಪೂರ್ವಕ ಪ್ರಯತ್ನಗಳಿಲ್ಲದೆ ಕುಬರ್ನೆಟ್ಸ್ ಯಶಸ್ವಿಯಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ, ಅಲ್ಲಿ ಜನರು ಒಟ್ಟಿಗೆ ಅಂಟಿಕೊಳ್ಳುತ್ತಾರೆ ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಹೊಸಬರನ್ನು ಮಡಿಲಿಗೆ ಸ್ವಾಗತಿಸುತ್ತಾರೆ.

ಭವಿಷ್ಯ

ಭವಿಷ್ಯದಲ್ಲಿ ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸಬೇಕಾದ ಪ್ರಮುಖ ಸವಾಲುಗಳೆಂದರೆ ಕೋಡ್‌ನ ವಿವರಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವ ಸಾಮರ್ಥ್ಯ, ಮತ್ತು ಅದು ಚಾಲನೆಯಲ್ಲಿರುವ ಮೂಲಸೌಕರ್ಯದ ಮೇಲೆ ಅಲ್ಲ. ಇದು ಈ ಪ್ರವೃತ್ತಿಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ ಸರ್ವರ್‌ಲೆಸ್ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಮಾದರಿ, ಇದು ಇಂದು ಪ್ರಮುಖವಾಗಿದೆ. ಸುಧಾರಿತ ಚೌಕಟ್ಟುಗಳು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ಉದಾ. ನೇಟಿವ್ и ಓಪನ್ಫಾಸ್, ಇದು ಡೆವಲಪರ್‌ನಿಂದ ಮೂಲಸೌಕರ್ಯವನ್ನು ಅಮೂರ್ತಗೊಳಿಸಲು ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.

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

ಮೂಲ: www.habr.com