28.1-dars: Docker — tushuncha

Muammo: "mening mashinamda ishlaydi"
   (Python versiyasi, kutubxona, muhit farqli)
Docker: dastur + barcha bog'liqliklar → konteyner
   har joyda bir xil ishlaydi

IMAGE (obraz) — o'zgarmas shablon (dastur + bog'liqliklar)
   masalan: python:3.14 + kodingiz + kutubxonalar
CONTAINER (konteyner) — imagedan ishga tushgan nusxa
   bir image → ko'p container (ishlaydigan)

Virtual mashina (VM): har biri to'liq OS (og'ir, sekin)
   [App][Guest OS] [App][Guest OS] → Hypervisor → Host OS

Konteyner: host OS yadrosini ulashadi (yengil, tez)
   [App][App][App] → Docker → Host OS (bir yadro)

# 1. BUILD — Dockerfile'dan image qurish
docker build -t myapp:v1 .

# 2. RUN — imagedan container ishga tushirish
docker run -p 8000:8000 myapp:v1

# 3. PUSH — imageni registryga yuborish
docker push myapp:v1

# boshqa: docker ps (ishlayotganlar), docker stop, docker logs

CREATED → RUNNING → PAUSED/STOPPED → REMOVED
docker run: created → running
docker stop: running → stopped
docker start: stopped → running
docker rm: removed (o'chirildi)

# ASOSIY TUSHUNCHALAR:
# Image — o'zgarmas shablon (dastur + bog'liqlik)
# Container — imagedan ishlaydigan nusxa
# Dockerfile — image qurish retsepti
# Registry — obrazlar ombori (Docker Hub)
# Volume — doimiy saqlash · Network — konteyner aloqasi

# ISH OQIMI:
docker build -t myapp:v1 .        # image qurish
docker run -p 8000:8000 myapp:v1  # container ishga tushirish
docker push myapp:v1              # registryga yuborish
docker pull myapp:v1              # registrydan olish

# BOSHQARISH:
docker ps                         # ishlayotgan containerlar
docker ps -a                      # barcha (to'xtagan ham)
docker stop <id>                  # to'xtatish
docker logs <id>                  # chiqishni ko'rish
docker exec -it <id> bash         # ichiga kirish
docker images                     # obrazlar ro'yxati
docker rm <id> / docker rmi <img> # o'chirish

# HAYOTIY SIKL: created → running → stopped → removed

Docker — dasturni bog'liqliklari bilan konteynerga qadoqlash
Image (shablon, o'zgarmas) → Container (ishlaydigan nusxa)
Konteyner — yengil (VM emas: host yadro ulashadi)
Build → Run → Push (ish oqimi) · Volume (doimiy saqlash)
Izchillik: har joyda bir xil ("mening mashinamda" muammosiz)

"""Image (shablon) va Container (nusxa) modeli — bir image, ko'p container."""


class Image:
    """O'zgarmas shablon (dastur + bog'liqliklar)."""

    def __init__(self, nom: str, tag: str, bogliqliklar: list) -> None:
        self.nom = nom
        self.tag = tag
        self.bogliqliklar = tuple(bogliqliklar)   # o'zgarmas

    def __repr__(self) -> str:
        return f"{self.nom}:{self.tag}"


class Container:
    """Imagedan ishga tushgan nusxa."""

    _keyingi_id = 1

    def __init__(self, image: Image) -> None:
        self.id = Container._keyingi_id
        Container._keyingi_id += 1
        self.image = image
        self.holat = "created"

    def ishga_tushir(self) -> None:
        self.holat = "running"

    def toxtat(self) -> None:
        self.holat = "stopped"


def main() -> None:
    print("=== 1. Image yaratish (shablon) ===")
    image = Image("myapp", "v1", ["python:3.14", "fastapi", "uvicorn"])
    print(f"  image: {image}")
    print(f"  bog'liqliklar: {list(image.bogliqliklar)}")

    print("\n=== 2. Bir imagedan ko'p container ===")
    c1 = Container(image)
    c2 = Container(image)
    c3 = Container(image)
    print(f"  container id'lar: {c1.id}, {c2.id}, {c3.id}")
    print(f"  hammasi bir image: {c1.image} = {c2.image} = {c3.image}")

    print("\n=== 3. Containerlarni ishga tushirish ===")
    c1.ishga_tushir()
    c2.ishga_tushir()
    print(f"  c1 holat: {c1.holat}, c2 holat: {c2.holat}, c3 holat: {c3.holat}")

    print("\n=== 4. Image o'zgarmas, container o'zgaruvchan ===")
    c1.toxtat()
    print(f"  c1 to'xtadi: {c1.holat}, c2 ishlayapti: {c2.holat}")
    print("  image — shablon (sinf), container — nusxa (obyekt)")
    print("  ⭐ Bir image → ko'p container")


if __name__ == "__main__":
    main()

=== 1. Image yaratish (shablon) ===
  image: myapp:v1
  bog'liqliklar: ['python:3.14', 'fastapi', 'uvicorn']

=== 2. Bir imagedan ko'p container ===
  container id'lar: 1, 2, 3
  hammasi bir image: myapp:v1 = myapp:v1 = myapp:v1

=== 3. Containerlarni ishga tushirish ===
  c1 holat: running, c2 holat: running, c3 holat: created

=== 4. Image o'zgarmas, container o'zgaruvchan ===
  c1 to'xtadi: stopped, c2 ishlayapti: running
  image — shablon (sinf), container — nusxa (obyekt)
  ⭐ Bir image → ko'p container

"""Konteyner hayotiy sikli: created → running → stopped → removed."""


class Konteyner:
    OTISHLAR = {
        "created": ["running"],
        "running": ["stopped", "paused"],
        "paused": ["running", "stopped"],
        "stopped": ["running", "removed"],
        "removed": [],
    }

    def __init__(self) -> None:
        self.holat = "created"
        self.tarix = ["created"]

    def otish(self, yangi_holat: str) -> str:
        if yangi_holat not in self.OTISHLAR[self.holat]:
            return f"Xato: {self.holat} → {yangi_holat} mumkin emas"
        self.holat = yangi_holat
        self.tarix.append(yangi_holat)
        return f"{self.tarix[-2]} → {yangi_holat}"


def main() -> None:
    k = Konteyner()

    print("=== 1. Boshlang'ich holat ===")
    print(f"  holat: {k.holat}")

    print("\n=== 2. Ishga tushirish (docker run) ===")
    print(f"  {k.otish('running')}")

    print("\n=== 3. To'xtatish va qayta ishga tushirish ===")
    print(f"  {k.otish('stopped')}")
    print(f"  {k.otish('running')}")

    print("\n=== 4. Noto'g'ri o'tish ===")
    print(f"  {k.otish('removed')}  (running'dan to'g'ridan removed emas)")
    k.otish("stopped")
    print(f"  {k.otish('removed')}  (stopped'dan removed mumkin)")
    print(f"  tarix: {k.tarix}")
    print("  ⭐ Konteyner — holatlar bo'ylab (hayotiy sikl)")


if __name__ == "__main__":
    main()

=== 1. Boshlang'ich holat ===
  holat: created

=== 2. Ishga tushirish (docker run) ===
  created → running

=== 3. To'xtatish va qayta ishga tushirish ===
  running → stopped
  stopped → running

=== 4. Noto'g'ri o'tish ===
  Xato: running → removed mumkin emas  (running'dan to'g'ridan removed emas)
  stopped → removed  (stopped'dan removed mumkin)
  tarix: ['created', 'running', 'stopped', 'running', 'stopped', 'removed']
  ⭐ Konteyner — holatlar bo'ylab (hayotiy sikl)

"""Konteyner vs VM: resurs iste'moli modeli (konteyner yengilroq)."""


def vm_resurs(dasturlar_soni: int) -> dict:
    # har VM to'liq OS yuklaydi
    os_hajmi_gb = 2.0        # har VM uchun guest OS
    dastur_hajmi_gb = 0.5
    return {
        "jami_gb": dasturlar_soni * (os_hajmi_gb + dastur_hajmi_gb),
        "ishga_tushish_sek": dasturlar_soni * 30,   # sekin
    }


def konteyner_resurs(dasturlar_soni: int) -> dict:
    # host OS ulashiladi (bir marta)
    host_os_gb = 2.0        # bir marta (ulashiladi)
    dastur_hajmi_gb = 0.5
    return {
        "jami_gb": host_os_gb + dasturlar_soni * dastur_hajmi_gb,
        "ishga_tushish_sek": dasturlar_soni * 2,    # tez
    }


def main() -> None:
    n = 5

    print(f"=== 1. {n} ta dastur — VM bilan ===")
    vm = vm_resurs(n)
    print(f"  disk: {vm['jami_gb']} GB")
    print(f"  ishga tushish: {vm['ishga_tushish_sek']} sek")

    print(f"\n=== 2. {n} ta dastur — konteyner bilan ===")
    kont = konteyner_resurs(n)
    print(f"  disk: {kont['jami_gb']} GB")
    print(f"  ishga tushish: {kont['ishga_tushish_sek']} sek")

    print("\n=== 3. Taqqoslash ===")
    print(f"  disk tejaladi: {vm['jami_gb'] - kont['jami_gb']} GB")
    print(f"  tezroq: {vm['ishga_tushish_sek'] // kont['ishga_tushish_sek']}x")

    print("\n=== 4. Sabab ===")
    print("  VM: har biri to'liq OS (og'ir)")
    print("  Konteyner: host yadro ulashadi (yengil)")
    print("  ⭐ Konteyner — yengil, tez (VM emas)")


if __name__ == "__main__":
    main()

=== 1. 5 ta dastur — VM bilan ===
  disk: 12.5 GB
  ishga tushish: 150 sek

=== 2. 5 ta dastur — konteyner bilan ===
  disk: 4.5 GB
  ishga tushish: 10 sek

=== 3. Taqqoslash ===
  disk tejaladi: 8.0 GB
  tezroq: 15x

=== 4. Sabab ===
  VM: har biri to'liq OS (og'ir)
  Konteyner: host yadro ulashadi (yengil)
  ⭐ Konteyner — yengil, tez (VM emas)

"""Docker ish oqimi: build → run → push (buyruqlar ketma-ketligi modeli)."""


class DockerMuhit:
    def __init__(self) -> None:
        self.obrazlar: dict = {}       # nom:tag → bog'liqliklar
        self.containerlar: list = []
        self.registry: dict = {}

    def build(self, nom_tag: str, bogliqliklar: list) -> str:
        self.obrazlar[nom_tag] = bogliqliklar
        return f"Image qurildi: {nom_tag} ({len(bogliqliklar)} qatlam)"

    def run(self, nom_tag: str, port: int) -> str:
        if nom_tag not in self.obrazlar:
            return f"Xato: {nom_tag} image topilmadi"
        container = {"image": nom_tag, "port": port, "holat": "running"}
        self.containerlar.append(container)
        return f"Container ishga tushdi: {nom_tag} (port {port})"

    def push(self, nom_tag: str) -> str:
        if nom_tag not in self.obrazlar:
            return f"Xato: {nom_tag} topilmadi"
        self.registry[nom_tag] = self.obrazlar[nom_tag]
        return f"Registryga yuborildi: {nom_tag}"


def main() -> None:
    docker = DockerMuhit()

    print("=== 1. BUILD (Dockerfile'dan image) ===")
    print(f"  {docker.build('myapp:v1', ['python:3.14', 'fastapi', 'kod'])}")

    print("\n=== 2. RUN (imagedan container) ===")
    print(f"  {docker.run('myapp:v1', 8000)}")
    print(f"  {docker.run('myapp:v1', 8001)}")
    print(f"  ishlayotgan containerlar: {len(docker.containerlar)}")

    print("\n=== 3. PUSH (registryga) ===")
    print(f"  {docker.push('myapp:v1')}")
    print(f"  registryda: {list(docker.registry)}")

    print("\n=== 4. Yo'q imageni run ===")
    print(f"  {docker.run('boshqa:v9', 9000)}")
    print("  oqim: build → run → push (kod → konteyner → tarqatish)")
    print("  ⭐ Docker ish oqimi — build, run, push")


if __name__ == "__main__":
    main()

=== 1. BUILD (Dockerfile'dan image) ===
  Image qurildi: myapp:v1 (3 qatlam)

=== 2. RUN (imagedan container) ===
  Container ishga tushdi: myapp:v1 (port 8000)
  Container ishga tushdi: myapp:v1 (port 8001)
  ishlayotgan containerlar: 2

=== 3. PUSH (registryga) ===
  Registryga yuborildi: myapp:v1
  registryda: ['myapp:v1']

=== 4. Yo'q imageni run ===
  Xato: boshqa:v9 image topilmadi
  oqim: build → run → push (kod → konteyner → tarqatish)
  ⭐ Docker ish oqimi — build, run, push

# baza container ichida (o'chsa yo'qoladi)      # ⚠️
docker run -v data:/var/lib/postgresql ...      # ✅ volume

docker build -t myapp:latest .   # doim latest   # ⚠️
docker build -t myapp:v1.2 .     # versiya (tag)  # ✅

# bir konteynerda dastur + baza + kesh          # ⚠️
# har xizmat alohida konteyner (bir vazifa)      # ✅

ENV PAROL=secret123   # imageda qoladi           # ⚠️
# muhit o'zgaruvchisi run'da yoki secret          # ✅

docker run myapp   # port yo'q (kirib bo'lmaydi) # ⚠️
docker run -p 8000:8000 myapp                    # ✅

FROM ubuntu   # to'liq OS (og'ir)                # ⚠️
FROM python:3.14-slim   # yengil                  # ✅

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

1.  # Docker qanday muammoni hal qiladi?
2.  # image nima?
3.  # container nima?
4.  # image vs container?
5.  # konteyner vs VM?
6.  # nega konteyner yengil?
7.  # Dockerfile nima?
8.  # registry nima?
9.  # volume nima?
10. # docker build nima?
11. # docker run nima?
12. # konteyner o'tkinchimi?

1.  # baza container ichida saqlash      # volume

2.  docker build -t myapp:latest         # versiya

3.  # bir konteynerda dastur+baza+kesh    # alohida

4.  ENV PAROL=secret                      # muhit/secret

5.  docker run myapp   # port yo'q        # -p