IlmHamroh
Python kursi/Avtomatlashtirish7/10-dars17 daqiqa
Mundarija (22)

26.7-dars: API integratsiyasi

26-QISM — AVTOMATLASHTIRISH · 7-dars

1. Kirish va motivatsiya

26.3–26.6 da scraping (HTML) ni ko'rdik — mo'rt, etik muammoli. Ko'p xizmat (ob-havo, valyuta, ijtimoiy tarmoq, to'lov, xarita) esa rasmiy API beradi — dastur uchun ma'lumot yo'li. API scraping'dan afzal: rasmiy (ruxsat etilgan), barqaror (26.4 — HTML mo'rt), toza (JSON). Lekin API bilan ishlash o'z qoidalariga ega: autentifikatsiya (kalit), sahifalash (ko'p ma'lumot), rate limit (cheklov), xatolarni boshqarish.

API integratsiyasi — rasmiy API bilan ishlash: autentifikatsiya (API kaliti, OAuth — kim so'rayapti), endpointlar (turli yo'llar — /users, /orders), so'rov turlari (GET o'qish, POST yaratish, PUT yangilash, DELETE o'chir), sahifalash (pagination — ko'p ma'lumot bo'laklarga), rate limit (soatda N so'rov — cheklov), xato boshqarish (401 auth, 429 ko'p so'rov, qayta urinish). Bu 20-qism (FastAPI — server) ning mijoz tomoni va 26.3 (requests) ning kengaytmasi. API — zamonaviy dasturlar orasidagi ko'prik. Integratsiya — xizmatlarni birlashtirish.

Real vaziyat. Bir ilova Telegram, to'lov, ob-havo xizmatlarini birlashtirdi — barchasi API orqali. Har API: kalit (auth), sahifalash (ko'p ma'lumot), rate limit (cheklov), qayta urinish (xato). To'g'ri integratsiya bilan — barqaror, ishonchli. API integratsiya — zamonaviy ilovaning asosi (o'z hammasini qurmasdan tayyor xizmat). Xizmatlarni ulash — API bilan.

Bu darsda API integratsiyasini o'rganamiz.

Bu darsda:

  • API va autentifikatsiya
  • So'rov turlari (GET/POST/PUT/DELETE)
  • Sahifalash (pagination)
  • Rate limit (cheklov)
  • Xato boshqarish va qayta urinish
  • API kalit xavfsizligi
  • API hujjatlari
  • Amaliy: API integratsiya

ℹ Misollarda deterministik mock API (soxta — real API kalit va tarmoq talab qiladi) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. API va autentifikatsiya

Kim so'rayapti — kalit bilan:

python
import requests
headers = {"Authorization": "Bearer API_KALIT"}
response = requests.get("https://api.example.com/data", headers=headers)
# API kalit: kim so'rayapti (ruxsat, hisoblash)

API autentifikatsiya — kim so'rayaptini tasdiqlash: API kaliti (Authorization header — 25.10, 20.7), OAuth (murakkabroq — foydalanuvchi nomidan), token. Sabab: API kimga ruxsat, kim qancha so'rov (rate limit), pulli. headers={"Authorization": "Bearer KALIT"}. Bu 20.7 (auth — server tomoni) ning mijoz tomoni. Ko'p API kalit talab qiladi (ro'yxatdan o'tib olinadi). Autentifikatsiya — API'ga kirish.

2.2. So'rov turlari (GET/POST/PUT/DELETE)

CRUD — HTTP metodlari:

python
requests.get(url)                    # o'qish (Read)
requests.post(url, json=data)        # yaratish (Create)
requests.put(url, json=data)         # yangilash (Update)
requests.delete(url)                 # o'chirish (Delete)

