28.5-dars: Kubernetes — tushuncha

28-QISM — INFRATUZILMA · 5-dars

1. Kirish va motivatsiya

Docker Compose 28.3-bob bir mashinada ko'p konteynerni boshqaradi — bu rivojlanish uchun a'lo. Lekin haqiqiy ishlab chiqarishda: yuz minglab foydalanuvchi, o'nlab server, konteyner yiqilsa avtomatik tiklash, yuk oshsa avtomatik ko'paytirish, yangi versiyani uzilishsiz chiqarish kerak. Buni qo'lda boshqarish imkonsiz (qaysi konteyner qaysi serverda? biri yiqildi — kim tiklaydi?). Kubernetes — ko'p mashinada ko'p konteynerni avtomatik boshqarish (orkestratsiya) tizimi: konteynerlarni serverlar bo'ylab joylashtirar, yiqilganini tiklaydi, yukni ko'paytiradi, yangilashni boshqaradi — hammasi avtomatik.

Kubernetes (K8s) — konteyner orkestratsiya platformasi: ko'p mashinada (klaster) konteynerlarni avtomatik joylashtirish, boshqarish, miqyoslash. Asosiy tushunchalar: Pod (eng kichik birlik — bir yoki bir necha konteyner), Deployment (podlarni boshqarish — nechta, qaysi versiya), Service (podlarga barqaror kirish nuqtasi), Node (klasterdagi bir mashina), Cluster (barcha node'lar). Kubernetes deklarativ (28.3 — istalgan holatni ta'riflaysiz), o'z-o'zini tuzatadi (self-healing — yiqilganini tiklaydi), avtomatik miqyoslaydi. Bu Docker 28.1-bob, Compose 28.3-bob dan keyingi bosqich (bir mashinadan ko'p mashinaga). Kubernetes — katta miqyosda konteyner boshqaruvi. Orkestratsiya — avtomatik boshqaruv.

Real vaziyat. Bir tizim o'sib, bir server yetmay qoldi (yuk oshdi, tez-tez yiqilardi). Konteynerlarni qo'lda ko'p serverga tarqatish — koshmar (qaysi qayerda, biri yiqilsa qo'lda tiklash, kechasi ham). Kubernetes qo'llanildi: Deployment (3 nusxa dastur), Service (yuk taqsimlash), avtomatik miqyoslash (yuk oshsa 3→10 pod), self-healing (yiqilgan pod avtomatik tiklanadi). Endi tizim o'zini boshqaradi (yiqilish → tiklanish, yuk → miqyos). Jamoa kechalari tinch uxladi. Kubernetes — avtomatik boshqaruv.

Bu darsda Kubernetes tushunchasini o'rganamiz.

Bu darsda:

• Kubernetes nima va nega
• Pod (eng kichik birlik)
• Deployment (podlarni boshqarish)
• Service (barqaror kirish)
• Node va Cluster
• Deklarativ va self-healing
• Kubernetes qachon kerak
• Amaliy: orkestratsiya modeli

ℹ Kubernetes murakkab tizim; misollar Python bilan K8s tushunchalarini modellashtiradi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Kubernetes nima va nega

Ko'p mashinada avtomatik boshqaruv:

Compose: bir mashina, qo'lda boshqaruv
Kubernetes: ko'p mashina (klaster), avtomatik
   - konteynerlarni joylashtiradi (qaysi serverga)
   - yiqilganini tiklaydi (self-healing)
   - yukni ko'paytiradi (auto-scaling)
   - yangilashni boshqaradi (rolling update)

