28.2-dars: Dockerfile yozish

FROM python:3.14-slim        # asosiy image
WORKDIR /app                 # ishchi papka
COPY requirements.txt .      # bog'liqliklar ro'yxati
RUN pip install -r requirements.txt   # o'rnatish
COPY . .                     # kod
CMD ["python", "app.py"]     # ishga tushirish

Har Dockerfile buyrug'i → bir QATLAM (layer)
FROM python:3.14   → qatlam 1
COPY requirements  → qatlam 2
RUN pip install    → qatlam 3
COPY . .           → qatlam 4
   Docker qatlamlarni KESHLAYDI
   o'zgarmagan qatlam → qayta qurilmaydi (tez)

# YAXSHI: kutubxonalar (kam o'zgaradi) avval
COPY requirements.txt .
RUN pip install -r requirements.txt   # kesh saqlanadi
COPY . .                              # kod (tez-tez o'zgaradi)

# YOMON: kod avval → har o'zgarishda pip qayta ishlaydi
COPY . .
RUN pip install -r requirements.txt   # kesh buziladi

# CMD — standart buyruq (almashtiriladi)
CMD ["python", "app.py"]
# docker run myapp → python app.py
# docker run myapp bash → bash (CMD almashtirildi)

# ENTRYPOINT — asosiy buyruq (o'zgarmas)
ENTRYPOINT ["python", "app.py"]
# argumentlar qo'shiladi

# .dockerignore (COPY chetlab o'tadi)
.git
__pycache__
*.pyc
.env          # sirlar!
node_modules
venv

# ODATIY PYTHON DOCKERFILE:
FROM python:3.14-slim         # yengil asos
WORKDIR /app                  # ishchi papka
COPY requirements.txt .       # bog'liqliklar (avval — kesh)
RUN pip install --no-cache-dir -r requirements.txt
COPY . .                      # kod (keyin — tez o'zgaradi)
EXPOSE 8000                   # port (hujjat)
USER appuser                  # root emas (xavfsizlik)
CMD ["python", "app.py"]      # ishga tushirish

# BUYRUQLAR:
# FROM — asosiy image | WORKDIR — papka
# COPY — fayl nusxala | RUN — build buyrug'i (o'rnatish)
# ENV — muhit o'zgaruvchisi | EXPOSE — port
# CMD — ishga tushirish (almashtiriladi)
# ENTRYPOINT — asosiy buyruq (o'zgarmas)

# QATLAM: har buyruq → qatlam (keshlanadi)
# TARTIB: kam o'zgaradiganlar avval (kesh)
# .dockerignore: .git, __pycache__, .env (sirlar)

Dockerfile — image qurish retsepti (FROM, COPY, RUN, CMD)
Har buyruq → qatlam (keshlanadi — o'zgarmagan qayta qurilmaydi)
Tartib: kam o'zgaradiganlar avval (kutubxona → kod)
CMD (almashtiriladi) · ENTRYPOINT (o'zgarmas)
.dockerignore (sir/keraksiz) · yengil asos · root emas

"""Dockerfile buyruqlarini tahlil qilish — har buyruq bir qatlam."""


def dockerfile_tahlil(satrlar: list) -> list:
    qatlamlar = []
    for satr in satrlar:
        satr = satr.strip()
        if not satr or satr.startswith("#"):
            continue   # bo'sh yoki izoh
        buyruq = satr.split()[0]
        qatlamlar.append({"buyruq": buyruq, "matn": satr})
    return qatlamlar


def main() -> None:
    dockerfile = [
        "FROM python:3.14-slim",
        "WORKDIR /app",
        "# bog'liqliklar",
        "COPY requirements.txt .",
        "RUN pip install -r requirements.txt",
        "COPY . .",
        "CMD [\"python\", \"app.py\"]",
    ]

    qatlamlar = dockerfile_tahlil(dockerfile)

    print("=== 1. Qatlamlar soni ===")
    print(f"  {len(qatlamlar)} qatlam (izohlar hisobga olinmaydi)")

    print("\n=== 2. Har qatlam (buyruq) ===")
    for i, q in enumerate(qatlamlar, 1):
        print(f"  {i}. {q['buyruq']}")

    print("\n=== 3. Buyruq turlari ===")
    buyruqlar = [q["buyruq"] for q in qatlamlar]
    print(f"  FROM: {buyruqlar.count('FROM')}, COPY: {buyruqlar.count('COPY')}")
    print(f"  RUN: {buyruqlar.count('RUN')}, CMD: {buyruqlar.count('CMD')}")

    print("\n=== 4. Birinchi buyruq FROM bo'lishi kerak ===")
    print(f"  birinchi: {qatlamlar[0]['buyruq']} (to'g'ri: FROM)")
    print("  ⭐ Har buyruq → bir qatlam")


if __name__ == "__main__":
    main()

=== 1. Qatlamlar soni ===
  6 qatlam (izohlar hisobga olinmaydi)

=== 2. Har qatlam (buyruq) ===
  1. FROM
  2. WORKDIR
  3. COPY
  4. RUN
  5. COPY
  6. CMD

=== 3. Buyruq turlari ===
  FROM: 1, COPY: 2
  RUN: 1, CMD: 1

=== 4. Birinchi buyruq FROM bo'lishi kerak ===
  birinchi: FROM (to'g'ri: FROM)
  ⭐ Har buyruq → bir qatlam

"""Kesh mantiqi: o'zgargan qatlamdan keyingilar qayta quriladi."""


def build_simulyatsiya(qatlamlar: list, ozgargan_indeks: int) -> dict:
    natija = []
    kesh_buzildi = False
    for i, qatlam in enumerate(qatlamlar):
        if i == ozgargan_indeks:
            kesh_buzildi = True   # shu qatlamdan keyingilar qayta quriladi
        if kesh_buzildi:
            natija.append({"qatlam": qatlam, "holat": "QAYTA QURILDI"})
        else:
            natija.append({"qatlam": qatlam, "holat": "keshdan (tez)"})
    return {"qatlamlar": natija, "qayta_qurildi": sum(1 for n in natija if "QAYTA" in n["holat"])}


def main() -> None:
    qatlamlar = ["FROM", "COPY requirements", "RUN pip install", "COPY kod", "CMD"]

    print("=== 1. Faqat kod o'zgardi (4-qatlam) ===")
    r = build_simulyatsiya(qatlamlar, ozgargan_indeks=3)
    for n in r["qatlamlar"]:
        print(f"  {n['qatlam']}: {n['holat']}")

    print(f"\n=== 2. Qayta qurilgan qatlamlar ===")
    print(f"  {r['qayta_qurildi']} ta (faqat kod va keyingi)")
    print("  kutubxonalar keshdan (tez)")

    print("\n=== 3. requirements o'zgardi (2-qatlam) ===")
    r2 = build_simulyatsiya(qatlamlar, ozgargan_indeks=1)
    print(f"  qayta qurilgan: {r2['qayta_qurildi']} ta")
    print("  pip install ham qayta (kesh buzildi)")

    print("\n=== 4. Xulosa ===")
    print("  kod o'zgarishi: 2 qatlam qayta (tez)")
    print("  requirements o'zgarishi: 4 qatlam qayta (sekin)")
    print("  ⭐ O'zgargan qatlamdan keyingilar qayta quriladi")


if __name__ == "__main__":
    main()

=== 1. Faqat kod o'zgardi (4-qatlam) ===
  FROM: keshdan (tez)
  COPY requirements: keshdan (tez)
  RUN pip install: keshdan (tez)
  COPY kod: QAYTA QURILDI
  CMD: QAYTA QURILDI

=== 2. Qayta qurilgan qatlamlar ===
  2 ta (faqat kod va keyingi)
  kutubxonalar keshdan (tez)

=== 3. requirements o'zgardi (2-qatlam) ===
  qayta qurilgan: 4 ta
  pip install ham qayta (kesh buzildi)

=== 4. Xulosa ===
  kod o'zgarishi: 2 qatlam qayta (tez)
  requirements o'zgarishi: 4 qatlam qayta (sekin)
  ⭐ O'zgargan qatlamdan keyingilar qayta quriladi

"""Tartib optimizatsiyasi: kod o'zgarishida qayta qurilish (yaxshi vs yomon)."""


def qayta_qurilish_soni(qatlamlar: list, kod_indeksi: int) -> int:
    # kod o'zgarganda: kod va keyingi qatlamlar qayta quriladi
    return len(qatlamlar) - kod_indeksi


def main() -> None:
    # YAXSHI tartib: kutubxona avval, kod keyin
    yaxshi = ["FROM", "COPY requirements", "RUN pip install", "COPY kod", "CMD"]
    # YOMON tartib: kod avval, kutubxona keyin
    yomon = ["FROM", "COPY kod", "COPY requirements", "RUN pip install", "CMD"]

    print("=== 1. YAXSHI tartib (kutubxona avval) ===")
    for i, q in enumerate(yaxshi):
        print(f"  {i}. {q}")

    print("\n=== 2. Kod o'zgarganda (yaxshi) ===")
    yaxshi_qayta = qayta_qurilish_soni(yaxshi, kod_indeksi=3)
    print(f"  qayta qurilgan: {yaxshi_qayta} qatlam (kod, CMD)")
    print("  pip install keshdan (tez)")

    print("\n=== 3. Kod o'zgarganda (yomon) ===")
    yomon_qayta = qayta_qurilish_soni(yomon, kod_indeksi=1)
    print(f"  qayta qurilgan: {yomon_qayta} qatlam")
    print("  pip install ham qayta (sekin)")

    print("\n=== 4. Taqqoslash ===")
    print(f"  yaxshi: {yaxshi_qayta} qatlam, yomon: {yomon_qayta} qatlam")
    print("  kam o'zgaradiganlar avval → kesh ishlaydi")
    print("  ⭐ To'g'ri tartib — tez build (kesh)")


if __name__ == "__main__":
    main()

=== 1. YAXSHI tartib (kutubxona avval) ===
  0. FROM
  1. COPY requirements
  2. RUN pip install
  3. COPY kod
  4. CMD

=== 2. Kod o'zgarganda (yaxshi) ===
  qayta qurilgan: 2 qatlam (kod, CMD)
  pip install keshdan (tez)

=== 3. Kod o'zgarganda (yomon) ===
  qayta qurilgan: 4 qatlam
  pip install ham qayta (sekin)

=== 4. Taqqoslash ===
  yaxshi: 2 qatlam, yomon: 4 qatlam
  kam o'zgaradiganlar avval → kesh ishlaydi
  ⭐ To'g'ri tartib — tez build (kesh)

"""dockerignore: keraksiz/sir fayllarni chetlab o'tish (image yengil, xavfsiz)."""


DOCKERIGNORE = {".git", "__pycache__", ".env", "venv", "node_modules"}


def copy_qilinadi(fayllar: list) -> dict:
    kiritilgan = []
    chetlab = []
    for fayl in fayllar:
        # dockerignore naqshiga mos keladimi
        if any(fayl == naqsh or fayl.startswith(naqsh + "/") for naqsh in DOCKERIGNORE):
            chetlab.append(fayl)
        else:
            kiritilgan.append(fayl)
    return {"kiritilgan": kiritilgan, "chetlab": chetlab}


def main() -> None:
    fayllar = ["app.py", "requirements.txt", ".git", ".env", "__pycache__", "utils.py", "venv"]

    natija = copy_qilinadi(fayllar)

    print("=== 1. Barcha fayllar ===")
    print(f"  {fayllar}")

    print("\n=== 2. Imagega kiritilgan ===")
    print(f"  {natija['kiritilgan']}")

    print("\n=== 3. Chetlab o'tilgan (.dockerignore) ===")
    print(f"  {natija['chetlab']}")

    print("\n=== 4. Nega muhim ===")
    print("  .env — sir (imagega tushmasligi kerak!)")
    print("  .git, venv — keraksiz (image yengil)")
    print(f"  {len(natija['chetlab'])} fayl chetlab o'tildi")
    print("  ⭐ .dockerignore — yengil va xavfsiz image")


if __name__ == "__main__":
    main()

=== 1. Barcha fayllar ===
  ['app.py', 'requirements.txt', '.git', '.env', '__pycache__', 'utils.py', 'venv']

=== 2. Imagega kiritilgan ===
  ['app.py', 'requirements.txt', 'utils.py']

=== 3. Chetlab o'tilgan (.dockerignore) ===
  ['.git', '.env', '__pycache__', 'venv']

=== 4. Nega muhim ===
  .env — sir (imagega tushmasligi kerak!)
  .git, venv — keraksiz (image yengil)
  4 fayl chetlab o'tildi
  ⭐ .dockerignore — yengil va xavfsiz image

COPY . .                      # kesh buziladi        # ⚠️
RUN pip install ...
# yaxshi:
COPY requirements.txt .       # avval (kesh)          # ✅
RUN pip install ...
COPY . .

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

COPY .env .                   # sir imageda!          # ⚠️
# .dockerignore'ga .env + run vaqtida muhit           # ✅

RUN apt update
RUN apt install -y curl       # 2 qatlam              # ⚠️
RUN apt update && apt install -y curl   # 1 qatlam     # ✅

CMD ["python", "app.py"]      # root (xavfli)          # ⚠️
USER appuser                                            # ✅
CMD ["python", "app.py"]

FROM python:latest            # qaysi versiya?         # ⚠️
FROM python:3.14-slim         # aniq                    # ✅

RUN pip install -r req.txt    # kesh qoladi            # ⚠️
RUN pip install --no-cache-dir -r req.txt              # ✅

1.  # Dockerfile nima?
2.  # FROM nima?
3.  # COPY nima?
4.  # RUN nima?
5.  # CMD nima?
6.  # RUN vs CMD?
7.  # qatlam nima?
8.  # kesh qanday ishlaydi?
9.  # nega tartib muhim?
10. # CMD vs ENTRYPOINT?
11. # .dockerignore nima?
12. # nega slim asos?

1.  COPY . .
    RUN pip install       # kesh buziladi

2.  FROM python:3.14       # og'ir

3.  COPY .env .            # sir

4.  RUN apt update
    RUN apt install curl   # ko'p qatlam

5.  FROM python:latest     # noaniq