30.14-dars: gRPC va Protocol Buffers

30-QISM — PYTHON VA BOSHQA TILLAR · 14-dars

1. Kirish va motivatsiya

Go 30.13-bob va Python alohida xizmatlar sifatida tarmoq orqali gaplashadi. Lekin qanday gaplashadi? REST/JSON (23-qism) bir yo'l, lekin u sekin (JSON matn — parse qilish og'ir) va shartnomasiz (API o'zgarsa — bilmaysiz). Xizmatlararo yuqori unumdor aloqa uchun gRPC va Protocol Buffers bor. Protocol Buffers (protobuf) — binar ma'lumot formati (JSON'dan kichik va tez); .proto faylda ma'lumot va xizmat sxemasi aniqlanadi (shartnoma). gRPC esa shu sxema asosida turli tillar (Python, Go, Java...) uchun kod avtomatik yaratadi — Python stub.Hisobla(...) chaqiradi, u tarmoq orqali Go xizmatga boradi, xuddi mahalliy funksiya kabi. gRPC — polyglot mikroservislarning zamonaviy aloqa standarti. Google, Netflix, ko'p yirik tizim ishlatadi.

gRPC — xizmatlararo yuqori unumdor aloqa tizimi (Google): Protocol Buffers (protobuf — binar ma'lumot formati, JSON'dan kichik/tez), .proto (sxema — ma'lumot va xizmat ta'rifi, shartnoma), kod generatsiya (.protodan turli til kodi — Python, Go), RPC (Remote Procedure Call — masofaviy funksiya chaqiruv, mahalliy kabi), HTTP/2 (samarali transport). Foydalanish: mikroservis aloqasi (25-qism), Python↔Go 30.13-bob. Bu 30.13 (Go — alohida xizmat), 23-qism (REST — muqobil) bilan bog'liq. gRPC — tez xizmat aloqa. protobuf binar. Kod generatsiya.

Real vaziyat. Python ML xizmati va Go bildirishnoma xizmati 30.13-bob gaplashishi kerak edi. REST/JSON sinab ko'rildi — sekin (JSON parse — soniyaga million so'rovda bottleneck 29.2). gRPC qo'llandi: hisob.proto faylda xizmat ta'riflandi (Hisobla(So'rov) → Javob), gRPC Python va Go uchun kod yaratdi (avtomatik). Python stub.Hisobla(so'rov) — Go xizmatga bordi (protobuf binar — JSON'dan 5x tez, kichik). Ikki xizmat (turli til) tez, ishonchli gaplashdi (shartnoma — .proto). gRPC — polyglot tez aloqa (binar, sxema).

Bu darsda gRPC va Protocol Buffers ni o'rganamiz.

Bu darsda:

• gRPC va protobuf nima
• .proto — sxema (shartnoma)
• Kod generatsiya (turli til)
• Binar format (JSON farqi)
• RPC — masofaviy chaqiruv
• gRPC amaliyoti
• gRPC vs REST
• Amaliy: gRPC oqimi modeli

ℹ gRPC alohida kutubxona/vositalar talab qiladi; misollar gRPC/protobuf mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. gRPC va protobuf nima

Tez xizmat aloqasi:

// hisob.proto — sxema (shartnoma)
syntax = "proto3";

message Sorov {              // ma'lumot strukturasi
    int32 a = 1;
    int32 b = 2;
}
message Javob {
    int32 natija = 1;
}
service Hisob {             // xizmat
    rpc Qoshish(Sorov) returns (Javob);   // masofaviy funksiya
}

gRPC — Google'ning xizmatlararo yuqori unumdor aloqa tizimi; Protocol Buffers (protobuf) — uning binar ma'lumot formati va sxema tili. Sabab: mikroservislar (25-qism — Python, Go) tez, ishonchli gaplashishi kerak; REST/JSON (23-qism) sekin (matn parse) va shartnomasiz; gRPC tez (protobuf binar) va shartnomali (.proto sxema). Ish oqimi: .proto (sxema ta'rifla) → gRPC kod yaratadi (turli til) → xizmatlar shu kod bilan gaplashadi. gRPC — xizmat aloqa tizimi. protobuf — binar format + sxema. Yuqori unumdor.

2.2. .proto — sxema (shartnoma)

Ma'lumot va xizmat ta'rifi:

message Foydalanuvchi {      // ma'lumot (maydonlar + raqamlar)
    string ism = 1;          // maydon raqami (1) — binar kodda ishlatiladi
    int32 yosh = 2;
    repeated string roller = 3;   // ro'yxat
}

service FoydalanuvchiXizmat {
    rpc Ol(IdSorov) returns (Foydalanuvchi);
    rpc Yarat(Foydalanuvchi) returns (Javob);
}

.proto — gRPC'ning sxema fayli (shartnoma): message (ma'lumot strukturasi — maydonlar, har birida raqam — ism = 1, binar kodda ishlatiladi), service (xizmat — rpc metodlar), rpc (masofaviy funksiya — Ol(So'rov) returns (Javob)). Sabab: xizmatlar kelishilgan shartnoma kerak (nima yuboriladi, nima qaytadi — 28.14 shartnoma); .proto bu shartnoma (yagona manba — Python, Go undan kod oladi). Maydon raqami (= 1) muhim (binar kodda nom emas, raqam — kichik, tez, versiya mos). .proto — sxema (shartnoma). message + service + rpc. Yagona manba.

2.3. Kod generatsiya (turli til)

Sxemadan avtomatik kod:

hisob.proto (sxema)
      │
      │ protoc (gRPC kompilyator)
      ├──────────────┬──────────────┐
      v              v              v
hisob_pb2.py     hisob.pb.go    Hisob.java
(Python kod)     (Go kod)       (Java kod)

→ har til bir xil sxemadan (mos, avtomatik)

Kod generatsiya — gRPC'ning kuchi: .proto sxemasidan turli til uchun kod avtomatik yaratadi (protoc — protobuf kompilyator). Sabab: har til qo'lda yozsa — xato (mos kelmaslik — 30.4 qo'lda tur), zerikarli; gRPC bir sxemadan hammasini yaratadi (Python _pb2.py, Go .pb.go, Java) — mos (yagona manbadan). Natija: Python va Go bir xil ma'lumot strukturasini (message) ishlatadi, xizmat interfeysi (stub) tayyor. Bu 30.4 (cffi — deklaratsiyadan avtomatik) g'oyasi (sxemadan avtomatik). Kod generatsiya — .proto → turli til (avtomatik). protoc. Mos, yagona manba.

2.4. Binar format (JSON farqi)

Kichik va tez:

JSON (matn):
   {"ism": "Ali", "yosh": 25}   → 27 bayt (matn, nom takrorlanadi)

Protobuf (binar):
   [maydon 1: "Ali"][maydon 2: 25]   → ~10 bayt (raqam, binar)

→ protobuf kichikroq (~3x), tezroq parse (binar)

Binar format (JSON farqi) — protobuf'ning tezlik manbai: JSON matn ({"ism": "Ali"} — nom takrorlanadi, matn parse — sekin, katta), protobuf binar (maydon raqami + qiymat — nom yo'q, kichik, tez parse). Sabab: JSON o'qiladi (inson), lekin sekin/katta (matn, nomlar); protobuf samarali (binar — mashina uchun, kichik ~3x, tez ~5x parse). Sabab maydon raqami (2.2 — = 1): binar kodda nom o'rniga raqam (kichik). Cheklov: protobuf o'qilmaydi (binar — inson ko'rmaydi, vosita kerak). Foydalanish: yuqori unumdor (million so'rov — 29.2). Binar format — kichik, tez (JSON'dan). Raqam (nom emas). O'qilmaydi.

2.5. RPC — masofaviy chaqiruv

Mahalliy funksiya kabi:

# Python mijoz (gRPC stub)
import hisob_pb2, hisob_pb2_grpc

stub = hisob_pb2_grpc.HisobStub(kanal)
sorov = hisob_pb2.Sorov(a=3, b=5)
javob = stub.Qoshish(sorov)   # masofaviy chaqiruv (Go xizmatga!)
print(javob.natija)           # 8 (tarmoq orqali, lekin oddiy funksiya kabi)

RPC (Remote Procedure Call — masofaviy protsedura chaqiruv) — gRPC'ning asosiy g'oyasi: masofadagi (boshqa xizmat/til) funksiyani mahalliy funksiya kabi chaqirish (stub.Qoshish(so'rov) — lekin Go xizmatga boradi). Sabab: tarmoq aloqasi murakkab (so'rov qurish, yuborish, javob parse — 23-qism); RPC buni yashiradi (stub — mahalliy obyekt, chaqiruv tarmoqga o'giradi). Python stub.Qoshish(...) — gRPC protobuf'ga o'giradi, HTTP/2 orqali Go'ga yuboradi, javobni qaytaradi (oddiy funksiya kabi). Bu abstraksiya (tarmoq yashirin — mahalliy kabi). RPC — masofaviy funksiya (mahalliy kabi). stub. Tarmoq yashirin.

2.6. gRPC amaliyoti

gRPC amaliyotlari: .proto (sxema — yagona manba, shartnoma); protoc (kod generatsiya — turli til); stub (mijoz — stub.Metod, mahalliy kabi); server (xizmat — .proto service amalga oshirish); HTTP/2 (samarali transport — bir ulanish ko'p so'rov); streaming (gRPC oqim — ko'p javob, real vaqt); versiya (maydon raqami o'zgartirmaslik — moslik); xato (gRPC status kodlar). Tuzoqlar: maydon raqami o'zgartirish (eski mijoz buziladi — moslik), .proto sinxronsizlik (xizmatlar turli sxema), o'qilmaslik (binar — debug qiyin, vosita kerak). Amaliyot — .proto, protoc, stub, moslik. gRPC — tez, shartnomali aloqa.

2.7. gRPC vs REST

gRPC vs REST: REST/JSON (23-qism — JSON matn, o'qiladi, brauzer/ommaviy API'ga mos, lekin sekinroq — parse, shartnomasiz), gRPC/protobuf (binar — tez, .proto shartnoma majburiy, kod avtomatik, lekin o'qilmaydi — ichki xizmat aloqasiga mos). Tanlov: ommaviy API/brauzer (REST — o'qiladi, keng qo'llab-quvvatlash), ichki xizmat aloqasi (gRPC — tez, shartnomali, polyglot — Python↔Go 30.13). Sabab: REST oddiy, universal (brauzer ham); gRPC tez, qat'iy (ichki — yuqori unumdor). Ko'p tizim ikkalasini (tashqi REST, ichki gRPC). gRPC vs REST — binar/tez/shartnomali vs matn/o'qiladi/universal. Ichki vs ommaviy. Maqsadga qarab.

2.8. gRPC — polyglot xizmatlar aloqa ko'prigi

gRPC asosiy g'oyasi — polyglot xizmatlar aloqa ko'prigi: turli tildagi (Python, Go — 30.13) xizmatlar tez (protobuf binar) va ishonchli (.proto shartnoma) gaplashishi; sxemadan kod avtomatik (mos — har til bir manbadan). Bu 30.13 (Python + Go birga) ni amaliy qiladi (ular qanday gaplashadi — gRPC), 25-qism (mikroservis — alohida xizmatlar aloqasi) ning yuqori unumdor varianti. gRPC uch narsani beradi: tezlik (binar — 29.2 bottleneck yechim), shartnoma (.proto — 28.14 yagona haqiqat manbai, xizmatlar kelishadi), polyglot (kod generatsiya — til erkin). Google, Netflix ichki aloqada gRPC. Bu 30.16 (polyglot arxitektura) ning aloqa qatlami. gRPC — tez, shartnomali, polyglot aloqa. .proto sxema. Xizmatlar ko'prigi.

3. Tez ma'lumotnoma

// .PROTO — sxema (shartnoma)
syntax = "proto3";

message Sorov { int32 a = 1; int32 b = 2; }   // maydon raqami (1,2)
message Javob { int32 natija = 1; }

service Hisob {
    rpc Qoshish(Sorov) returns (Javob);        // masofaviy funksiya
}

# KOD GENERATSIYA (protoc):
#   hisob.proto → hisob_pb2.py (Python) + hisob.pb.go (Go)

# PYTHON MIJOZ (stub — masofaviy chaqiruv):
stub = hisob_pb2_grpc.HisobStub(kanal)
javob = stub.Qoshish(hisob_pb2.Sorov(a=3, b=5))   # Go xizmatga!
print(javob.natija)   # 8 (mahalliy funksiya kabi)

BINAR FORMAT (JSON farqi):
   JSON: {"ism":"Ali","yosh":25} — matn, ~27 bayt (sekin)
   protobuf: [1:"Ali"][2:25] — binar, ~10 bayt (tez, kichik)

gRPC vs REST:
   REST/JSON — matn, o'qiladi, ommaviy API (sekinroq)
   gRPC/protobuf — binar, tez, ichki xizmat (o'qilmaydi)

QOIDA: .proto (shartnoma) · protoc (kod) · ichki → gRPC, ommaviy → REST

gRPC xulosasi

gRPC — yuqori unumdor xizmat aloqasi (Google) + protobuf binar
.proto — sxema (message + service + rpc), yagona shartnoma
Kod generatsiya — .proto → turli til (Python, Go — mos)
Binar format — JSON'dan kichik/tez (raqam, nom emas)
RPC — masofaviy funksiya (mahalliy kabi) · ichki aloqa (REST — ommaviy)

4. Batafsil misollar

gRPC alohida kutubxona/vositalar talab qiladi; misollar gRPC/protobuf mantiqini (deterministik) modellashtiradi.

Misol 1 — .proto sxema (message + service)

"""'.proto' sxema: message va service ta'rifi (model)."""


def message(nom: str, maydonlar: list) -> dict:
    return {"nom": nom, "maydonlar": maydonlar}   # (tur, nom, raqam)


def main() -> None:
    sorov = message("Sorov", [("int32", "a", 1), ("int32", "b", 2)])
    javob = message("Javob", [("int32", "natija", 1)])

    print("=== 1. Sorov message ===")
    for tur, nom, raqam in sorov["maydonlar"]:
        print(f"  {tur} {nom} = {raqam}")

    print("\n=== 2. Javob message ===")
    for tur, nom, raqam in javob["maydonlar"]:
        print(f"  {tur} {nom} = {raqam}")

    print("\n=== 3. Service ===")
    print("  rpc Qoshish(Sorov) returns (Javob)")

    print("\n=== 4. Maydon raqami ===")
    print("  = 1, = 2 (binar kodda ishlatiladi, nom emas)")
    print("  ⭐ .proto — sxema (shartnoma, yagona manba)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Sorov message ===
  int32 a = 1
  int32 b = 2

=== 2. Javob message ===
  int32 natija = 1

=== 3. Service ===
  rpc Qoshish(Sorov) returns (Javob)

=== 4. Maydon raqami ===
  = 1, = 2 (binar kodda ishlatiladi, nom emas)
  ⭐ .proto — sxema (shartnoma, yagona manba)

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

Misol 2 — Kod generatsiya (turli til)

"""Kod generatsiya: bir .proto → turli til (model)."""


def protoc_generatsiya(proto: str) -> dict:
    asos = proto.replace(".proto", "")
    return {
        "proto": proto,
        "python": f"{asos}_pb2.py",
        "go": f"{asos}.pb.go",
        "java": f"{asos.capitalize()}.java",
    }


def main() -> None:
    gen = protoc_generatsiya("hisob.proto")

    print("=== 1. Manba ===")
    print(f"  {gen['proto']} (sxema)")

    print("\n=== 2. protoc yaratadi ===")
    print(f"  Python: {gen['python']}")
    print(f"  Go: {gen['go']}")
    print(f"  Java: {gen['java']}")

    print("\n=== 3. Mos ===")
    print("  har til bir sxemadan (yagona manba)")

    print("\n=== 4. Qo'lda emas ===")
    print("  avtomatik (mos kelmaslik xavfi yo'q)")
    print("  ⭐ Kod generatsiya — .proto → turli til (avtomatik)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Manba ===
  hisob.proto (sxema)

=== 2. protoc yaratadi ===
  Python: hisob_pb2.py
  Go: hisob.pb.go
  Java: Hisob.java

=== 3. Mos ===
  har til bir sxemadan (yagona manba)

=== 4. Qo'lda emas ===
  avtomatik (mos kelmaslik xavfi yo'q)
  ⭐ Kod generatsiya — .proto → turli til (avtomatik)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Binar vs JSON (hajm)

"""Binar vs JSON: hajm taqqoslash (model)."""


def json_hajm(maydonlar: dict) -> int:
    # JSON: {"nom":qiymat,...} — nom + qiymat + tinish belgilar
    import json
    return len(json.dumps(maydonlar))


def protobuf_hajm(maydonlar: dict) -> int:
    # protobuf: raqam + qiymat (nom yo'q, taxminan)
    return sum(2 + len(str(v)) for v in maydonlar.values())


def main() -> None:
    data = {"ism": "Ali", "yosh": 25, "shahar": "Toshkent"}

    print("=== 1. Ma'lumot ===")
    print(f"  {data}")

    print("\n=== 2. JSON (matn) ===")
    j = json_hajm(data)
    print(f"  hajm: {j} bayt (nom takrorlanadi)")

    print("\n=== 3. Protobuf (binar) ===")
    p = protobuf_hajm(data)
    print(f"  hajm: ~{p} bayt (raqam, nom yo'q)")

    print("\n=== 4. Farq ===")
    print(f"  protobuf ~{j // p}x kichikroq (binar)")
    print("  ⭐ Binar — kichik, tez (JSON'dan)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ma'lumot ===
  {'ism': 'Ali', 'yosh': 25, 'shahar': 'Toshkent'}

=== 2. JSON (matn) ===
  hajm: 48 bayt (nom takrorlanadi)

=== 3. Protobuf (binar) ===
  hajm: ~19 bayt (raqam, nom yo'q)

=== 4. Farq ===
  protobuf ~2x kichikroq (binar)
  ⭐ Binar — kichik, tez (JSON'dan)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — gRPC vs REST (tanlov)

"""gRPC vs REST: qaysi qachon (tanlov modeli)."""


def tanlov(vaziyat: str) -> str:
    if "ichki" in vaziyat or "xizmat" in vaziyat or "yuqori unumdor" in vaziyat:
        return "gRPC (binar, tez, shartnoma)"
    else:  # ommaviy, brauzer
        return "REST (JSON, o'qiladi, universal)"


def main() -> None:
    print("=== 1. Xususiyatlar ===")
    print("  REST: JSON matn, o'qiladi, ommaviy")
    print("  gRPC: binar, tez, ichki xizmat")

    print("\n=== 2. Ichki xizmat aloqasi ===")
    print(f"  {tanlov('ichki xizmat aloqasi')}")

    print("\n=== 3. Ommaviy API (brauzer) ===")
    print(f"  {tanlov('ommaviy brauzer API')}")

    print("\n=== 4. Ko'p tizim ikkalasi ===")
    print("  tashqi REST + ichki gRPC")
    print("  ⭐ gRPC vs REST — ichki/tez vs ommaviy/o'qiladi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xususiyatlar ===
  REST: JSON matn, o'qiladi, ommaviy
  gRPC: binar, tez, ichki xizmat

=== 2. Ichki xizmat aloqasi ===
  gRPC (binar, tez, shartnoma)

=== 3. Ommaviy API (brauzer) ===
  REST (JSON, o'qiladi, universal)

=== 4. Ko'p tizim ikkalasi ===
  tashqi REST + ichki gRPC
  ⭐ gRPC vs REST — ichki/tez vs ommaviy/o'qiladi

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Maydon raqamini o'zgartirish

string ism = 1;  →  string ism = 5;   // eski mijoz buziladi  // ⚠️
// raqam o'zgartirmasdan (moslik)                              // ✅

2. .proto sinxronsizligi

# xizmatlar turli .proto versiya (mos kelmaslik)              # ⚠️
# .proto yagona manba (barcha xizmat bir versiya)              # ✅

3. gRPC'ni brauzerga to'g'ridan

# brauzer to'g'ridan gRPC (cheklangan qo'llab-quvvatlash)     # ⚠️
# brauzer → REST/gRPC-Web, ichki → gRPC                        # ✅

4. protobuf'ni qo'lda o'qishga urinish

# binar protobuf'ni matn kabi o'qish (o'qilmaydi)             # ⚠️
# vosita (grpcurl, protobuf decode) — debug                    # ✅

5. Ommaviy API'ga gRPC

# ochiq/uchinchi tomon API gRPC (o'qilmaydi, murakkab)        # ⚠️
# ommaviy → REST (universal), ichki → gRPC                     # ✅

6. Sxemasiz JSON (gRPC o'rniga)

# yuqori yuk ichki aloqa JSON (sekin, shartnomasiz)           # ⚠️
# gRPC (binar, .proto shartnoma)                               # ✅

7. Kod generatsiyani o'tkazib yuborish

# .proto o'zgardi, protoc qayta ishlatilmadi (eski kod)       # ⚠️
# .proto o'zgarsa → protoc qayta (yangi kod)                   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.13-dars (o'tilgan): Go — Python bilan (gRPC aloqa)
• 30.16-dars: Polyglot arxitektura — aloqa qatlami
• 25-qism (o'tilgan): Mikroservis — xizmat aloqasi
• 23-qism (o'tilgan): REST/JSON — muqobil
• 28.14-dars (o'tilgan): Shartnoma — yagona manba

8. Eng yaxshi amaliyotlar

1. .proto — yagona shartnoma (barcha xizmat).

2. protoc — kod generatsiya (turli til, mos).

3. Maydon raqamini o'zgartirmaslik (moslik).

4. Ichki aloqa → gRPC (tez, shartnoma).

5. Ommaviy/brauzer → REST (universal).

6. HTTP/2 (bir ulanish ko'p so'rov).

7. .proto o'zgarsa → protoc qayta.

8. Debug uchun vosita (binar — grpcurl).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # gRPC nima?
2.  # protobuf nima?
3.  # .proto nima?
4.  # message nima?
5.  # maydon raqami nega?
6.  # kod generatsiya nima?
7.  # protoc nima?
8.  # binar nega tez?
9.  # RPC nima?
10. # stub nima?
11. # gRPC vs REST?
12. # gRPC qachon?

Vazifa 2: Xatolarni tuzating

1.  string ism = 1; → = 5;   # raqam o'zgardi

2.  # xizmatlar turli .proto

3.  # brauzer to'g'ridan gRPC

4.  # ommaviy API gRPC

5.  # .proto o'zgardi, protoc yo'q

1.  raqam o'zgartirmasdan (moslik)

2.  .proto yagona manba

3.  ommaviy → REST, ichki → gRPC

4.  ommaviy → REST (universal)

5.  protoc qayta (yangi kod)

Vazifa 3: .proto

Modellang:

1. message
2. service
3. rpc
4. Maydon raqami

Vazifa 4: Kod generatsiya

Modellang:

1. .proto
2. protoc
3. Turli til
4. Mos

Vazifa 5: Binar

Modellang:

1. JSON hajm
2. Protobuf hajm
3. Farq
4. Raqam

Vazifa 6: gRPC vs REST

Modellang:

1. REST
2. gRPC
3. Ichki/ommaviy
4. Tanlov

Vazifa 7: O'ylash

gRPC .proto fayli xizmatlar orasidagi shartnoma (contract) — nima yuboriladi, nima qaytadi, aniq kelishilgan. Nima uchun aniq shartnoma (schema/contract) taqsimlangan tizimlarda (mikroservis) hal qiluvchi, va nega "sxemasiz" (JSON — istalgan struktura) aloqa katta tizimda muammoga aylanadi?

Nimani mustahkamlaydi: 2.2, 2.8-bo'limlar.

Xulosa

Bu darsda gRPC va Protocol Buffers ni o'rgandik.

Eng muhim uch fikr:

1. gRPC/protobuf va .proto. gRPC — Google'ning xizmatlararo yuqori unumdor aloqa tizimi; Protocol Buffers (protobuf) — binar ma'lumot formati va sxema tili; REST/JSON (23-qism) sekin/shartnomasiz joyda tez/shartnomali. .proto — sxema fayli (shartnoma): message (ma'lumot — maydonlar, har birida raqam ism = 1, binar kodda), service (rpc metodlar), rpc (masofaviy funksiya); xizmatlar kelishilgan shartnoma (yagona manba — Python, Go undan kod).

2. Kod generatsiya, binar, RPC. Kod generatsiya — .protodan turli til kodi avtomatik (protoc — Python _pb2.py, Go .pb.go), mos (yagona manbadan — qo'lda xato yo'q). Binar format — protobuf tezlik manbai: JSON matn (nom takrorlanadi, sekin/katta), protobuf binar (maydon raqami + qiymat — kichik ~3x, tez ~5x parse), lekin o'qilmaydi. RPC (Remote Procedure Call) — masofadagi funksiyani mahalliy kabi chaqirish (stub.Qoshish(...) — tarmoq yashirin, gRPC protobuf'ga o'giradi, HTTP/2 orqali Go'ga).

3. REST taqqoslash va polyglot ko'prik. gRPC vs REST: REST/JSON (matn, o'qiladi, ommaviy API/brauzer, sekinroq), gRPC/protobuf (binar, tez, .proto shartnoma, kod avtomatik, ichki xizmat aloqasi — o'qilmaydi); tanlov ommaviy (REST) yoki ichki (gRPC), ko'p tizim ikkalasi. gRPC — polyglot xizmatlar aloqa ko'prigi: turli til (Python, Go — 30.13) tez (binar), ishonchli (.proto shartnoma) gaplashadi; 25-qism (mikroservis aloqasi) yuqori unumdor varianti, 30.16 (polyglot) aloqa qatlami. Aniq shartnoma (.proto) taqsimlangan tizimda hal qiluvchi (mustaqillik, erta xato, hujjat); sxemasiz JSON katta tizimda muammo (taxmin, jim buzilish, N^2 kelishuv).

Keyingi darsda Python va JavaScript ni o'rganamiz: veb dunyosidagi eng keng tarqalgan til bilan integratsiya — Python backend + JavaScript frontend, JSON aloqa, Node.js va WebAssembly (Python'ni brauzerda ishlatish — Pyodide).