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 പഠനയാത്രയിൽ നിങ്ങൾക്ക് സഹായവും പരാമർശവും നൽകുമെന്ന് പ്രതീക്ഷിക്കുന്നു.