Kubernetes ಪ್ರಾರಂಭ ಮಾರ್ಗದರ್ಶಿ: ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಂಟೈನರ್ ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು

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

Kubernetes ಏನು?

Kubernetes (ಸಾಮಾನ್ಯವಾಗಿ K8s ಎಂದು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ) ಸ್ವಾಯತ್ತ ಕಂಟೈನರ್ ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಿಯೋಜನೆ, ವಿಸ್ತರಣೆ ಮತ್ತು ನಿರ್ವಹಣೆಗೆ ಬಳಸುವ ಓಪನ್ ಸೋರ್ಸ್ ವೇದಿಕೆ. ಇದನ್ನು Google ಅಭಿವೃದ್ಧಿಪಡಿಸಿದೆ ಮತ್ತು ಕ್ಲೌಡ್ ನೈಸರ್ಗಿಕ ಗಣನೆ ನಿಧಿಗೆ (CNCF) ದಾನ ಮಾಡಲಾಗಿದೆ. Kubernetes ನ ಪ್ರಮುಖ ಉದ್ದೇಶವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಜೀವನಚಕ್ರ ನಿರ್ವಹಣೆಯನ್ನು ಸುಲಭಗೊಳಿಸುವುದು ಮತ್ತು ವ್ಯವಸ್ಥೆಯ ಉನ್ನತ ಲಭ್ಯತೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸುವುದು.

Kubernetes ನ ಮೂಲ ಘಟಕಗಳು

1. Pod

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

apiVersion: v1
kind: Pod
metadata:
  name: my-app-pod
spec:
  containers:
  - name: my-app-container
    image: nginx

2. Deployment

Deployment Pod ನ ಜೀವನಚಕ್ರವನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ Pod ಗಳು ಕಾರ್ಯನಿರ್ವಹಣಾ ಸ್ಥಿತಿಯಲ್ಲಿ ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ಮತ್ತು ನವೀಕರಣಗಳನ್ನು ಮಾಡಬಹುದು.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: nginx

3. Service

Service ಸ್ಥಿರ ಪ್ರವೇಶದ ಬಾಗಿಲನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇತರ Pod ಅಥವಾ ಹೊರಗಿನ ಬಳಕೆದಾರರಿಗೆ ಕಾರ್ಯನಿರ್ವಹಣೆಯಲ್ಲಿರುವ Pod ಗೆ ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 80

Kubernetes ನ ಪ್ರಯೋಜನಗಳು

• ಸ್ವಯಂಚಾಲಿತ ನಿರ್ವಹಣೆ: Kubernetes ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಂಟೈನರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜನೆ, ವಿಸ್ತರಣೆ ಮತ್ತು ನಿರ್ವಹಿಸುತ್ತದೆ, ಕೈಯಿಂದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ದೋಷಗಳ ಸಂಭವನೀಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಉನ್ನತ ಲಭ್ಯತೆ: ReplicaSets ಮೂಲಕ, Kubernetes ಸಾಕಷ್ಟು Pod ಉದಾಹರಣೆಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಒಂದು ಉದಾಹರಣೆ ವಿಫಲವಾದಾಗ, ವ್ಯವಸ್ಥೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪುನರಾರಂಭಿಸುತ್ತದೆ ಅಥವಾ ಅದನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
• ಭಾರ ಸಮತೋಲನ: Kubernetes ನಲ್ಲಿನ ನಿರ್ಮಿತ ಭಾರ ಸಮತೋಲನ ಕಾರ್ಯಕ್ಷಮತೆ, ಸೇವೆಗಳಿಗೆ ಪ್ರವಾಹವನ್ನು ಹಂಚಿಸುತ್ತದೆ, ಸಂಪತ್ತುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಖಚಿತಪಡಿಸುತ್ತದೆ.

Kubernetes ಅನ್ನು ಶೀಘ್ರವಾಗಿ ಹೇಗೆ ಬಳಸುವುದು

1. ಪರಿಸರ ತಯಾರಿಕೆ

ಮೊದಲು, ನೀವು Kubernetes ಪರಿಸರವನ್ನು ನಿರ್ಮಿಸಲು ಅಗತ್ಯವಿದೆ. ಇದು ಹಲವಾರು ಮಾರ್ಗಗಳಿಂದ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ Minikube ಸ್ಥಳೀಯ ಪರೀಕ್ಷೆಯನ್ನು ಬಳಸುವುದು, ಅಥವಾ ಕ್ಲೌಡ್ ಸೇವಾ ಒದಗಿಸುವವರ (ಜಾಗತಿಕ Kubernetes ಎಂಜಿನ್, AWS EKS, Azure AKS) ಮೇಲೆ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು.

