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 స్థానిక పరీక్షను ఉపయోగించడం లేదా క్లౌడ్ సేవా ప్రదాతల (ఉదాహరణకు Google Kubernetes Engine, 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

# డిప్లాయ్‌మెంట్‌ను అప్లై చేయండి
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

# సేవను అప్లై చేయండి
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 యొక్క నేర్చుకునే ప్రయాణంలో సహాయం మరియు సూచనలను అందించగలదని ఆశిస్తున్నాము.