Kubernetes (K8s) — konteynerlarni ko'p mashinada avtomatik boshqarish (orkestratsiya) platformasi: konteynerlarni serverlar bo'ylab joylashtiradi, yiqilganini tiklaydi, yukka qarab ko'paytiradi, yangilashni boshqaradi. Sabab: katta tizimda (ko'p foydalanuvchi, ko'p server) konteynerlarni qo'lda boshqarish imkonsiz (qaysi qayerda, yiqilsa kim tiklaydi, yuk oshsa?) — Kubernetes buni avtomatlashtiradi. Bu Compose (28.3 — bir mashina) dan keyingi bosqich (ko'p mashina, avtomatik). K8s — bulut davri infratuzilma standarti. Kubernetes — konteyner orkestratsiyasi (avtomatik boshqaruv).

2.2. Pod (eng kichik birlik)

Bir yoki bir necha konteyner:

Pod — Kubernetes'ning eng kichik birligi
   [Pod: konteyner(lar) + umumiy tarmoq/saqlash]
   odatda bir pod = bir konteyner (dastur)
   ba'zan bir necha (dastur + yordamchi "sidecar")

Pod — Kubernetes'ning eng kichik boshqariladigan birligi: bir yoki bir necha konteyner (umumiy tarmoq, saqlash bilan). Odatda bir pod = bir konteyner (dastur); ba'zan bir necha (asosiy dastur + yordamchi "sidecar" — log yig'uvchi, proxy). Muhim: Kubernetes konteynerni emas, pod ni boshqaradi (pod — o'rash birligi). Pod o'tkinchi (ephemeral — yiqilsa yangi pod yaratiladi, eski tiklanmaydi — yangi ID, yangi IP). Podlar to'g'ridan yaratilmaydi (Deployment orqali — 28.5.3). Pod — konteyner(lar) o'rami (Kubernetes birligi). Eng kichik birlik.

2.3. Deployment (podlarni boshqarish)

Nechta pod, qaysi versiya:

apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3           # 3 nusxa pod (istalgan holat)
  template:
    spec:
      containers:
        - name: myapp
          image: myapp:v1.2
# Kubernetes 3 podni ta'minlaydi (biri yiqilsa — yangi)

Deployment — podlarni boshqarish obyekti: nechta nusxa (replicas: 3), qaysi image (versiya), qanday yangilash. Siz istalgan holatni ta'riflaysiz ("3 pod ishlashi kerak"), Kubernetes buni ta'minlaydi (2 ta bo'lsa — 1 qo'shadi, 4 bo'lsa — 1 o'chiradi — reconciliation). Deployment: self-healing (yiqilgan podni almashtiradi), miqyoslash (replicas o'zgartirish — 3→10), rolling update (yangi versiyani bosqichma-bosqich — 28.8). Siz podlarni qo'lda emas, Deployment orqali boshqarasiz. Deployment — istalgan pod holatini ta'minlash. Deklarativ pod boshqaruvi.

2.4. Service (barqaror kirish)

Podlarga o'zgarmas manzil:

kind: Service
spec:
  selector:
    app: myapp          # shu yorliqli podlar
  ports:
    - port: 80
# podlar o'zgaradi (IP), Service barqaror manzil beradi
# + yukni podlar orasida taqsimlaydi (load balancing)

Service — podlarga barqaror kirish nuqtasi (o'zgarmas manzil): podlar o'tkinchi (yiqilsa yangi IP — 28.5.2), lekin Service barqaror nom/IP beradi (podlar o'zgarsa ham). Service yorliq (label) bo'yicha podlarni topadi (selector: app: myapp) va yukni taqsimlaydi (load balancing — so'rovlarni podlar orasida). Turlari: ClusterIP (klaster ichida), NodePort/LoadBalancer (tashqaridan kirish). Sabab: mijoz o'zgaruvchan pod IP'lariga emas, barqaror Service'ga murojaat qiladi. Service — podlarga barqaror eshik (yuk taqsimlash bilan). Barqaror manzil — o'zgaruvchan podlar.

2.5. Node va Cluster

Mashinalar to'plami:

Cluster (klaster) — barcha mashinalar
   ├── Master/Control Plane — boshqaruv (rejalashtirish)
   ├── Node 1 — [Pod][Pod]
   ├── Node 2 — [Pod][Pod][Pod]
   └── Node 3 — [Pod]
   Kubernetes podlarni node'lar bo'ylab joylashtiradi

Node va Cluster: Node — klasterdagi bir mashina (fizik yoki virtual server), podlar shu node'larda ishlaydi; Cluster — barcha node'lar to'plami (bir tizim sifatida). Control Plane (boshqaruv) — Kubernetes miyasi (podlarni qayerga joylashtirish — scheduler, holatni kuzatish); Worker node'lar — podlarni ishga tushiradi. Kubernetes podlarni node'lar bo'ylab avtomatik joylashtiradi (resurs, yuk bo'yicha) — siz qaysi pod qaysi node'da ekanini bilishingiz shart emas. Bir node yiqilsa — podlar boshqa node'ga ko'chadi. Node — mashina, Cluster — mashinalar tizimi. Klaster — bir katta kompyuter kabi.

2.6. Deklarativ va self-healing

Kubernetes ikki kuchli xususiyat: Deklarativ 28.3-bob — siz istalgan holatni ta'riflaysiz (YAML — "3 pod, v1.2 image"), Kubernetes joriy holatni shunga keltiradi (reconciliation — doim tekshiradi, farqni tuzatadi); Self-healing (o'z-o'zini tuzatish) — Kubernetes doim istalgan holatni ta'minlaydi: pod yiqilsa — yangi pod, node yiqilsa — podlar ko'chadi, sog'liq tekshiruvi (health check) muvaffaqiyatsiz — pod qayta ishga tushadi. Bu inson aralashuvisiz (avtomatik). Farqi Compose'dan: Compose bir marta ishga tushiradi (keyin nazorat yo'q), Kubernetes doim kuzatadi/tuzatadi. Deklarativ + self-healing — avtomatik, ishonchli tizim. O'z-o'zini tuzatadi.

2.7. Kubernetes qachon kerak

Kubernetes kuchli, lekin murakkab — har loyihaga emas: kerak — katta miqyos (ko'p server, ko'p foydalanuvchi), yuqori mavjudlik (uzilishsiz — self-healing), avtomatik miqyoslash (yuk o'zgaruvchan), ko'p mikroservis (27.9 — o'nlab xizmat), katta jamoa; kerak emas — kichik loyiha (bir server yetadi — Compose), oddiy ilova, kichik jamoa (K8s murakkabligi ortiqcha). Kubernetes murakkab (o'rganish egri chizig'i, boshqarish yuki) — kichik loyihaga "temir to'p bilan chumchuq otish". Alternativalar: Compose (kichik), boshqariladigan xizmatlar (managed — bulut K8s, yoki Heroku/Railway — soddaroq). K8s — katta miqyos uchun (kichikka ortiqcha). Miqyos — Kubernetes sababi.

2.8. Kubernetes — deklarativ orkestratsiya

Kubernetes asosiy g'oyasi — deklarativ orkestratsiya: siz tizimning istalgan holatini (nima ishlashi kerak) ta'riflaysiz, Kubernetes uni avtomatik ta'minlaydi va saqlaydi (joylashtirish, tiklash, miqyoslash — reconciliation loop). Bu Compose (28.3 — deklarativ, bir mashina), Docker (28.1 — konteyner) ustiga quriladi (ko'p mashina, avtomatik). K8s bulut-mahalliy (cloud-native) arxitekturaning asosi (mikroservis 27.9, chidamlilik 27.12 ni amalda). Lekin murakkab — muvozanat kerak (kichik loyihaga Compose). Kubernetes — infratuzilmani deklarativ boshqarish (istalgan holat → avtomatik ta'minlash). Deklarativ orkestratsiya — o'zini boshqaruvchi tizim. Istalgan holat — avtomatik saqlanadi.

3. Tez ma'lumotnoma

# POD — eng kichik birlik (konteyner o'rami)
# odatda Deployment orqali (to'g'ridan emas)

# DEPLOYMENT — podlarni boshqarish
apiVersion: apps/v1
kind: Deployment
spec:
  replicas: 3               # istalgan holat (3 pod)
  selector:
    matchLabels: {app: myapp}
  template:
    metadata:
      labels: {app: myapp}
    spec:
      containers:
        - name: myapp
          image: myapp:v1.2

# SERVICE — barqaror kirish + load balancing
kind: Service
spec:
  selector: {app: myapp}
  ports:
    - port: 80

# TUSHUNCHALAR:
# Pod — konteyner(lar) · Deployment — nechta/versiya
# Service — barqaror manzil · Node — mashina · Cluster — tizim

# BUYRUQLAR (kubectl):
# kubectl apply -f deploy.yaml   # istalgan holatni qo'llash
# kubectl get pods               # podlar
# kubectl scale --replicas=10    # miqyoslash

Kubernetes xulosasi

K8s — ko'p mashinada konteynerni avtomatik boshqarish
Pod (konteyner o'rami) · Deployment (nechta, versiya)
Service (barqaror manzil + yuk taqsimlash) · Node/Cluster
Deklarativ (istalgan holat) + self-healing (avtomatik tiklash)
Katta miqyos uchun (kichikka Compose — muvozanat)

4. Batafsil misollar

Kubernetes murakkab tizim; misollar Python bilan K8s tushunchalarini modellashtiradi.

Misol 1 — Deployment: istalgan holat (replicas)

"""Deployment: istalgan pod sonini ta'minlash (reconciliation)."""


class Deployment:
    def __init__(self, nom: str, istalgan_replicas: int) -> None:
        self.nom = nom
        self.istalgan = istalgan_replicas
        self.podlar: list = []

    def reconcile(self) -> str:
        """Joriy holatni istalgan holatga keltirish."""
        joriy = len(self.podlar)
        if joriy < self.istalgan:
            for i in range(self.istalgan - joriy):
                self.podlar.append(f"pod-{len(self.podlar) + 1}")
            return f"{self.istalgan - joriy} pod qo'shildi"
        elif joriy > self.istalgan:
            olib = joriy - self.istalgan
            self.podlar = self.podlar[: self.istalgan]
            return f"{olib} pod o'chirildi"
        return "o'zgarishsiz (istalgan holat)"


def main() -> None:
    deploy = Deployment("myapp", istalgan_replicas=3)

    print("=== 1. Boshlang'ich (0 pod) ===")
    print(f"  {deploy.reconcile()}")
    print(f"  podlar: {deploy.podlar}")

    print("\n=== 2. Bir pod yiqildi (self-healing) ===")
    deploy.podlar.pop()   # yiqilish
    print(f"  yiqilishdan keyin: {len(deploy.podlar)} pod")
    print(f"  {deploy.reconcile()}")
    print(f"  podlar: {deploy.podlar}")

    print("\n=== 3. Miqyoslash (3 → 5) ===")
    deploy.istalgan = 5
    print(f"  {deploy.reconcile()}")
    print(f"  podlar soni: {len(deploy.podlar)}")

    print("\n=== 4. Kamaytirish (5 → 2) ===")
    deploy.istalgan = 2
    print(f"  {deploy.reconcile()}")
    print(f"  podlar soni: {len(deploy.podlar)}")
    print("  ⭐ Deployment — istalgan holatni ta'minlaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Boshlang'ich (0 pod) ===
  3 pod qo'shildi
  podlar: ['pod-1', 'pod-2', 'pod-3']

=== 2. Bir pod yiqildi (self-healing) ===
  yiqilishdan keyin: 2 pod
  1 pod qo'shildi
  podlar: ['pod-1', 'pod-2', 'pod-3']

=== 3. Miqyoslash (3 → 5) ===
  2 pod qo'shildi
  podlar soni: 5

=== 4. Kamaytirish (5 → 2) ===
  3 pod o'chirildi
  podlar soni: 2
  ⭐ Deployment — istalgan holatni ta'minlaydi

Nima ko'rsatdi: 2.3, 2.6-bo'limlar.

Misol 2 — Service: yuk taqsimlash (load balancing)

"""Service: so'rovlarni podlar orasida taqsimlash (barqaror kirish)."""


class Service:
    def __init__(self, nom: str, podlar: list) -> None:
        self.nom = nom
        self.podlar = podlar
        self._keyingi = 0

    def sorov_yubor(self, sorov: str) -> str:
        # round-robin: so'rovlarni navbat bilan podlarga
        if not self.podlar:
            return "Xato: pod yo'q"
        pod = self.podlar[self._keyingi % len(self.podlar)]
        self._keyingi += 1
        return f"{sorov} → {pod}"


def main() -> None:
    service = Service("myapp-service", ["pod-1", "pod-2", "pod-3"])

    print("=== 1. Barqaror manzil ===")
    print(f"  service: {service.nom} (podlar: {service.podlar})")

    print("\n=== 2. So'rovlar taqsimlanadi (round-robin) ===")
    for i in range(5):
        print(f"  {service.sorov_yubor(f'sorov-{i + 1}')}")

    print("\n=== 3. Pod yiqildi (Service moslashadi) ===")
    service.podlar = ["pod-1", "pod-3"]   # pod-2 yiqildi
    service._keyingi = 0
    print(f"  qolgan podlar: {service.podlar}")
    for i in range(3):
        print(f"  {service.sorov_yubor(f'yangi-{i + 1}')}")

    print("\n=== 4. Foyda ===")
    print("  mijoz Service'ga (barqaror), podlar o'zgaradi")
    print("  yuk podlar orasida taqsimlanadi")
    print("  ⭐ Service — barqaror kirish + yuk taqsimlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barqaror manzil ===
  service: myapp-service (podlar: ['pod-1', 'pod-2', 'pod-3'])

=== 2. So'rovlar taqsimlanadi (round-robin) ===
  sorov-1 → pod-1
  sorov-2 → pod-2
  sorov-3 → pod-3
  sorov-4 → pod-1
  sorov-5 → pod-2

=== 3. Pod yiqildi (Service moslashadi) ===
  qolgan podlar: ['pod-1', 'pod-3']
  yangi-1 → pod-1
  yangi-2 → pod-3
  yangi-3 → pod-1

=== 4. Foyda ===
  mijoz Service'ga (barqaror), podlar o'zgaradi
  yuk podlar orasida taqsimlanadi
  ⭐ Service — barqaror kirish + yuk taqsimlash

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — Podlarni node'larga joylashtirish (scheduler)

"""Scheduler: podlarni node'lar bo'ylab resurs bo'yicha joylashtirish."""


class Node:
    def __init__(self, nom: str, sigim: int) -> None:
        self.nom = nom
        self.sigim = sigim
        self.podlar: list = []

    def bosh_joy(self) -> int:
        return self.sigim - len(self.podlar)


def joylashtir(nodelar: list, pod: str) -> str:
    # eng ko'p bo'sh joyli node'ga (oddiy strategiya)
    mos = max(nodelar, key=lambda n: n.bosh_joy())
    if mos.bosh_joy() <= 0:
        return f"{pod}: joy yo'q (barcha node to'la)"
    mos.podlar.append(pod)
    return f"{pod} → {mos.nom}"


def main() -> None:
    nodelar = [Node("node-1", 2), Node("node-2", 3), Node("node-3", 2)]

    print("=== 1. Node'lar (sig'im) ===")
    for n in nodelar:
        print(f"  {n.nom}: {n.sigim} pod sig'imi")

    print("\n=== 2. Podlarni joylashtirish ===")
    for i in range(1, 6):
        print(f"  {joylashtir(nodelar, f'pod-{i}')}")

    print("\n=== 3. Node yuklari ===")
    for n in nodelar:
        print(f"  {n.nom}: {len(n.podlar)}/{n.sigim} ({n.podlar})")

    print("\n=== 4. Kubernetes avtomatik joylashtiradi ===")
    print("  resurs, yuk bo'yicha (siz bilishingiz shart emas)")
    print("  node yiqilsa — podlar boshqasiga ko'chadi")
    print("  ⭐ Scheduler — podlarni node'larga joylashtiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Node'lar (sig'im) ===
  node-1: 2 pod sig'imi
  node-2: 3 pod sig'imi
  node-3: 2 pod sig'imi

=== 2. Podlarni joylashtirish ===
  pod-1 → node-2
  pod-2 → node-1
  pod-3 → node-2
  pod-4 → node-3
  pod-5 → node-1

=== 3. Node yuklari ===
  node-1: 2/2 (['pod-2', 'pod-5'])
  node-2: 2/3 (['pod-1', 'pod-3'])
  node-3: 1/2 (['pod-4'])

=== 4. Kubernetes avtomatik joylashtiradi ===
  resurs, yuk bo'yicha (siz bilishingiz shart emas)
  node yiqilsa — podlar boshqasiga ko'chadi
  ⭐ Scheduler — podlarni node'larga joylashtiradi

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Self-healing (holat kuzatuvi)

"""Self-healing: Kubernetes doim istalgan holatni kuzatadi va tiklaydi."""


class Klaster:
    def __init__(self, istalgan_holat: int) -> None:
        self.istalgan = istalgan_holat
        self.sog_podlar: list = [f"pod-{i}" for i in range(1, istalgan_holat + 1)]
        self.tiklashlar = 0

    def pod_yiqilishi(self, pod: str) -> None:
        if pod in self.sog_podlar:
            self.sog_podlar.remove(pod)

    def kuzatuv_sikli(self) -> str:
        # istalgan holatdan farqni tuzatish
        yetishmaydi = self.istalgan - len(self.sog_podlar)
        if yetishmaydi > 0:
            for i in range(yetishmaydi):
                yangi = f"pod-yangi-{self.tiklashlar + 1}"
                self.sog_podlar.append(yangi)
                self.tiklashlar += 1
            return f"{yetishmaydi} pod tiklandi"
        return "sog'lom (istalgan holat)"


def main() -> None:
    klaster = Klaster(istalgan_holat=3)

    print("=== 1. Sog'lom klaster ===")
    print(f"  podlar: {klaster.sog_podlar}")
    print(f"  {klaster.kuzatuv_sikli()}")

    print("\n=== 2. Ikki pod yiqildi ===")
    klaster.pod_yiqilishi("pod-1")
    klaster.pod_yiqilishi("pod-2")
    print(f"  sog' podlar: {klaster.sog_podlar}")

    print("\n=== 3. Kuzatuv sikli (self-healing) ===")
    print(f"  {klaster.kuzatuv_sikli()}")
    print(f"  podlar soni: {len(klaster.sog_podlar)}")

    print("\n=== 4. Jami tiklashlar ===")
    print(f"  {klaster.tiklashlar} pod tiklandi (avtomatik)")
    print("  Kubernetes doim kuzatadi (inson aralashuvisiz)")
    print("  ⭐ Self-healing — o'z-o'zini tuzatadi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Sog'lom klaster ===
  podlar: ['pod-1', 'pod-2', 'pod-3']
  sog'lom (istalgan holat)

=== 2. Ikki pod yiqildi ===
  sog' podlar: ['pod-3']

=== 3. Kuzatuv sikli (self-healing) ===
  2 pod tiklandi
  podlar soni: 3

=== 4. Jami tiklashlar ===
  2 pod tiklandi (avtomatik)
  Kubernetes doim kuzatadi (inson aralashuvisiz)
  ⭐ Self-healing — o'z-o'zini tuzatadi

Nima ko'rsatdi: 2.6-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Podlarni to'g'ridan yaratish

kind: Pod   # yiqilsa tiklanmaydi                # ⚠️
kind: Deployment   # self-healing                 # ✅

2. Pod IP'ga bog'lanish

ulanish("10.1.2.3")   # pod IP o'zgaradi          # ⚠️
ulanish("myapp-service")   # barqaror              # ✅

3. Kichik loyihaga Kubernetes

# bir server, oddiy ilovaga K8s klaster           # ⚠️
# Docker Compose (soddaroq)                        # ✅

4. Resurs chegarasiz podlar

containers: [{image: myapp}]   # cheksiz resurs    # ⚠️
resources: {limits: {memory: 512Mi, cpu: 0.5}}    # ✅

5. Health check yo'q

# pod "ishlayapti" lekin javob bermaydi            # ⚠️
livenessProbe, readinessProbe                       # ✅

6. latest image tag

image: myapp:latest   # qaysi versiya?             # ⚠️
image: myapp:v1.2.3    # aniq                        # ✅

7. State'ni podda saqlash

# ma'lumot pod ichida (o'tkinchi — yo'qoladi)      # ⚠️
# PersistentVolume (doimiy saqlash)                 # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 28.3-dars (o'tilgan): Compose — bir mashina (K8s — ko'p)
• 28.6-dars: Kubernetes deploy — amaliy
• 28.13-dars: Cloud — boshqariladigan K8s (EKS, GKE)
• 27.9-dars (o'tilgan): Mikroservis — K8s bilan
• 27.12-dars (o'tilgan): Chidamlilik — self-healing

8. Eng yaxshi amaliyotlar

1. Deployment (Pod emas — self-healing).

2. Service (barqaror manzil, IP emas).

3. Resurs chegaralari (limits/requests).

4. Health check (liveness/readiness).

5. Aniq image tag (latest emas).

6. State — PersistentVolume (pod o'tkinchi).

7. Deklarativ (YAML, kubectl apply).

8. K8s — katta miqyos (kichikka Compose).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # Kubernetes nima?
2.  # nega kerak?
3.  # Pod nima?
4.  # Pod barqarormi?
5.  # Deployment nima?
6.  # replicas nima?
7.  # Service nima?
8.  # nega Service (barqaror)?
9.  # Node nima?
10. # Cluster nima?
11. # self-healing nima?
12. # K8s qachon kerak?

Vazifa 2: Xatolarni tuzating

1.  kind: Pod   # to'g'ridan

2.  ulanish("10.1.2.3")   # pod IP

3.  # kichik loyihaga K8s

4.  containers: [myapp]   # resurs cheksiz

5.  image: myapp:latest

1.  kind: Deployment (self-healing)

2.  ulanish("myapp-service")

3.  Docker Compose (soddaroq)

4.  resources: {limits: {...}}

5.  image: myapp:v1.2.3

Vazifa 3: Deployment

Modellang:

1. replicas
2. Reconcile
3. Self-healing
4. Miqyoslash

Vazifa 4: Service

Modellang:

1. Podlar
2. Barqaror manzil
3. Yuk taqsimlash
4. Round-robin

Vazifa 5: Scheduler

Modellang:

1. Node'lar
2. Sig'im
3. Joylashtirish
4. Yuk

Vazifa 6: Self-healing

Modellang:

1. Istalgan holat
2. Yiqilish
3. Kuzatuv
4. Tiklash

Vazifa 7: O'ylash

Kubernetes "deklarativ orkestratsiya" va "self-healing" g'oyalarini keng ko'lamda amalga oshiradi: siz istalgan holatni ta'riflaysiz, tizim uni avtomatik saqlaydi. Nima uchun bu "istalgan holat + reconciliation loop" (joriy holatni istalganga keltirish) namunasi kuchli va universal (nafaqat Kubernetes'da), va nega Kubernetes'ning kuchi ayni vaqtda uning murakkabligining sababi — kichik loyihaga nega ortiqcha?

Nimani mustahkamlaydi: 2.6, 2.8-bo'limlar.

Xulosa

Bu darsda Kubernetes tushunchasini o'rgandik.

Eng muhim uch fikr:

1. Kubernetes va Pod. Kubernetes (K8s) — konteynerlarni ko'p mashinada avtomatik boshqarish (orkestratsiya): serverlar bo'ylab joylashtirish, yiqilganini tiklash, yukka qarab ko'paytirish, yangilash — Compose (28.3 — bir mashina) dan keyingi bosqich (ko'p mashina, avtomatik). Pod — eng kichik boshqariladigan birlik (bir yoki bir necha konteyner — umumiy tarmoq/saqlash); odatda bir pod = bir konteyner; pod o'tkinchi (yiqilsa yangi pod — yangi IP, eski tiklanmaydi); podlar to'g'ridan emas, Deployment orqali.

2. Deployment, Service, Node/Cluster. Deployment — podlarni boshqarish (replicas: 3 — nechta, qaysi image); siz istalgan holatni ta'riflaysiz, Kubernetes ta'minlaydi (reconciliation), self-healing (yiqilganini almashtiradi), miqyoslash, rolling update. Service — podlarga barqaror kirish (podlar o'tkinchi/IP o'zgaradi, Service barqaror nom) + yuk taqsimlash (load balancing); yorliq (label) bo'yicha podlarni topadi. Node — klasterdagi bir mashina, Cluster — barcha node'lar (Control Plane boshqaradi); Kubernetes podlarni node'lar bo'ylab avtomatik joylashtiradi.

3. Deklarativ, self-healing, muvozanat. Kubernetes deklarativ (istalgan holatni YAML'da ta'riflaysiz, tizim joriy holatni shunga keltiradi — reconciliation) va self-healing (o'z-o'zini tuzatadi — pod/node yiqilsa avtomatik tiklaydi, inson aralashuvisiz). "Istalgan holat + reconciliation loop" — universal, kuchli namuna (termostat, git kabi — o'z-o'zini tuzatuvchi). Kubernetes kuchli, lekin murakkab (ko'p tushuncha, qism, sozlama) — kuch murakkablik bilan keladi (avtomatika narxi): katta miqyos (ko'p server, foydalanuvchi, mikroservis) uchun zarur, kichik loyihaga ortiqcha (Compose yetadi — vositani miqyosga moslash, KISS). K8s — bulut-mahalliy arxitektura standarti (mikroservis 27.9, chidamlilik 27.12 amalda).

Keyingi darsda Kubernetes deploy ni o'rganamiz: amaliy jihatdan Deployment va Service YAML manifestlarini yozish, kubectl bilan ilovani klasterga chiqarish va boshqarish.