Kubernetes-ის შესავალი სახელმძღვანელო: როგორ უნდა მართოთ კონტეინერიზებული აპლიკაციები ეფექტურად

Kubernetes გახდა ყველაზე პოპულარული კონტეინერების მართვის პლატფორმა, რომელიც უზრუნველყოფს ავტომატიზირებული განთავსების, გაფართოების და მართვის გადაწყვეტილებებს კონტეინერიზებული აპლიკაციებისათვის. ეს სტატია მოამზადებს პრაქტიკულ შესავალ სახელმძღვანელოს დამწყებთათვის და საშუალო დონის პროგრამისტებისთვის, რათა სწრაფად დაეუფლონ Kubernetes-ის ძირითადი კონცეფციების და პრაქტიკული ოპერაციების.

რა არის Kubernetes?

Kubernetes (ჩვეულებრივ, K8s-ის სახელით არის ცნობილი) არის ღია წყაროს პლატფორმა, რომელიც ავტომატიზირებს კონტეინერიზებული აპლიკაციების განთავსებას, გაფართოებას და მართვას. იგი შექმნილია Google-ის მიერ და გადაცემულია Cloud Native Computing Foundation (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

# გამოიყენეთ 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-ის სწავლის პროცესში.