Minikube ಬಳಸಿಕೊಂಡು Kubernetes ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು

• Minikube ಮತ್ತು kubectl ಅನ್ನು ಸ್ಥಾಪಿಸಿ

# Minikube ಅನ್ನು ಸ್ಥಾಪಿಸಿ (ನಿಖರ ಸ್ಥಾಪನಾ ವಿಧಾನಕ್ಕಾಗಿ Minikube ಅಧಿಕೃತ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ನೋಡಿ)
brew install minikube

# kubectl ಅನ್ನು ಸ್ಥಾಪಿಸಿ
brew install kubectl

• Minikube ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ

minikube start

2. ಮೊದಲ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು

Nginx ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ, ನಾವು Nginx ಅನ್ನು ನಿಯೋಜಿಸಲು Deployment ಮತ್ತು Service ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಮಾಡಬಹುದು.

# deployment.yaml ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ
cat  deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# deployment ಅನ್ನು ಅನ್ವಯಿಸಿ
kubectl apply -f deployment.yaml

# service.yaml ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ
cat  service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort
EOF

# service ಅನ್ನು ಅನ್ವಯಿಸಿ
kubectl apply -f service.yaml

3. ಅಪ್ಲಿಕೇಶನ್ ಗೆ ಪ್ರವೇಶಿಸುವುದು

ನೀವು NodePort ಪ್ರಕಾರದ Service ಅನ್ನು ರಚಿಸಿದಾಗ, Kubernetes ಅದಕ್ಕೆ ಒಂದು ಪೋರ್ಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ. ಪ್ರವೇಶ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು:

minikube service nginx-service --url

ಮುದ್ರಿತ URL ಅನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪ್ರವೇಶಿಸುವ ಮೂಲಕ, Nginx ನ ಸ್ವಾಗತ ಪುಟವನ್ನು ನೋಡಬಹುದು.

ಸಾಮಾನ್ಯ ದೋಷಗಳು ಮತ್ತು ಡಿಬಗ್

Kubernetes ಬಳಸುವಾಗ, ನೀವು ಕೆಲವು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ Pod ಸ್ಥಿತಿ CrashLoopBackOff ಆಗಿದೆ. ಇದು ದೋಷವಲ್ಲ, ಆದರೆ ಇದು ಒಂದು ಸುರಕ್ಷತಾ ಯಂತ್ರಣೆಯಾಗಿದೆ, Kubernetes Pod ಕುಸಿದಾಗ ನಿರಂತರವಾಗಿ ಪುನರಾರಂಭಿಸುವುದಿಲ್ಲ, ಆದರೆ ಪ್ರತಿಯೊಂದು ಪುನರಾರಂಭದ ನಡುವಿನ ವಿಳಂಬವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ವ್ಯವಸ್ಥೆ ಗೊಂದಲದಿಂದ ತಪ್ಪಿಸಲು.

ನೀವು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು Pod ನ ಲಾಗ್‌ಗಳನ್ನು ನೋಡಬಹುದು, ಡಿಬಗ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ:

kubectl logs 

ನಿರ್ಣಯ

Kubernetes ಒಂದು ಶಕ್ತಿಯುತ ಕಂಟೈನರ್ ನಿರ್ವಹಣಾ ಸಾಧನವಾಗಿದೆ, ಇದರ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಸಾಮಾನ್ಯ ಆಜ್ಞೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ, ನೀವು ಕ್ಲೌಡ್ ನೈಸರ್ಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಕ್ಲೌಡ್ ಗಣನೆ ಮತ್ತು ಕಂಟೈನರ್ ತಂತ್ರಜ್ಞಾನಗಳ ಪ್ರಸಾರದಿಂದ, Kubernetes ಅನ್ನು ಕಲಿಯುವುದು ನಿಮ್ಮ ವೃತ್ತಿ ಅಭಿವೃದ್ಧಿಗೆ ಹೊಸ ಅವಕಾಶಗಳನ್ನು ತೆರೆಯುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ನಿಮ್ಮ Kubernetes ಕಲಿಕೆಯ ಪ್ರಯಾಣದಲ್ಲಿ ಸಹಾಯ ಮತ್ತು ಉಲ್ಲೇಖವನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂದು ಆಶಿಸುತ್ತೇವೆ.