რა არის Kubernetes და რა პრობლემებს წყვეტს?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (ხშირად შემოკლებით **K8s**) არის ღია კოდის **კონტეინერების ორკესტრაციის (container orchestration)** პლატფორმა. ის ავტომატიზირებს კონტეინერიზებული აპლიკაციების გაშლას, მასშტაბირებას, ქსელურ კავშირსა და აღდგენას მანქანების კლასტერზე, ასე რომ თქვენ აღწერთ *სასურველ მდგომარეობას (desired state)*, ხოლო Kubernetes განუწყვეტლივ მუშაობს იმაზე, რომ რეალობა მას დაემთხვეს.

## პრობლემა: კონტეინერების დიდ მასშტაბზე გაშვება რთულია

```text
You have containers (from Docker), but in production you must also answer:
  → On WHICH machine does each container run? (scheduling)
  → What if a container crashes? (self-healing / restarts)
  → What if a whole node dies? (reschedule elsewhere)
  → How do 50 replicas find and talk to each other? (service discovery)
  → How do I roll out a new version with zero downtime? (rolling updates)
  → How do I scale from 3 to 30 replicas on a traffic spike? (autoscaling)
Doing all this by hand across many servers does not scale.
```

## გადაწყვეტა: დეკლარაციული ორკესტრაცია

თქვენ აგზავნით **manifest**-ს, რომელიც აღწერს რასაც გსურთ, ხოლო კლასტერის **მართვის მარყუჟები (control loops)** სისტემას იმ მდგომარეობისკენ მიჰყავს:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "მინდა, რომ ყოველთვის 3 ასლი მუშაობდეს"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # სასურველი მდგომარეობის დეკლარირება
kubectl get pods              # Kubernetes-მა შექმნა და დაგეგმა 3 Pod
```

თუ Pod მოკვდება, Kubernetes ამჩნევს სხვაობას (მუშაობს 2, სასურველი კი 3) და ავტომატურად ქმნის შემცვლელს.

## რას გაძლევთ Kubernetes

```text
✓ SCHEDULING       — places Pods on nodes based on resources & constraints
✓ SELF-HEALING     — restarts failed containers, replaces dead Pods/nodes
✓ SERVICE DISCOVERY— stable virtual IPs & DNS names for groups of Pods
✓ LOAD BALANCING   — spreads traffic across healthy replicas
✓ ROLLING UPDATES  — ship new versions with no downtime, roll back on failure
✓ SCALING          — manual or automatic (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — inject configuration without rebuilding images
✓ STORAGE ORCHESTRATION — attach persistent volumes to workloads
```

## დეკლარაციული vs იმპერატიული

```text
IMPERATIVE  → "run this command, then that command" (you manage each step)
DECLARATIVE → "here is the end state I want" (Kubernetes reconciles to it)
The declarative, reconciliation-loop model is Kubernetes' core idea.
```

## რატომ არის ეს მნიშვნელოვანი

Kubernetes გახდა де-факто სტანდარტი კონტეინერიზებული workload-ების production-ში გასაშვებად, ამიტომ იმის გაგება, თუ რა არის ის და რა პრობლემებს წყვეტს, ფუნდამენტური და ფართოდ გამოსაყენებელი ცოდნაა. კონტეინერები (ისეთი ხელსაწყოებიდან, როგორიც Docker-ია) აგვარებენ შეფუთვის საკითხს, მაგრამ ისინი პასუხს არ სცემენ იმ საოპერაციო კითხვებს, რომლებიც დიდ მასშტაბზე ჩნდება: რომელ მანქანაზე მუშაობს თითოეული კონტეინერი, რა ხდება, როცა კონტეინერი ან მთელი node ცდება მწყობრიდან, როგორ პოულობს და ესაუბრება ერთმანეთს ათობით ასლი, როგორ გავშალოთ ახალი ვერსია downtime-ის გარეშე და როგორ გავზარდოთ ან შევამციროთ მასშტაბი მოთხოვნის მიხედვით. Kubernetes ყველა ამ საკითხს **დეკლარაციული, შეჯერებაზე დაფუძნებული (reconciliation-based)** მოდელით აგვარებს: თქვენ აღწერთ სასურველ მდგომარეობას manifest-ში, ხოლო კლასტერის მართვის მარყუჟები განუწყვეტლივ მიჰყავს ფაქტობრივ მდგომარეობას მისკენ — ქმნის, გეგმავს, თავიდან უშვებს და ცვლის Pod-ებს საჭიროებისამებრ. ეს გაძლევთ **თვით-აღდგენას** (crash-ქმნილი კონტეინერები და მკვდარი node-ები ავტომატურად აღდგება), **service discovery-სა და load balancing-ს** (სტაბილური ვირტუალური IP-ები და DNS Pod-ების ჯგუფების წინ), **rolling update-ებსა და rollback-ებს** (downtime-ის გარეშე გაშლა), **მასშტაბირებას** (ხელით ან ავტომატურ) და **config-ის, secret-ისა და storage-ის ორკესტრაციას**. რადგან Kubernetes საფუძვლად უდევს იმას, თუ როგორ შლის და ოპერირებს პროგრამულ უზრუნველყოფას ინდუსტრიის დიდი ნაწილი — ყველა მთავარ ღრუბელსა და on-premises გარემოში — მისი დანიშნულებისა და გულში მდებარე დეკლარაციული მოდელის გაგება არსებითი კონტექსტია თანამედროვე ინფრასტრუქტურული სამუშაოსთვის და ის აზრობრივი საფუძველია, რომელზეც Kubernetes-ის ყველა სხვა კონცეფცია შენდება.

პრობლემა: კონტეინერების დიდ მასშტაბზე გაშვება რთულია

გადაწყვეტა: დეკლარაციული ორკესტრაცია

რას გაძლევთ Kubernetes

დეკლარაციული vs იმპერატიული

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები