Python kursi28.14-dars: Infrastructure as Code
Python kursi · Infratuzilma

28.14-dars: Infrastructure as Code

19 daqiqa14/14-dars

28-QISM — INFRATUZILMA · 14-dars


1. Kirish va motivatsiya

Bulut 28.13-bob serverlarni, bazalarni, tarmoqlarni bir necha bosish bilan yaratish imkonini beradi. Lekin qo'lda yaratish (bulut konsolida tugmalar bosish) muammolarga to'la: takrorlanmaydigan (yana yaratish — qanday sozlagandim?), hujjatsiz (nima yaratilgan — noma'lum), xatoga moyil (bir sozlama unutildi), izsiz (kim, nima, qachon o'zgartirdi?), dev/prod farqli (qo'lda — turlicha). 20 ta xizmatni qo'lda sozlash — koshmar. Infrastructure as Code (IaC) buni hal qiladi: infratuzilma (serverlar, tarmoqlar, bazalar) qo'lda emas, kod bilan ta'riflanadi. Kod ishga tushiriladi — infratuzilma yaratiladi (takrorlanadigan, versiyalangan, hujjatlangan).

Infrastructure as Code (IaC) — infratuzilmani (server, tarmoq, baza, sozlama) kod bilan ta'riflash va boshqarish: deklarativ ta'rif (nima kerakligini kodda — Terraform, CloudFormation), versiyalash (git'da — o'zgarishlar kuzatiladi), takrorlanuvchanlik (bir kod — bir xil infratuzilma, dev/prod), avtomatlashtirish (qo'lda emas — kod ishga tushadi). Vositalar: Terraform (ko'p bulut, deklarativ — HCL), CloudFormation (AWS), Pulumi (haqiqiy dasturlash tili), Ansible (konfiguratsiya). Bu Docker (28.1 — Dockerfile), Kubernetes (28.6 — manifest), cloud 28.13-bob ustiga quriladi (barchasi "muhit kodi"). IaC — infratuzilmani kod qilish. Infratuzilma kodda — takrorlanadigan.

Real vaziyat. Bir jamoa prod muhitini qo'lda yaratgandi (AWS konsolida) — yangi test muhiti kerak bo'lganda uni qayta yaratish koshmar edi (qanday sozlangandi? qaysi sozlamalar? bir hafta ish, ko'p farq). Terraform qo'llanildi: butun infratuzilma kodda ta'riflandi (serverlar, baza, tarmoq — HCL). Endi terraform apply — bir buyruqda to'liq muhit (staging, prod — bir xil kod, turli o'zgaruvchi). Yangi muhit daqiqalar. O'zgarishlar git'da (kuzatiladi). IaC — infratuzilmani takrorlanadigan qildi.

Bu darsda Infrastructure as Code ni o'rganamiz.

Bu darsda:

  • IaC nima va nega
  • Deklarativ infratuzilma
  • Terraform va vositalar
  • Holat va reja (state, plan)
  • Versiyalash va takrorlanuvchanlik
  • IaC va boshqa "kod" (Docker, K8s)
  • IaC amaliyoti
  • Amaliy: IaC modeli

ℹ IaC amaliy vosita; misollar Python bilan IaC mantiqini modellashtiradi (deterministik).


2. Nazariya — chuqur tushuntirish

2.1. IaC nima va nega

Infratuzilmani kod bilan:

Qo'lda (konsolda tugmalar): takrorlanmaydigan, hujjatsiz, izsiz
   yangi muhit — koshmar (qanday sozlagandim?)

IaC (kod): terraform apply → infratuzilma
   takrorlanadigan, versiyalangan, hujjatlangan

Infrastructure as Code (IaC) — infratuzilmani (server, tarmoq, baza) qo'lda (bulut konsolida tugmalar) emas, kod bilan ta'riflash: kod ishga tushiriladi — infratuzilma yaratiladi. Sabab: qo'lda yaratish takrorlanmaydigan (yana qanday?), hujjatsiz (nima bor?), xatoga moyil (unutish), izsiz (kim o'zgartirdi?), dev/prod farqli; kod bilan — takrorlanadigan (bir kod — bir xil), versiyalangan (git — o'zgarishlar), hujjatlangan (kod — nima bor), avtomatik. IaC — muhitni kod qilish (Dockerfile 28.2 kabi, lekin butun infratuzilma). IaC — infratuzilmani takrorlanadigan qilish. Kod — infratuzilma haqiqati.

2.2. Deklarativ infratuzilma

Istalgan holatni ta'riflash:

hcl
# Terraform (deklarativ — nima kerak)
resource "aws_instance" "web" {
  ami           = "ami-123"
  instance_type = "t2.micro"
  tags = { Name = "web-server" }
}
# terraform apply → shu server yaratiladi
# ikkinchi apply → o'zgarish yo'q (allaqachon bor)

Deklarativ infratuzilma — siz infratuzilmani qanday yaratishni (qadamlar) emas, nima kerakligini (istalgan holat) kodda ta'riflaysiz — vosita joriy holatni shunga keltiradi (28.3 Compose, 28.5 Kubernetes kabi). Masalan "web server kerak" (resource) — Terraform yaratadi (yo'q bo'lsa), o'zgartiradi (farqli bo'lsa), o'chirmaydi (allaqachon to'g'ri bo'lsa) — reconciliation. Sabab: deklarativ — idempotent (qayta ishga tushirish xavfsiz — istalgan holatga keltiradi), takrorlanadigan (bir ta'rif — bir natija). Imperativ (qadamlar) o'rniga deklarativ (maqsad) — ishonchli 28.3-bob. Deklarativ — istalgan holat kodda. Nima kerak — vosita ta'minlaydi.

2.3. Terraform va vositalar

Vosita Xususiyat
Terraform Ko'p bulut, deklarativ (HCL)
CloudFormation AWS'ga xos (JSON/YAML)
Pulumi Haqiqiy til (Python, Go)
Ansible Konfiguratsiya (serverlar sozlash)

IaC vositalari: Terraform (HashiCorp — eng mashhur, ko'p bulut (AWS, GCP, Azure), deklarativ til HCL, provayder plaginlari); CloudFormation (AWS'ga xos — JSON/YAML); Pulumi (infratuzilmani haqiqiy dasturlash tilida — Python, Go — sikllar, funksiyalar); Ansible (konfiguratsiya boshqaruvi — serverlarni sozlash, dastur o'rnatish). Farq: provisioning (Terraform — resurs yaratish) vs configuration (Ansible — serverni sozlash). Terraform ko'p bulut (lock-in kam — 28.13), CloudFormation AWS. Tanlov: bulut, jamoa, ehtiyoj. Vositalar — IaC ni amalga oshirish. Har biri bir yondashuv.

2.4. Holat va reja (state, plan)

Joriy holatni kuzatish:

bash
# STATE — joriy infratuzilma holati (Terraform biladi nima bor)
terraform.tfstate   # yaratilgan resurslar

# PLAN — o'zgarishlarni oldindan ko'rish (apply'dan oldin)
terraform plan   # "3 qo'shiladi, 1 o'zgaradi, 0 o'chadi"

# APPLY — o'zgarishlarni qo'llash
terraform apply   # tasdiqdan keyin

Holat va reja: State (holat — terraform.tfstate) — Terraform yaratgan resurslarni kuzatadi (nima bor, qanday sozlangan — joriy holat); Plan (reja — terraform plan) — kod va joriy holatni solishtiradi, o'zgarishlarni oldindan ko'rsatadi ("3 qo'shiladi, 1 o'zgaradi, 1 o'chadi") — apply'dan oldin (xavfsizlik — nima bo'lishini bilib); Apply — o'zgarishlarni qo'llaydi. Sabab: state — reconciliation asosi (joriy vs istalgan farqi); plan — xavfsizlik (kutilmagan o'zgarish yo'q, ayniqsa o'chirish). State muhim (jamoada ulashiladi — remote state). Holat va reja — nazorat qilinadigan o'zgarish. Reja — o'zgarishni oldindan ko'rish.

2.5. Versiyalash va takrorlanuvchanlik

Versiyalash va takrorlanuvchanlik — IaC ning asosiy foydalari: versiyalash (infratuzilma kodi git'da — 05-qism: o'zgarishlar kuzatiladi, kim/nima/qachon, code review, rollback — infratuzilma tarixi); takrorlanuvchanlik (bir kod — bir xil infratuzilma: dev/staging/prod bir kod, turli o'zgaruvchilar — 28.13; yangi muhit daqiqalar); hujjat (kod — nima yaratilgan, aniq); hamkorlik (jamoa bir kod, review). Sabab: qo'lda — noma'lum, takrorlanmaydigan; kod — aniq, takrorlanadigan (28.1 Docker izchillik kabi, infratuzilma darajasida). Bu deploy 28.8-bob, CI/CD bilan bog'liq (infratuzilma ham pipeline'da). Versiyalash — infratuzilma tarixi va takrorlanuvchanlik. Kod — kuzatiladigan infratuzilma.

2.6. IaC va boshqa "kod" (Docker, K8s)

IaC butun "muhit kodi" oilasining bir qismi: Dockerfile (28.2 — bir konteyner muhiti), docker-compose.yml (28.3 — ko'p konteyner), Kubernetes manifest (28.6 — orkestratsiya), Terraform (28.14 — bulut infratuzilmasi), CI/CD pipeline (28.7-8 — jarayon), config (28.9 — sozlama). Barchasi bir tamoyil: hamma narsa kodda (qo'lda emas — takrorlanadigan, versiyalangan, avtomatik). Farq darajada: Dockerfile — dastur muhiti, Terraform — bulut resurslari (server, tarmoq). Ular birga: Terraform serverni yaratadi → Kubernetes'ni o'rnatadi → Docker konteynerlar ishlaydi. "Hamma narsa kodda" — DevOps falsafasi. IaC — infratuzilma darajasidagi kod. Butun stack kodda.

2.7. IaC amaliyoti

IaC amaliyotlari: deklarativ (istalgan holat — Terraform); versiyalash (git — code review, tarix); plan avval (plan — o'zgarishni ko'rish, ayniqsa o'chirish — xavfsizlik); remote state (jamoa — ulashilgan holat, qulflash); modullar (takroriy qismlar — DRY, 27.1); sirlarsiz (28.9 — parol kodda emas, o'zgaruvchi/sir menejeri); muhitlar (dev/prod — bir kod, turli o'zgaruvchi); kichik o'zgarishlar (28.6 — kichik, tez-tez, xavfsiz). Yomon: qo'lda o'zgartirish (drift — kod va haqiqat farqi), sirlar kodda, plansiz apply. Yaxshi IaC — deklarativ, versiyalangan, xavfsiz. Amaliyot — ishonchli infratuzilma. Kod va nazorat — ishonchli.

2.8. IaC — infratuzilmani boshqarilishimsh mumkin qilish

IaC asosiy g'oyasi — infratuzilmani dasturlash tamoyillari bilan boshqarish: infratuzilma ham kod (versiyalanadi, review qilinadi, sinaladi, takrorlanadi — dastur kabi). Bu qo'lda, "qor uyumi" serverlardan (snowflake — har biri o'ziga xos, takrorlanmaydigan) takrorlanadigan infratuzilmaga o'tish. IaC butun DevOps stackining (Docker 28.1, K8s 28.5, CI/CD 28.7-8, cloud 28.13) yakuni: hamma narsa kodda (dastur, muhit, infratuzilma, jarayon). Bu 28-qism (Infratuzilma) ning umumiy g'oyasi: infratuzilmani ishonchli, avtomatik, takrorlanadigan qilish. "Cattle, not pets" (chorva emas, uy hayvoni emas — serverlar almashtiriladigan, noyob emas). IaC — infratuzilmani kod bilan boshqarish. Takrorlanadigan infratuzilma — ishonchli tizim.


3. Tez ma'lumotnoma

hcl
# Terraform (HCL) — deklarativ infratuzilma
resource "aws_instance" "web" {
  ami           = "ami-123"
  instance_type = "t2.micro"
  tags = { Name = "web-server", Env = var.environment }
}

variable "environment" { default = "dev" }
output "ip" { value = aws_instance.web.public_ip }
bash
# TERRAFORM ISH OQIMI:
terraform init      # provayder plaginlari
terraform plan      # o'zgarishlarni ko'rish (oldindan)
terraform apply     # qo'llash (tasdiq bilan)
terraform destroy   # o'chirish

# STATE: terraform.tfstate (joriy holat — remote, ulashilgan)
# PLAN: "N qo'shiladi, M o'zgaradi, K o'chadi"

# VOSITALAR: Terraform (ko'p bulut), CloudFormation (AWS),
#            Pulumi (til), Ansible (konfiguratsiya)

# "MUHIT KODI" OILASI:
# Dockerfile · compose.yml · K8s manifest · Terraform · CI/CD

Infrastructure as Code xulosasi

IaC — infratuzilmani kod bilan (qo'lda emas)
Deklarativ (istalgan holat) · Terraform (ko'p bulut, HCL)
State (joriy holat) · plan (o'zgarishni oldindan ko'rish)
Versiyalash (git) · takrorlanuvchanlik (bir kod, ko'p muhit)
"Hamma narsa kodda" (Docker, K8s, Terraform — DevOps)

4. Batafsil misollar

IaC amaliy vosita; misollar Python bilan IaC mantiqini modellashtiradi.

Misol 1 — Deklarativ resurs (reconciliation)

python
"""Deklarativ IaC: istalgan holat vs joriy holat — reconciliation."""


class Infratuzilma:
    def __init__(self) -> None:
        self.joriy: dict = {}   # yaratilgan resurslar (state)

    def apply(self, istalgan: dict) -> list:
        amallar = []
        # yaratish/o'zgartirish
        for nom, config in istalgan.items():
            if nom not in self.joriy:
                amallar.append(f"+ {nom} yaratildi")
            elif self.joriy[nom] != config:
                amallar.append(f"~ {nom} o'zgartirildi")
        # o'chirish (istalganda yo'q)
        for nom in self.joriy:
            if nom not in istalgan:
                amallar.append(f"- {nom} o'chirildi")
        self.joriy = dict(istalgan)
        return amallar


def main() -> None:
    infra = Infratuzilma()

    print("=== 1. Birinchi apply (yaratish) ===")
    istalgan = {"web": "t2.micro", "baza": "db.small"}
    for amal in infra.apply(istalgan):
        print(f"  {amal}")

    print("\n=== 2. Ikkinchi apply (o'zgarishsiz) ===")
    amallar = infra.apply(istalgan)
    print(f"  o'zgarishlar: {len(amallar)} (idempotent)")

    print("\n=== 3. O'zgartirish (web turini) ===")
    yangi = {"web": "t2.large", "baza": "db.small"}
    for amal in infra.apply(yangi):
        print(f"  {amal}")

    print("\n=== 4. Resurs olib tashlash ===")
    kam = {"web": "t2.large"}   # baza yo'q
    for amal in infra.apply(kam):
        print(f"  {amal}")
    print("  ⭐ Deklarativ — istalgan holatga keltiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Birinchi apply (yaratish) ===
  + web yaratildi
  + baza yaratildi

=== 2. Ikkinchi apply (o'zgarishsiz) ===
  o'zgarishlar: 0 (idempotent)

=== 3. O'zgartirish (web turini) ===
  ~ web o'zgartirildi

=== 4. Resurs olib tashlash ===
  - baza o'chirildi
  ⭐ Deklarativ — istalgan holatga keltiradi

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Plan (o'zgarishlarni oldindan ko'rish)

python
"""Plan: apply'dan oldin o'zgarishlarni ko'rsatish (xavfsizlik — o'chirish)."""


def plan(joriy: dict, istalgan: dict) -> dict:
    reja = {"qoshiladi": [], "ozgaradi": [], "ochadi": []}
    for nom, config in istalgan.items():
        if nom not in joriy:
            reja["qoshiladi"].append(nom)
        elif joriy[nom] != config:
            reja["ozgaradi"].append(nom)
    for nom in joriy:
        if nom not in istalgan:
            reja["ochadi"].append(nom)
    return reja


def main() -> None:
    joriy = {"web": "t2.micro", "baza": "db.small", "kesh": "redis"}
    istalgan = {"web": "t2.large", "baza": "db.small", "navbat": "sqs"}

    reja = plan(joriy, istalgan)

    print("=== 1. Joriy holat ===")
    print(f"  {list(joriy)}")

    print("\n=== 2. Istalgan holat ===")
    print(f"  {list(istalgan)}")

    print("\n=== 3. Plan (o'zgarishlar) ===")
    print(f"  + qo'shiladi: {reja['qoshiladi']}")
    print(f"  ~ o'zgaradi: {reja['ozgaradi']}")
    print(f"  - o'chadi: {reja['ochadi']}")

    print("\n=== 4. Xavfsizlik ===")
    print(f"  {len(reja['ochadi'])} resurs o'chadi — DIQQAT!")
    print("  plan → tasdiq → apply (kutilmagan o'chirish yo'q)")
    print("  ⭐ Plan — o'zgarishni oldindan ko'rish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Joriy holat ===
  ['web', 'baza', 'kesh']

=== 2. Istalgan holat ===
  ['web', 'baza', 'navbat']

=== 3. Plan (o'zgarishlar) ===
  + qo'shiladi: ['navbat']
  ~ o'zgaradi: ['web']
  - o'chadi: ['kesh']

=== 4. Xavfsizlik ===
  1 resurs o'chadi — DIQQAT!
  plan → tasdiq → apply (kutilmagan o'chirish yo'q)
  ⭐ Plan — o'zgarishni oldindan ko'rish

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — Muhitlar (bir kod, turli o'zgaruvchi)

python
"""Takrorlanuvchanlik: bir IaC kod, turli muhit (o'zgaruvchilar bilan)."""


def infratuzilma_yarat(muhit: str, ozgaruvchilar: dict) -> dict:
    # bir shablon (kod), muhitga qarab o'zgaruvchilar
    return {
        "muhit": muhit,
        "web_soni": ozgaruvchilar["web_soni"],
        "server_turi": ozgaruvchilar["server_turi"],
        "baza_turi": ozgaruvchilar["baza_turi"],
    }


MUHIT_OZGARUVCHILARI = {
    "dev": {"web_soni": 1, "server_turi": "t2.micro", "baza_turi": "db.small"},
    "prod": {"web_soni": 5, "server_turi": "t2.large", "baza_turi": "db.large"},
}


def main() -> None:
    print("=== 1. Dev muhiti (bir kod) ===")
    dev = infratuzilma_yarat("dev", MUHIT_OZGARUVCHILARI["dev"])
    print(f"  web: {dev['web_soni']}, server: {dev['server_turi']}")

    print("\n=== 2. Prod muhiti (bir xil kod) ===")
    prod = infratuzilma_yarat("prod", MUHIT_OZGARUVCHILARI["prod"])
    print(f"  web: {prod['web_soni']}, server: {prod['server_turi']}")

    print("\n=== 3. Bir kod, turli natija ===")
    print(f"  dev: {dev['web_soni']} server, prod: {prod['web_soni']} server")
    print("  bir shablon, turli o'zgaruvchi (takrorlanadigan)")

    print("\n=== 4. Foyda ===")
    print("  yangi muhit — bir buyruq (o'zgaruvchilar bilan)")
    print("  dev = prod tuzilishi (farq — o'lcham)")
    print("  ⭐ Takrorlanuvchanlik — bir kod, ko'p muhit")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Dev muhiti (bir kod) ===
  web: 1, server: t2.micro

=== 2. Prod muhiti (bir xil kod) ===
  web: 5, server: t2.large

=== 3. Bir kod, turli natija ===
  dev: 1 server, prod: 5 server
  bir shablon, turli o'zgaruvchi (takrorlanadigan)

=== 4. Foyda ===
  yangi muhit — bir buyruq (o'zgaruvchilar bilan)
  dev = prod tuzilishi (farq — o'lcham)
  ⭐ Takrorlanuvchanlik — bir kod, ko'p muhit

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Drift aniqlash (kod vs haqiqat)

python
"""Drift: qo'lda o'zgarish kod bilan mos kelmaydi (IaC intizomini buzadi)."""


def drift_aniqla(kod_holati: dict, haqiqiy_holat: dict) -> list:
    driftlar = []
    for resurs, kod_config in kod_holati.items():
        haqiqiy = haqiqiy_holat.get(resurs)
        if haqiqiy is None:
            driftlar.append(f"{resurs}: kodda bor, haqiqatda yo'q")
        elif haqiqiy != kod_config:
            driftlar.append(f"{resurs}: kod={kod_config}, haqiqat={haqiqiy} (qo'lda o'zgartirilgan!)")
    return driftlar


def main() -> None:
    # kodda ta'riflangan
    kod = {"web": "t2.micro", "baza": "db.small"}
    # haqiqatda (kimdir qo'lda o'zgartirgan)
    haqiqat = {"web": "t2.large", "baza": "db.small"}   # web qo'lda o'zgartirilgan

    print("=== 1. Kod holati (IaC) ===")
    print(f"  {kod}")

    print("\n=== 2. Haqiqiy holat (bulut) ===")
    print(f"  {haqiqat}")

    print("\n=== 3. Drift aniqlash ===")
    driftlar = drift_aniqla(kod, haqiqat)
    for d in driftlar:
        print(f"  ⚠️ {d}")

    print("\n=== 4. Nega drift yomon ===")
    print("  kod haqiqatni aks ettirmaydi (yolg'on)")
    print("  keyingi apply — qo'lda o'zgarishni bekor qiladi")
    print("  qoida: faqat kod orqali o'zgartirish (qo'lda emas)")
    print("  ⭐ Drift — kod va haqiqat farqi (yomon)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Kod holati (IaC) ===
  {'web': 't2.micro', 'baza': 'db.small'}

=== 2. Haqiqiy holat (bulut) ===
  {'web': 't2.large', 'baza': 'db.small'}

=== 3. Drift aniqlash ===
  ⚠️ web: kod=t2.micro, haqiqat=t2.large (qo'lda o'zgartirilgan!)

=== 4. Nega drift yomon ===
  kod haqiqatni aks ettirmaydi (yolg'on)
  keyingi apply — qo'lda o'zgarishni bekor qiladi
  qoida: faqat kod orqali o'zgartirish (qo'lda emas)
  ⭐ Drift — kod va haqiqat farqi (yomon)

Nima ko'rsatdi: 2.7-bo'lim.


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

Noto'g'ri fikr To'g'risi
"Konsolda qo'lda yetadi" IaC (takrorlanadigan)
"IaC imperativ (qadamlar)" Deklarativ (istalgan holat)
"Plan keraksiz" Plan (o'zgarishni ko'rish — o'chirish!)
"State muhim emas" State — joriy holat (kuzatuv)
"Qo'lda tuzatish mayli" Drift (kod = haqiqat)
"Har muhit alohida kod" Bir kod, o'zgaruvchilar
"Sirlar IaC kodda" O'zgaruvchi/sir menejeri
"IaC = faqat Terraform" Oila (Docker, K8s, Terraform)

6. Keng tarqalgan xatolar va yechimlari

1. Qo'lda o'zgartirish (drift)

# konsolda resurs o'zgartirish (kod eskiradi)      # ⚠️
# faqat kod orqali (apply — kod = haqiqat)           # ✅

2. Plansiz apply

bash
terraform apply   # nima o'zgaradi noma'lum          # ⚠️
terraform plan; # ko'rib, keyin apply                 # ✅

3. Sirlar IaC kodda

hcl
password = "secret123"   # git'da                     # ⚠️
password = var.db_password   # o'zgaruvchi/sir         # ✅

4. State lokal (jamoa)

# terraform.tfstate lokal (jamoa nizosi)             # ⚠️
# remote state (S3 + qulflash)                         # ✅

5. Takror kod (modulsiz)

hcl
# har muhit uchun nusxa-joylash                        # ⚠️
# module (DRY — takroriy qism)                          # ✅

6. Katta, bir apply (hammasi)

# butun infratuzilma bir apply (xavfli)               # ⚠️
# kichik, bosqichma (28.6 — kichik o'zgarish)           # ✅

7. State'ni git'ga (sirlar)

git add terraform.tfstate   # sirlar bo'lishi mumkin  # ⚠️
# .gitignore + remote (shifrlangan)                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 28.13-dars (o'tilgan): Cloud — IaC bulut resurslarini
  • 28.6-dars (o'tilgan): K8s manifest — infratuzilma kodi
  • 28.2-dars (o'tilgan): Dockerfile — muhit kodi
  • 28.9-dars (o'tilgan): Sirlar — IaC'da o'zgaruvchi
  • 28.8-dars (o'tilgan): CD — infratuzilma pipeline'da

8. Eng yaxshi amaliyotlar

  1. Deklarativ (istalgan holat — Terraform).

  2. Versiyalash (git — review, tarix).

  3. Plan avval (o'zgarishni ko'rish — o'chirish!).

  4. Faqat kod orqali (drift emas).

  5. Remote state (jamoa — qulflash).

  6. Modullar (DRY — takroriy qism).

  7. Sirlarsiz (o'zgaruvchi/sir menejeri).

  8. Kichik o'zgarishlar (tez-tez, xavfsiz).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # IaC nima?
2.  # nega IaC (qo'lda emas)?
3.  # deklarativ nima?
4.  # Terraform nima?
5.  # state nima?
6.  # plan nima?
7.  # nega plan?
8.  # takrorlanuvchanlik nima?
9.  # drift nima?
10. # drift nega yomon?
11. # modul nima?
12. # "hamma narsa kodda"?
Javoblar
  1. Infratuzilmani kod bilan ta'riflash
  2. Takrorlanadigan, versiyalangan, hujjatlangan
  3. Istalgan holatni ta'riflash (qadamlar emas)
  4. Ko'p bulut IaC vositasi (HCL)
  5. Joriy infratuzilma holati (kuzatuv)
  6. O'zgarishlarni oldindan ko'rsatish
  7. Xavfsizlik (o'chirishni ko'rish)
  8. Bir kod — bir xil infratuzilma
  9. Kod va haqiqat farqi (qo'lda o'zgarish)
  10. Kod yolg'on (haqiqatni aks ettirmaydi)
  11. Takroriy infratuzilma qismi (DRY)
  12. Dastur, muhit, infratuzilma — hammasi kodda

Vazifa 2: Xatolarni tuzating

1.  # konsolda o'zgartirish (drift)

2.  terraform apply   # plansiz

3.  password = "secret"

4.  # state lokal (jamoa)

5.  # har muhit nusxa-joylash
Javoblar
1.  faqat kod orqali (apply)

2.  terraform plan; keyin apply

3.  var.db_password (o'zgaruvchi)

4.  remote state (S3 + qulflash)

5.  module (DRY)

Vazifa 3: Deklarativ

Modellang:

  1. Istalgan
  2. Joriy
  3. Reconciliation
  4. Idempotent

Vazifa 4: Plan

Modellang:

  1. Joriy
  2. Istalgan
  3. O'zgarishlar
  4. O'chirish

Vazifa 5: Muhitlar

Modellang:

  1. Shablon
  2. Dev
  3. Prod
  4. O'zgaruvchilar

Vazifa 6: Drift

Modellang:

  1. Kod
  2. Haqiqat
  3. Farq
  4. Muammo

Vazifa 7: O'ylash

Infrastructure as Code "hamma narsa kodda" (dastur, muhit, infratuzilma, jarayon) DevOps falsafasining cho'qqisi. Nima uchun "infratuzilmani kod qilish" (dasturlash tamoyillarini infratuzilmaga qo'llash) shunchalik kuchli o'zgarish (qor uyumidan chorvaga), va nega "drift" (kod va haqiqat farqi) IaC ning eng katta dushmani — bu "haqiqat manbai" (source of truth) tushunchasi haqida nima aytadi?

Javob

Qisqa javob: "Infratuzilmani kod qilish" kuchli o'zgarish, chunki u dasturlash tamoyillarini (versiyalash, review, test, takrorlanuvchanlik, avtomatlashtirish) infratuzilmaga olib keladi: an'anaviy usulda infratuzilma qo'lda boshqariladi (konsolda tugmalar, ssh bilan sozlash) — bu "qor uyumi" (snowflake) serverlarga olib keladi (har biri o'ziga xos, qo'lda sozlangan, takrorlanmaydigan, hujjatsiz — "uy hayvoni", noyob va qadrli, yiqilsa falokat). IaC buni "chorva" (cattle) ga aylantiradi (serverlar bir xil, koddan yaratiladi, almashtiriladigan — biri yiqilsa yangisini yaratasan, noyob emas). Bu farq katta: qor uyumi — mo'rt (noyob, takrorlanmaydigan, bir kishi biladi), chorva — chidamli (takrorlanadigan, avtomatik, hujjatlangan). "Kod qilish" infratuzilmani muhandislik intizomiga bo'ysundiradi (dastur kabi — versiya, test, review). "Drift" (kod va haqiqat farqi — kimdir qo'lda o'zgartirdi) IaC ning eng katta dushmani, chunki u haqiqat manbaini (single source of truth) buzadi: IaC ning butun kuchi kod haqiqatni aks ettiradi degan kafolatda (kodga qarab infratuzilmani bilasan); drift bo'lsa — kod yolg'on (kodda bir narsa, haqiqatda boshqa) — ishonch yo'qoladi (kodga ishonolmaysan, qo'lda tekshirish kerak — IaC foydasi yo'qoladi). Bundan tashqari: keyingi apply driftni bekor qiladi (qo'lda o'zgarishni yo'qotadi — kutilmagan) yoki konflikt. "Haqiqat manbai" tushunchasi — bir narsa uchun yagona avtoritet manba bo'lishi kerak (ikki manba — ziddiyat, qaysi to'g'ri?); IaC'da kod haqiqat manbai (undan infratuzilma). Drift ikki manba yaratadi (kod va qo'lda o'zgarish) — ziddiyat. Qoida: faqat kod orqali o'zgartirish (qo'lda emas — haqiqat manbaini bitta saqlash). Muhandislik saboqlari: kod qilish — muhandislik intizomi (versiya, test — dastur kabi); qor uyumi → chorva (noyob → takrorlanadigan); haqiqat manbai yagona bo'lishi kerak (ikki manba — ziddiyat); drift — haqiqat manbaini buzadi (IaC ishonchini yo'qotadi).

1. Nega kod qilish kuchli

Dasturlash tamoyillarini (versiya, review, test, takror) infratuzilmaga. Qo'lda → kod (intizom).

2. Qor uyumi vs chorva

Model Xususiyat
Qor uyumi (snowflake) Noyob, qo'lda, mo'rt
Chorva (cattle) Takrorlanadigan, kod, chidamli

Server — almashtiriladigan (noyob emas).

3. Nega drift eng katta dushman

IaC kuchi: kod haqiqatni aks ettiradi. Drift → kod yolg'on → ishonch yo'q (qo'lda tekshirish — foyda yo'qoladi).

4. Haqiqat manbai (source of truth)

Bir narsa uchun yagona avtoritet manba. IaC'da kod. Drift ikki manba (kod + qo'lda) — ziddiyat.

5. Muhandislik saboqlari

  1. Kod qilish — muhandislik intizomi
  2. Qor uyumi → chorva (takrorlanadigan)
  3. Haqiqat manbai yagona (ikki — ziddiyat)
  4. Drift — IaC ishonchini buzadi (faqat kod orqali)

6. Xulosa

  1. Infratuzilmani kod — dasturlash intizomi (versiya, test)
  2. Qor uyumi → chorva (noyob → takrorlanadigan)
  3. Drift — kod yolg'on (haqiqat manbaini buzadi)
  4. Faqat kod orqali (yagona haqiqat manbai)

Nimani mustahkamlaydi: 2.7, 2.8-bo'limlar.


Xulosa

Bu darsda Infrastructure as Code ni o'rgandik.

Eng muhim uch fikr:

  1. IaC va deklarativ infratuzilma. Infrastructure as Code (IaC) — infratuzilmani (server, tarmoq, baza) qo'lda emas (konsolda tugmalar), kod bilan ta'riflash: kod ishga tushiriladi — infratuzilma yaratiladi (takrorlanadigan, versiyalangan, hujjatlangan, avtomatik); qo'lda — takrorlanmaydigan, izsiz, xatoga moyil. Deklarativ — qanday (qadamlar) emas, nima kerakligini (istalgan holat) ta'riflaysiz, vosita joriy holatni shunga keltiradi (reconciliation, idempotent — 28.3, 28.5 kabi). "Web server kerak" → Terraform yaratadi/o'zgartiradi/tegmaydi.

  2. Terraform, state, plan. Vositalar: Terraform (eng mashhur, ko'p bulut — AWS/GCP/Azure, deklarativ HCL), CloudFormation (AWS), Pulumi (haqiqiy til — Python), Ansible (konfiguratsiya). State (terraform.tfstate) — Terraform yaratgan resurslarni kuzatadi (joriy holat — reconciliation asosi); Plan (terraform plan) — kod va joriy holatni solishtirib o'zgarishlarni oldindan ko'rsatadi ("3 qo'shiladi, 1 o'chadi") — apply'dan oldin (xavfsizlik, ayniqsa o'chirish); Apply — qo'llaydi. Remote state (jamoa — ulashilgan, qulflash).

  3. Versiyalash, drift, "hamma narsa kodda". Versiyalash (git — o'zgarishlar, review, rollback, tarix) va takrorlanuvchanlik (bir kod — dev/prod, turli o'zgaruvchilar; yangi muhit daqiqalar) — IaC asosiy foydalari. Drift (kod va haqiqat farqi — qo'lda o'zgarish) — IaC dushmani: kod haqiqat manbaini (source of truth) aks ettirishi kerak, drift kodni yolg'on qiladi (ishonch yo'qoladi) — qoida: faqat kod orqali. IaC "muhit kodi" oilasining (Dockerfile 28.2, compose 28.3, K8s manifest 28.6, Terraform, CI/CD) yakuni — hamma narsa kodda (dastur, muhit, infratuzilma, jarayon — DevOps falsafasi); infratuzilma dasturlash intizomiga (versiya, review, test — "qor uyumi"dan "chorva"ga: noyob → takrorlanadigan). IaC — infratuzilmani ishonchli, avtomatik, takrorlanadigan qilish.

Bu bilan 28-qism (Infratuzilma) yakunlandi: Docker, Dockerfile, Docker Compose, konteyner optimizatsiyasi, Kubernetes (tushuncha va deploy), CI/CD, muhit va sirlar boshqaruvi, monitoring, markazlashgan loglar, xato kuzatuvi (Sentry), cloud (AWS/GCP) va Infrastructure as Code. Keyingi — 29-qism: Miqyos va unumdorlik — tizimni tez va ko'p yukka bardoshli qilish: profiling, kesh, navbatlar, yuk taqsimlash va baza miqyoslash.

Infratuzilma · 14-dars yakunlandi

28.14-dars: Infrastructure as Code

19 daqvaqt
0belgi
Keyingi dars: 29.1-dars: Unumdorlikni o'lchash
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0