So'rov turlari — HTTP metodlari (23.4 CRUD kabi): GET (o'qish — ma'lumot olish, 26.3), POST (yaratish — yangi ma'lumot yuborish, json=data), PUT/PATCH (yangilash), DELETE (o'chirish). Bu 20-qism (FastAPI — server bu metodlarni qabul qiladi) ning mijoz tomoni. RESTful API — metodlar ma'noli (GET /users — o'qi, POST /users — yarat). Metod — amal turi (o'qi/yarat/yangila/o'chir).

2.3. Sahifalash (pagination)

Ko'p ma'lumot — bo'laklarga:

python
# API bir marta 100 element beradi (hammasi emas)
response = requests.get(url, params={"page": 1, "per_page": 100})
data = response.json()
data["has_next"]     # keyingi sahifa bormi?
# barcha uchun: sikl (page += 1)

Sahifalash (pagination) — API ko'p ma'lumotni bo'laklarga (sahifalar) beradi (bir marta hammasi emas — server yuki, tezlik): params={"page": 2, "per_page": 100}. Javob: has_next (keyingi bormi), next_url, yoki total. Barcha ma'lumot uchun — sikl (while has_next: page += 1). Bu 24-qism (katta ma'lumot) va API asosiy naqshi. Ko'p ma'lumot — sahifalab ol (bir marta emas). Sahifalash — ko'p ma'lumot.

2.4. Rate limit (cheklov)

So'rov cheklovi:

python
# API: soatda 1000 so'rov (cheklov)
# javob header: X-RateLimit-Remaining: 50
if response.status_code == 429:      # ko'p so'rov
    time.sleep(60)                    # kutib qayta urin

Rate limit — API so'rov cheklovi (soatda/daqiqada N so'rov — server himoyasi): javob header (X-RateLimit-Remaining — qolgan), status 429 (Too Many Requests — cheklov oshdi). Yechim: kutish (time.sleep), cheklovni kuzatish (qolgan so'rov), sekin so'rov (26.6 rate limiting). Bu 26.6 (etika) ning API shakli — cheklovga rioya. Cheklovni buzish — vaqtincha bloklanish. Rate limit — API'ni hurmat qilish.

2.5. Xato boshqarish va qayta urinish

Ishonchli integratsiya:

python
def api_call_with_retry(url, max_tries=3):
    for i in range(max_tries):
        r = requests.get(url, timeout=10)
        if r.status_code == 200:
            return r.json()
        if r.status_code == 429:
            time.sleep(2 ** i)        # exponential backoff
    return None

Xato boshqarish + qayta urinish — API ishonchsiz (tarmoq, server, cheklov): qayta urinish (retry — vaqtincha xato o'tib ketishi mumkin), exponential backoff (2 ** i — har urinishda ko'proq kut: 1, 2, 4 soniya — serverga yumshoq), status tekshirish (200/429/500). Vaqtincha xato (429, 500) — qayta urin; doimiy (401, 404) — urinma. Bu ishonchli integratsiya (bir xato butun ishni to'xtatmasin). "Qayta urin, lekin aqlli (backoff)".

2.6. API kalit xavfsizligi

Kalit — maxfiy:

python
import os
api_key = os.environ["API_KEY"]      # muhit o'zgaruvchisi
# kodga yozMANG (git — 25.10)
# .env fayl (gitignore)

API kalit xavfsizligi (25.10 kabi) — kalit maxfiy (kim bilsa — sizning hisobingizdan, pul): kodga yozMANG (git'ga tushadi — o'g'rilanadi), muhit o'zgaruvchisi (os.environ), .env (gitignore — 19-qism). Kalit sizib ketsa — darrov bekor qil (revoke). Bu 25.10 (LLM API), 20.7 (auth) da ko'rdik — umumiy xavfsizlik. API kalit — parol kabi (maxfiy). Xavfsizlik — API integratsiyasida muhim.

2.7. API hujjatlari

API'ni tushunish:

API hujjati (docs): API'ni qanday ishlatish
   - endpointlar (yo'llar)
   - parametrlar
   - autentifikatsiya
   - javob formati
   - misollar
# har API o'z hujjatiga ega

API hujjatlari (docs) — API'ni qanday ishlatishni tavsiflaydi: endpointlar (yo'llar — /users), parametrlar (so'rov), autentifikatsiya (kalit), javob formati (JSON tuzilishi), rate limit, misollar. API bilan ishlash — hujjatni o'qish (har API har xil). Yaxshi hujjat — oson integratsiya. FastAPI avtomatik hujjat beradi (20.16 — OpenAPI). Hujjatsiz API — qiyin (taxmin). Integratsiya hujjatdan boshlanadi.

2.8. API integratsiya — xizmatlarni ulash

API integratsiya — zamonaviy ilovaning asosi: o'z hammasini qurmasdan tayyor xizmatlarni ulash (Telegram, to'lov, xarita, ob-havo, AI — 25.10). Muhim naqshlar: autentifikatsiya (kalit), sahifalash (ko'p ma'lumot), rate limit (cheklov), qayta urinish (ishonchlilik), xavfsizlik (kalit). Bu 20-qism (FastAPI — API yaratish) va 26.3 (requests) ni birlashtiradi — API mijozi. Zamonaviy dastur — ko'p API integratsiya (mikroservis, tashqi xizmat — 27.9). "O'zi qurmasdan ula" — API tejaydi (tayyor xizmat). Integratsiya — xizmatlar ekotizimi.

3. Tez ma'lumotnoma

python
import requests
import os
import time

# autentifikatsiya:
headers = {"Authorization": f"Bearer {os.environ['API_KEY']}"}

# so'rov turlari (CRUD):
requests.get(url, headers=headers)          # o'qish
requests.post(url, json=data, headers=headers)  # yaratish
requests.put(url, json=data, headers=headers)   # yangilash
requests.delete(url, headers=headers)       # o'chirish

# sahifalash:
r = requests.get(url, params={"page": 1, "per_page": 100})
while r.json()["has_next"]:
    page += 1; ...

# rate limit (429):
if r.status_code == 429:
    time.sleep(60)

# qayta urinish (backoff):
for i in range(3):
    r = requests.get(url, timeout=10)
    if r.status_code == 200: break
    time.sleep(2 ** i)   # 1, 2, 4 soniya

API integratsiya xulosasi

Auth (kalit/OAuth) · CRUD (GET/POST/PUT/DELETE) · sahifalash (page)
Rate limit (429 — kut) · qayta urinish (backoff) · kalit maxfiy
API hujjati (docs) · o'zi qurmasdan xizmat ula

4. Batafsil misollar

Misollarda deterministik mock API (soxta) bilan sinaladi. Namunalar integratsiya naqshini ko'rsatadi.

Misol 1 — Autentifikatsiya va so'rov turlari

python
"""mock API: autentifikatsiya (kalit); so'rov turlari (GET/POST/DELETE)."""


class MockAPI:
    def __init__(self, kalit: str) -> None:
        self.kalit = kalit
        self.malumot: dict = {1: "Python", 2: "Go"}

    def _auth(self, kalit: str) -> bool:
        return kalit == self.kalit

    def get(self, id: int, kalit: str) -> dict:
        if not self._auth(kalit):
            return {"status": 401, "xato": "Unauthorized"}
        return {"status": 200, "data": self.malumot.get(id)}

    def post(self, id: int, qiymat: str, kalit: str) -> dict:
        if not self._auth(kalit):
            return {"status": 401}
        self.malumot[id] = qiymat
        return {"status": 201, "data": qiymat}

    def delete(self, id: int, kalit: str) -> dict:
        if not self._auth(kalit):
            return {"status": 401}
        self.malumot.pop(id, None)
        return {"status": 204}


def main() -> None:
    api = MockAPI("secret123")

    print("=== 1. Auth'siz (401) ===")
    print(f"  {api.get(1, 'wrong')}")

    print("\n=== 2. GET (o'qish) ===")
    print(f"  {api.get(1, 'secret123')}")

    print("\n=== 3. POST (yaratish) ===")
    print(f"  {api.post(3, 'Rust', 'secret123')}")
    print(f"  qo'shilgan: {api.get(3, 'secret123')['data']}")

    print("\n=== 4. DELETE (o'chirish) ===")
    print(f"  status: {api.delete(1, 'secret123')['status']}")
    print(f"  o'chirilgan: {api.get(1, 'secret123')['data']}")
    print("  ⭐ auth (kalit) + CRUD (GET/POST/DELETE)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Auth'siz (401) ===
  {'status': 401, 'xato': 'Unauthorized'}

=== 2. GET (o'qish) ===
  {'status': 200, 'data': 'Python'}

=== 3. POST (yaratish) ===
  {'status': 201, 'data': 'Rust'}
  qo'shilgan: Rust

=== 4. DELETE (o'chirish) ===
  status: 204
  o'chirilgan: None
  ⭐ auth (kalit) + CRUD (GET/POST/DELETE)

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

Misol 2 — Sahifalash (pagination)

python
"""sahifalash: API ma'lumotni bo'laklarga; barcha sahifani sikl bilan olish."""


class MockPaginatedAPI:
    def __init__(self, kalit: str) -> None:
        self.kalit = kalit
        self.sahifalar = {1: ["a", "b"], 2: ["c", "d"], 3: ["e"]}

    def get(self, page: int, kalit: str) -> dict:
        if kalit != self.kalit:
            return {"status": 401}
        data = self.sahifalar.get(page, [])
        return {
            "status": 200,
            "data": data,
            "page": page,
            "has_next": page < len(self.sahifalar),
        }


def fetch_all(api: MockPaginatedAPI, kalit: str) -> list:
    natija = []
    page = 1
    while True:
        r = api.get(page, kalit)
        natija.extend(r["data"])
        if not r["has_next"]:
            break
        page += 1
    return natija


def main() -> None:
    api = MockPaginatedAPI("key")

    print("=== 1. Bir sahifa (page=1) ===")
    print(f"  {api.get(1, 'key')['data']}")

    print("\n=== 2. has_next (keyingi bormi) ===")
    print(f"  page 1 has_next: {api.get(1, 'key')['has_next']}")
    print(f"  page 3 has_next: {api.get(3, 'key')['has_next']}")

    print("\n=== 3. Barcha sahifa (sikl) ===")
    hammasi = fetch_all(api, "key")
    print(f"  jami: {hammasi}")

    print("\n=== 4. Nega sahifalash ===")
    print("  API bir marta hammasini bermaydi (server yuki)")
    print("  sikl bilan barcha sahifa")
    print("  ⭐ sahifalash — ko'p ma'lumot bo'laklarga (sikl)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Bir sahifa (page=1) ===
  ['a', 'b']

=== 2. has_next (keyingi bormi) ===
  page 1 has_next: True
  page 3 has_next: False

=== 3. Barcha sahifa (sikl) ===
  jami: ['a', 'b', 'c', 'd', 'e']

=== 4. Nega sahifalash ===
  API bir marta hammasini bermaydi (server yuki)
  sikl bilan barcha sahifa
  ⭐ sahifalash — ko'p ma'lumot bo'laklarga (sikl)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Rate limit va qayta urinish

python
"""rate limit (429); qayta urinish (retry + exponential backoff) — ishonchli integratsiya."""


def with_retry(func, max_tries: int = 3) -> dict:
    """Qayta urinish (vaqtincha xato o'tib ketishi mumkin)."""
    for urinish in range(max_tries):
        r = func()
        if r["status"] == 200:
            return {"natija": r, "urinishlar": urinish + 1}
        # real: time.sleep(2 ** urinish) — exponential backoff
    return {"natija": {"status": "failed"}, "urinishlar": max_tries}


def main() -> None:
    print("=== 1. Rate limit (429 — cheklov) ===")
    print("  429: Too Many Requests")
    print("  yechim: kutib qayta urin (time.sleep)")

    print("\n=== 2. Vaqtincha xato (2-urinishda muvaffaqiyat) ===")
    urinishlar = [0]

    def flaky():
        urinishlar[0] += 1
        return {"status": 200} if urinishlar[0] >= 2 else {"status": 500}

    natija = with_retry(flaky)
    print(f"  status: {natija['natija']['status']}, urinishlar: {natija['urinishlar']}")

    print("\n=== 3. Exponential backoff ===")
    for i in range(3):
        print(f"  urinish {i + 1}: {2 ** i} soniya kut")

    print("\n=== 4. Doimiy xato (401 — urinma) ===")
    print("  vaqtincha (429, 500): qayta urin")
    print("  doimiy (401, 404): urinma (kalit/yo'l xato)")
    print("  ⭐ qayta urinish — backoff (ishonchli integratsiya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Rate limit (429 — cheklov) ===
  429: Too Many Requests
  yechim: kutib qayta urin (time.sleep)

=== 2. Vaqtincha xato (2-urinishda muvaffaqiyat) ===
  status: 200, urinishlar: 2

=== 3. Exponential backoff ===
  urinish 1: 1 soniya kut
  urinish 2: 2 soniya kut
  urinish 3: 4 soniya kut

=== 4. Doimiy xato (401 — urinma) ===
  vaqtincha (429, 500): qayta urin
  doimiy (401, 404): urinma (kalit/yo'l xato)
  ⭐ qayta urinish — backoff (ishonchli integratsiya)

Nima ko'rsatdi: 2.4, 2.5-bo'limlar.

Misol 4 — Amaliy: to'liq API integratsiya

Real integratsiya: auth, sahifalash, xato boshqarish — to'liq mijoz. Bu — API integratsiyasining namunasi (mock bilan).

python
"""to'liq API mijoz (mock): auth, barcha sahifa, xato boshqarish, ma'lumot qayta ishlash."""


class APIClient:
    def __init__(self, kalit: str) -> None:
        self.kalit = kalit
        self._data = {
            1: [{"nom": "Python", "narx": 100}, {"nom": "Go", "narx": 120}],
            2: [{"nom": "Rust", "narx": 150}],
        }

    def _get(self, page: int) -> dict:
        return {
            "status": 200,
            "data": self._data.get(page, []),
            "has_next": page < len(self._data),
        }

    def barcha_kurslar(self) -> list:
        natija = []
        page = 1
        while True:
            r = self._get(page)
            if r["status"] != 200:
                break
            natija.extend(r["data"])
            if not r["has_next"]:
                break
            page += 1
        return natija


def main() -> None:
    client = APIClient("api_key_123")

    print("=== 1. Barcha kurslarni olish (sahifalar) ===")
    kurslar = client.barcha_kurslar()
    print(f"  jami kurslar: {len(kurslar)}")

    print("\n=== 2. Ma'lumot qayta ishlash ===")
    nomlar = [k["nom"] for k in kurslar]
    print(f"  nomlar: {nomlar}")

    print("\n=== 3. Statistika ===")
    narxlar = [k["narx"] for k in kurslar]
    print(f"  jami narx: {sum(narxlar)}, o'rtacha: {round(sum(narxlar) / len(narxlar), 1)}")

    print("\n=== 4. Integratsiya oqimi ===")
    print("  auth → sahifalar (sikl) → ma'lumot → qayta ishlash")
    print("  o'z hammasini qurmasdan — tayyor xizmat")
    print("  ⭐ API integratsiya — auth + sahifalash + qayta ishlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Barcha kurslarni olish (sahifalar) ===
  jami kurslar: 3

=== 2. Ma'lumot qayta ishlash ===
  nomlar: ['Python', 'Go', 'Rust']

=== 3. Statistika ===
  jami narx: 370, o'rtacha: 123.3

=== 4. Integratsiya oqimi ===
  auth → sahifalar (sikl) → ma'lumot → qayta ishlash
  o'z hammasini qurmasdan — tayyor xizmat
  ⭐ API integratsiya — auth + sahifalash + qayta ishlash

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

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

Noto'g'ri fikr To'g'risi
"API auth keraksiz" Kalit (kim, cheklov)
"GET har amalga" POST/PUT/DELETE (amal)
"API hammani beradi" Sahifalash (bo'laklarga)
"Rate limit yo'q" Cheklov (429)
"Bir so'rov yetarli" Qayta urinish (ishonchli)
"Kalit kodga" Maxfiy (muhit)
"Hujjatsiz ham" Hujjat o'qi (har API)
"API = scraping" API afzal (rasmiy)

6. Keng tarqalgan xatolar va yechimlari

1. Auth unutish (401)

python
requests.get(url)   # 401 (kalit yo'q)               # ⚠️
requests.get(url, headers={"Authorization": "..."})   # ✅

2. Sahifalash unutish (faqat 1-sahifa)

python
requests.get(url).json()   # faqat 100 element        # ⚠️
# barcha uchun sikl (page += 1)                         # ✅

3. Rate limit'ni e'tiborsiz (429)

python
for u in urls: requests.get(u)   # 429                # ⚠️
if r.status_code == 429: time.sleep(60)                # ✅

4. Qayta urinishsiz (bir xato — to'xta)

python
r = requests.get(url)   # tarmoq xato — crash         # ⚠️
# retry + backoff                                       # ✅

5. Kalit kodga

python
key = "sk-abc123"                                     # ⚠️ (git)
key = os.environ["API_KEY"]                            # ✅

6. Doimiy xatoda qayta urinish

python
# 401/404 da qayta urin (behuda)                       # ⚠️
# vaqtincha (429/500) da urin, doimiyda yo'q            # ✅

7. Hujjatsiz taxmin

python
# API'ni taxmin qilib ishlatish                        # ⚠️
# hujjat o'qi (endpoint, param, format)                 # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 26.3-dars (o'tilgan): requests — API asosi
  • 26.6-dars (o'tilgan): Rate limiting — API cheklov
  • 20-qism (o'tilgan): FastAPI — API yaratish
  • 25.10-dars (o'tilgan): LLM API — integratsiya
  • 26.8-dars: Telegram bot — API

8. Eng yaxshi amaliyotlar

  1. Auth (kalit — Authorization).

  2. To'g'ri metod (GET/POST/PUT/DELETE).

  3. Sahifalash (barcha uchun sikl).

  4. Rate limit (429 — kut).

  5. Qayta urinish (backoff — ishonchli).

  6. Kalit maxfiy (muhit o'zgaruvchisi).

  7. Hujjat o'qi (har API).

  8. API afzal (scraping emas).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # API autentifikatsiya?
2.  # API kalit nima?
3.  # GET nima?
4.  # POST nima?
5.  # PUT/DELETE nima?
6.  # sahifalash nima?
7.  # has_next nima?
8.  # rate limit nima?
9.  # 429 nima?
10. # qayta urinish nima?
11. # backoff nima?
12. # kalit qayerda?
Javoblar
  1. Kim so'rayaptini tasdiqlash
  2. API'ga kirish (ruxsat, hisoblash)
  3. O'qish (Read)
  4. Yaratish (Create)
  5. Yangilash / O'chirish
  6. Ko'p ma'lumot bo'laklarga
  7. Keyingi sahifa bormi
  8. So'rov cheklovi
  9. Too Many Requests (cheklov)
  10. Xatoda qayta urinish
  11. Har urinishda ko'proq kutish
  12. Muhit o'zgaruvchisi (kodga emas)

Vazifa 2: Xatolarni tuzating

python
1.  requests.get(url)   # 401                  # Authorization

2.  requests.get(url).json()   # 1-sahifa      # sikl

3.  for u in urls: get(u)   # 429              # sleep

4.  key = "sk-abc123"                           # os.environ

5.  # 401 da qayta urin                         # doimiy — yo'q
Javoblar
python
1.  requests.get(url, headers={"Authorization": "..."})

2.  # barcha sahifa (sikl)

3.  if r.status_code==429: time.sleep(60)

4.  key = os.environ["API_KEY"]

5.  # vaqtincha (429/500) da urin

Vazifa 3: Auth/CRUD

API:

  1. Auth
  2. GET
  3. POST
  4. DELETE

Vazifa 4: Sahifalash

Ko'p ma'lumot:

  1. Bir sahifa
  2. has_next
  3. Sikl
  4. Barcha

Vazifa 5: Rate limit/retry

Ishonchli:

  1. 429
  2. Qayta urinish
  3. Backoff
  4. Vaqtincha vs doimiy

Vazifa 6: Integratsiya

To'liq:

  1. Auth
  2. Sahifalar
  3. Xato
  4. Qayta ishlash

Vazifa 7: O'ylash

API integratsiya zamonaviy ilovaning asosi — o'z hammasini qurmasdan tayyor xizmatlar (Telegram, to'lov, AI) ni ulash. Nima uchun "o'zi qurmasdan API ulash" foydali, va nega bu "qayta ishlatish va ixtisoslashish" tamoyilini ko'rsatadi — har bir xizmatni o'zi qurish o'rniga tayyor API ishlatish nega samaraliroq?

Javob

Qisqa javob: "O'zi qurmasdan API ulash" foydali, chunki: har xizmat (to'lov, xarita, AI, SMS) murakkab (yillar mehnat, mutaxassislik, infratuzilma) — o'zi qurish behuda (allaqachon bor). Tayyor API — bir necha so'rov (integratsiya). Bu "qayta ishlatish va ixtisoslashish": har kompaniya o'z kuchli tomoniga e'tibor beradi (ilova mantigi), qolganini tayyor xizmatdan oladi (to'lov — Stripe, xarita — Google, AI — OpenAI). Ixtisoslashish: to'lov kompaniyasi to'lovni eng yaxshi qiladi (o'ninchi daraja), siz uni ulaysiz (o'zi qurmasdan). Har xizmatni o'zi qurish — g'ildirakni qayta ixtiro qilish (vaqt, xato, sifat past). API ekosistemasi — zamonaviy dasturlash (mikroservis, bulut — 27.9, 28-qism). "O'zi qurma, ula" — samarali (vaqt, sifat, e'tibor).

1. Xizmat murakkab

To'lov, xarita, AI — yillar mehnat, mutaxassislik, infratuzilma. O'zi qurish behuda (bor, murakkab).

2. API — tayyor xizmat

Bir necha so'rov (integratsiya) → tayyor kuchli xizmat. Vaqt, xato, sifat — tejaladi.

3. Qayta ishlatish va ixtisoslashish

O'zi qurish API ulash
G'ildirakni qayta ixtiro Tayyor (ixtisoslashgan)
Vaqt, xato Tez, ishonchli
Sifat past Mutaxassis sifati
E'tibor bo'linadi O'z kuchiga e'tibor

4. Ixtisoslashish

Har kompaniya o'z kuchli tomoniga (Stripe — to'lov, Google — xarita, OpenAI — AI). Siz — o'z ilova mantigiga. Qolgani — API.

5. Muhandislik saboqlari

  1. Xizmat murakkab (o'zi qurish behuda)
  2. API — tayyor (integratsiya)
  3. Qayta ishlatish + ixtisoslashish
  4. O'z kuchiga e'tibor (qolgani API)

6. Xulosa

  1. API — o'zi qurmasdan xizmat
  2. Xizmat murakkab (tayyor afzal)
  3. Ixtisoslashish (o'z kuchi)
  4. G'ildirakni qayta ixtiro qilma

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda API integratsiyasini o'rgandik.

Eng muhim uch fikr:

  1. Autentifikatsiya va so'rov turlari. API autentifikatsiya — kim so'rayaptini tasdiqlash: API kaliti (Authorization header), OAuth, token (API kimga ruxsat, kim qancha so'rov — rate limit, pulli). So'rov turlari (HTTP metodlari — CRUD, 23.4): GET (o'qish), POST (yaratish — json=data), PUT/PATCH (yangilash), DELETE (o'chirish). Bu 20-qism (FastAPI — server) ning mijoz tomoni va 26.3 (requests) kengaytmasi. RESTful API — metodlar ma'noli.

  2. Sahifalash, rate limit, qayta urinish. Sahifalash (pagination) — API ko'p ma'lumotni bo'laklarga (sahifalar) beradi (server yuki): params={"page": 2}, has_next; barcha uchun sikl (while has_next). Rate limit — API so'rov cheklovi (429 — Too Many Requests; header X-RateLimit-Remaining) — kutish (time.sleep). Xato boshqarish + qayta urinish — API ishonchsiz: retry + exponential backoff (2 ** i — 1, 2, 4 soniya — serverga yumshoq); vaqtincha xato (429, 500) qayta urin, doimiy (401, 404) urinma. Ishonchli integratsiya.

  3. Xavfsizlik va xizmatlarni ulash. API kalit maxfiy (25.10 kabi) — kodga yozMANG (git — o'g'rilanadi), muhit o'zgaruvchisi (os.environ), .env. API hujjatlari (docs) — endpoint, parametr, auth, javob format (har API o'qi). API integratsiya — zamonaviy ilovaning asosi: o'z hammasini qurmasdan tayyor xizmatlar (Telegram, to'lov, xarita, AI) ni ulash. "Qayta ishlatish va ixtisoslashish" — har kompaniya o'z kuchli tomoniga e'tibor (Stripe — to'lov, OpenAI — AI), qolgani tayyor API. Har xizmatni o'zi qurish — g'ildirakni qayta ixtiro (vaqt, xato, sifat past). "O'zi qurma, ula" — samarali. API — xizmatlar ekosistemasi (mikroservis — 27.9, bulut — 28-qism).

Keyingi darsda Telegram bot ni o'rganamiz: Telegram API bilan bot yaratish — xabar qabul qilish, javob berish, buyruqlar — avtomatlashtirishning amaliy va mashhur sohasi.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
26.7-dars: API integratsiyasi — IlmHamroh