# فصل ۰۸ — هزینه در تولید

<div dir="rtl">

# فصل ۰۸ — هزینه در تولید

## در این فصل چه یاد می‌گیری

هیچ قیمتی در این فصل نوشته نمی‌شود، چون قیمت‌ها فردا عوض می‌شوند. **در عوض واحد می‌شماریم** — اجرای مدل، خواندنِ `cache`، ساعت‌نمونه — و آخرِ فصل **نقطهٔ سربه‌سر** را با عدد به دست می‌آوریم تا با قیمتِ فروشندهٔ خودت جواب بگیری.

منحنیِ بارِ یک شبانه‌روز را **فرض** می‌کنیم و حساب می‌کنیم اوجش **۲٫۱۱ برابرِ** میانگین است. مقیاسِ افقی روی همان منحنی **۲٫۰۴ برابر** ساعت‌نمونه صرفه‌جویی می‌کند. **و بعد یک `cache` هشتادوهفت‌درصدی همان هزینه را ۸ برابر کم می‌کند — چهار برابرِ بهترین تصمیمِ مقیاس.**

![دو ماشین‌خانه با ظرفیتِ ثابت و ظرفیتِ متغیر](/lesson-assets/t4-s08-cost-in-production/prompt/01-image-two-plant-layouts.png)

آخر این فصل می‌توانی:

- هزینه را از روی **واحدهای شمرده‌شده** بسازی، نه از روی حدس
- منحنیِ بار را بکشی و نسبتِ اوج به میانگین را بگویی
- مقیاسِ افقی و عمودی را با ساعت‌نمونه مقایسه کنی
- نقطهٔ سربه‌سرِ یک بهینه‌سازی را حساب کنی و با قیمتِ خودت تصمیم بگیری

## قبل از شروع

**از فصلِ ۵:** نرخِ اصابتِ `cache` و شمارندهٔ اجرای مدل. **از فصلِ ۴:** صف، که کارِ غیرفوری را از ساعتِ اوج به ساعتِ خلوت می‌برد. **از فصلِ ۷:** مسیرِ پشتیبان، که در این فصل معلوم می‌شود از مدل چقدر ارزان‌تر است.

> ⚠️ **مواظب باش:** در این فصل عمداً هیچ قیمتی — نه ساعتِ ماشین، نه گیگابایت، نه هزارتا درخواست — داخلِ متن نوشته نمی‌شود. **هر عددی که اینجا ببینی یک شمارش است، نه یک قیمت.** قیمت‌ها را خودت در متغیرهای بالای سلولِ آخر می‌گذاری. **و یک قید که به همان اندازه مهم است: منحنیِ بار و ظرفیتِ نمونه هم فرض‌اند، نه اندازه‌گیری.** `SHAPE` و `CAPACITY` و `HEADROOM` را ما دستی نوشته‌ایم تا شکلِ یک شبانه‌روزِ معمول را نشان بدهند؛ **تنها عددِ اندازه‌گیری‌شدهٔ این فصل نرخِ اصابتِ `cache` است** که از شمارندهٔ بخشِ ۱ می‌آید. هر جا در ادامه «حساب کردیم» می‌بینی، یعنی از همین فرض‌ها نتیجه گرفته‌ایم — روشِ حساب مالِ هر سرویسی است، عددش مالِ این منحنی.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-4-deployment/session-08-cost-in-production.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوت‌بوک روی CPU | کمتر از یک دقیقه |
| GPU | لازم نیست |

<div dir="rtl">

## ۱. واحد بشمار، نه پول

اولین کارِ هر تحلیلِ هزینه این است که بفهمی سرویس **چه چیزی** مصرف می‌کند. بعدش ضرب کردن در قیمت کارِ آسانی است — و آن ضرب را می‌شود هر ماه دوباره انجام داد بی‌آنکه اندازه‌گیری کهنه شود.

</div>

```python
import math
import random
import sqlite3

model = fit_model(TRAIN[:800])
POOL = [r["text"] for r in TEST]
WEIGHTS = [20.0] * 60 + [1.0] * (len(POOL) - 60)
STREAM = random.Random(11).choices(POOL, weights=WEIGHTS, k=2000)

CACHE = sqlite3.connect(str(WORK / "cost.db"))
CACHE.execute("CREATE TABLE l2 (key TEXT PRIMARY KEY, label TEXT)")
UNITS = {"model": 0, "cache_read": 0, "cache_write": 0}


def measure(use_cache):
    for key in UNITS:
        UNITS[key] = 0
    CACHE.execute("DELETE FROM l2")
    memory = {}
    for text in STREAM:
        key = normalise(text)
        if use_cache:
            UNITS["cache_read"] += 1
            if key in memory:
                continue
            row = CACHE.execute("SELECT label FROM l2 WHERE key = ?", (key,)).fetchone()
            if row:
                memory[key] = row[0]
                continue
        UNITS["model"] += 1
        label = model.predict([key])[0]
        if use_cache:
            memory[key] = label
            UNITS["cache_write"] += 1
            CACHE.execute("INSERT OR REPLACE INTO l2 VALUES (?, ?)", (key, label))
    CACHE.commit()
    return dict(UNITS)


cold = measure(use_cache=False)
warm = measure(use_cache=True)
print(f"{'':<18}{'اجرای مدل':>12}{'خواندنِ cache':>16}{'نوشتنِ cache':>15}")
for name, u in (("بدونِ cache", cold), ("با cache", warm)):
    print(f"{name:<18}{u['model']:>12}{u['cache_read']:>16}{u['cache_write']:>15}")
print("حجمِ دادهٔ cache (بایت):",
      CACHE.execute("SELECT SUM(LENGTH(CAST(key AS BLOB)) + LENGTH(CAST(label AS BLOB)))"
                    " FROM l2").fetchone()[0])
```

```text
                     اجرای مدل   خواندنِ cache   نوشتنِ cache
بدونِ cache               2000               0              0
با cache                   250            2000            250
حجمِ دادهٔ cache (بایت): 39356
```

<div dir="rtl">

**سه ستون، سه جنسِ کاملاً متفاوتِ هزینه.** اجرای مدل پردازنده می‌خواهد، خواندنِ `cache` یک تماسِ سبک است، و ذخیره‌سازی جای دیسک می‌گیرد و **ماهانه** حساب می‌شود نه به‌ازای هر درخواست.

**سی‌ونه کیلوبایت برای دویست‌وپنجاه جواب.** (`CAST ... AS BLOB` لازم است، چون `LENGTH` روی متن نویسه می‌شمارد نه بایت، و هر حرفِ فارسی دو بایت است.) این عدد آن‌قدر کوچک است که ذخیره‌سازی در این سرویس اصلاً وارد معادله نمی‌شود، و برای همین حسابِ بخشِ ۶ فقط اجرای مدل و خواندنِ `cache` را دارد.

## ۲. به ازای هر میلیون درخواست

شمارشِ دو هزار درخواست به‌تنهایی معنا ندارد. **واحدِ استانداردِ گفت‌وگو با هر فروشنده‌ای «به ازای هر میلیون» است.**

</div>

```python
def per_million(units):
    factor = 1_000_000 / len(STREAM)
    return {k: v * factor for k, v in units.items()}


for name, u in (("بدونِ cache", cold), ("با cache", warm)):
    p = per_million(u)
    print(f"{name:<12} به ازای هر میلیون درخواست:"
          f" اجرای مدل {p['model']:>10,.0f} · خواندنِ cache {p['cache_read']:>10,.0f}")
print("نسبتِ اجرای مدل:", round(cold["model"] / warm["model"], 2), "برابر")
```

```text
بدونِ cache  به ازای هر میلیون درخواست: اجرای مدل  1,000,000 · خواندنِ cache          0
با cache     به ازای هر میلیون درخواست: اجرای مدل    125,000 · خواندنِ cache  1,000,000
نسبتِ اجرای مدل: 8.0 برابر
```

<div dir="rtl">

**هشت برابر کمتر اجرای مدل — و یک میلیون خواندنِ `cache` که قبلاً نبود.**

**این جدول عمداً چیزی را که خرج شده هم نشان می‌دهد، نه فقط چیزی را که صرفه‌جویی شده.** بیشترِ گزارش‌های بهینه‌سازی فقط ستونِ اول را می‌نویسند. بخشِ ۶ نشان می‌دهد که بدونِ ستونِ دوم، تصمیم اصلاً قابلِ گرفتن نیست.

## ۳. منحنیِ بار

هزینه فقط به «چند درخواست در روز» بستگی ندارد؛ به **شکلِ توزیعشان در شبانه‌روز** بستگی دارد.

`SHAPE` زیر یک **فرض** است، نه یک اندازه‌گیری — بیست‌وچهار عددِ دستی که شکلِ آشنای یک سرویسِ روزانه را می‌سازند. **منحنیِ خودت را باید از سیاههٔ سرویسِ خودت دربیاوری**؛ چیزی که اینجا یاد می‌گیری روشِ حساب است، نه این بیست‌وچهار عدد.

</div>

```python
SHAPE = [12, 8, 5, 4, 4, 7, 15, 34, 66, 88, 100, 96,
         85, 90, 98, 93, 80, 62, 48, 41, 35, 29, 21, 15]
REQUESTS = [s * 3000 for s in SHAPE]
total = sum(REQUESTS)
peak, mean = max(REQUESTS), total / 24
print(f"درخواست در شبانه‌روز : {total:,}")
print(f"اوج در ساعت         : {peak:,}")
print(f"میانگین در ساعت     : {mean:,.0f}")
print(f"نسبتِ اوج به میانگین : {peak / mean:.2f}")
print("نمودارِ بار:")
for hour, count in enumerate(REQUESTS):
    print(f"  {hour:>2} {'#' * round(count / peak * 40)}")
```

```text
درخواست در شبانه‌روز : 3,408,000
اوج در ساعت         : 300,000
میانگین در ساعت     : 142,000
نسبتِ اوج به میانگین : 2.11
نمودارِ بار:
   0 #####
   1 ###
   2 ##
   3 ##
   4 ##
   5 ###
   6 ######
   7 ##############
   8 ##########################
   9 ###################################
  10 ########################################
  11 ######################################
  12 ##################################
  13 ####################################
  14 #######################################
  15 #####################################
  16 ################################
  17 #########################
  18 ###################
  19 ################
  20 ##############
  21 ############
  22 ########
  23 ######
```

<div dir="rtl">

**نسبتِ اوج به میانگین ۲٫۱۱ است، و همین یک عدد کلِ بحثِ مقیاس‌پذیری را می‌سازد.**

اگر ظرفیت را برای اوج بخری، **بیشترِ شبانه‌روز نصفش بی‌کار است**. اگر برای میانگین بخری، ساعتِ ده صبح سرویس زمین می‌خورد. **هرچه این نسبت بزرگ‌تر باشد، مقیاسِ خودکار بیشتر می‌ارزد** — و در سرویس‌هایی با اوجِ ده‌برابری، تفاوت از این هم بزرگ‌تر است.

## ۴. عمودی در برابرِ افقی

**عمودی یعنی یک ماشینِ بزرگ‌تر بخر. افقی یعنی چند ماشینِ کوچک، به تعدادی که همان ساعت لازم است.**

</div>

```python
CAPACITY = 60_000          # اجرای مدل در ساعت، برای هر نمونه
HEADROOM = 0.70            # هیچ‌کس نمونه را صد درصد پر نمی‌کند


def instances(load):
    return max(1, math.ceil(load / (CAPACITY * HEADROOM)))


def plan(hit_rate, floor=1):
    runs = [round(r * (1 - hit_rate)) for r in REQUESTS]
    return {"vertical": instances(max(runs)) * 24,
            "horizontal": sum(max(floor, instances(r)) for r in runs)}


no_cache = plan(0.0)
print(f"بدونِ cache — عمودی: {no_cache['vertical']} ساعت‌نمونه"
      f" · افقی: {no_cache['horizontal']} ساعت‌نمونه"
      f" · صرفه‌جویی {no_cache['vertical'] / no_cache['horizontal']:.2f} برابر")
floored = plan(0.0, floor=2)
print(f"با کفِ دو نمونه   — افقی: {floored['horizontal']} ساعت‌نمونه"
      f" · صرفه‌جویی {no_cache['vertical'] / floored['horizontal']:.2f} برابر")
```

```text
بدونِ cache — عمودی: 192 ساعت‌نمونه · افقی: 94 ساعت‌نمونه · صرفه‌جویی 2.04 برابر
با کفِ دو نمونه   — افقی: 100 ساعت‌نمونه · صرفه‌جویی 1.92 برابر
```

<div dir="rtl">

**۱۹۲ در برابرِ ۹۴ ساعت‌نمونه.** عددِ ۲٫۰۴ تقریباً همان نسبتِ اوج به میانگینِ بخشِ قبل است، و این تصادفی نیست: **مقیاسِ افقی دقیقاً همان فاصله را می‌گیرد.**

**و باز هم: `CAPACITY` و `HEADROOM` هر دو فرض‌اند.** ظرفیتِ نمونه را باید با یک آزمونِ بار روی سخت‌افزارِ خودت اندازه بگیری، نه از یک کتاب برداری. `HEADROOM` هم یک تصمیمِ واقعی است: اگر نمونه‌ها را صد درصد پر کنی، هر نوسانِ کوچکِ ترافیک صف می‌سازد و `p95` را خراب می‌کند. **هفتاد درصد یعنی سی درصدِ ظرفیت را برای بدشانسی کنار گذاشته‌ای.**

**و کفِ دو نمونه هزینهٔ واقعیِ افقی است.** یک نمونه یعنی هر ری‌استارت یک قطعی است، پس در عمل زیرِ دو نمونه نمی‌روی. **صرفه‌جویی از ۲٫۰۴ به ۱٫۹۲ رسید — نه فاجعه، ولی رایگان هم نبود.**

> ✅ **چک کن:** به ستونِ افقی نگاه کن و از خودت بپرس **چند بار در شبانه‌روز تعدادِ نمونه‌ها عوض شد.** هر تغییر یک راه‌اندازیِ تازه است، و هر راه‌اندازی یعنی بارگذاریِ دوبارهٔ مدل و یک `cache` سرد (فصلِ ۵). **اگر منحنیِ بارت دندانه‌دار باشد، مقیاسِ خودکار می‌تواند بیشتر از آنچه صرفه‌جویی می‌کند خرج بتراشد.**

## ۵. `cache` منحنی را عوض می‌کند

</div>

```python
hit = 1 - warm["model"] / cold["model"]
cached = plan(hit)
print(f"نرخِ اصابتِ اندازه‌گیری‌شده: {100 * hit:.1f}%")
print(f"با cache — عمودی: {cached['vertical']} ساعت‌نمونه"
      f" · افقی: {cached['horizontal']} ساعت‌نمونه")
print(f"عمودیِ بدونِ cache در برابرِ افقیِ با cache:"
      f" {no_cache['vertical'] / cached['horizontal']:.2f} برابر")
print(f"بهترین تصمیمِ مقیاس، بدونِ cache : "
      f"{no_cache['vertical'] / no_cache['horizontal']:.2f} برابر")
```

```text
نرخِ اصابتِ اندازه‌گیری‌شده: 87.5%
با cache — عمودی: 24 ساعت‌نمونه · افقی: 24 ساعت‌نمونه
عمودیِ بدونِ cache در برابرِ افقیِ با cache: 8.00 برابر
بهترین تصمیمِ مقیاس، بدونِ cache : 2.04 برابر
```

<div dir="rtl">

**هشت برابر در برابرِ دو برابر.**

**و یک نکتهٔ ظریف‌تر: با `cache`، عمودی و افقی هر دو ۲۴ ساعت‌نمونه شدند.** یعنی بار آن‌قدر کم شده که حتی در ساعتِ اوج هم یک نمونه کافی است، و **کلِ بحثِ مقیاس‌پذیری موضوعیت خودش را از دست داد.**

این ترتیبِ درستِ کار است و اغلب وارونه انجام می‌شود: **اول کارِ کمتر کن، بعد ماشینِ بیشتر بخر.** هر ساعتی که صرفِ تنظیمِ مقیاسِ خودکار می‌شود در حالی که هشتاد درصدِ درخواست‌ها تکراری‌اند، ساعتِ هدررفته است.

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان منحنیِ بار و همان ظرفیتِ نمونه؛ تنها متغیر نرخِ اصابت بود، و آن هم **اندازه‌گیری شده** — از شمارندهٔ بخشِ ۱ آمده، نه از یک فرض. **روی کدام داده؟** همان ۲۰۰۰ درخواست برای شمارشِ واحدها و همان منحنیِ ۲۴ساعته برای ساعت‌نمونه. **با چند `seed`؟** یکی، **و اینجا صادقانه باید گفت که این عدد بیشتر از هر چیزی به شکلِ ترافیک وابسته است، نه به `seed`**: اگر ترافیکِ تو تکرارِ کمتری داشته باشد، نرخِ اصابت پایین می‌آید و همین حساب جوابِ دیگری می‌دهد. **عددِ ۸ برابر مالِ این ترافیک است؛ روشِ رسیدن به آن مالِ هر ترافیکی.**

## ۶. نقطهٔ سربه‌سر، با قیمتِ خودت

تا اینجا فقط شمرده‌ایم. حالا تصمیم می‌گیریم — **و برای اینکه این حساب هیچ‌وقت کهنه نشود، واحدِ حساب را «هزینهٔ یک بار اجرای مدل» می‌گذاریم و بقیه را نسبت به آن می‌سنجیم.**

</div>

```python
PRICE_CACHE_READ = [1.0, 0.1, 0.01]      # ← نسبتِ قیمتِ خودت را اینجا بگذار


def per_request(units, price_cache_read):
    return (units["model"] + units["cache_read"] * price_cache_read) / len(STREAM)


saved = cold["model"] - warm["model"]
breakeven = saved / warm["cache_read"]
print(f"واحدِ حساب: هزینهٔ یک بار اجرای مدل = ۱")
print(f"نقطهٔ سربه‌سر: هر خواندنِ cache باید ارزان‌تر از {breakeven:.4f}"
      f" برابرِ یک اجرای مدل باشد")
for ratio in PRICE_CACHE_READ:
    a, b = per_request(cold, ratio), per_request(warm, ratio)
    print(f"  نسبتِ قیمت {ratio:<5} → بدونِ cache {a:.4f} · با cache {b:.4f}"
          f" · نسبت {a / b:.2f}")
print(f"ساعت‌نمونه به ازای هر میلیون درخواست:"
      f" بدونِ cache {no_cache['horizontal'] / total * 1e6:.1f}"
      f" · با cache {cached['horizontal'] / total * 1e6:.1f}")
```

```text
واحدِ حساب: هزینهٔ یک بار اجرای مدل = ۱
نقطهٔ سربه‌سر: هر خواندنِ cache باید ارزان‌تر از 0.8750 برابرِ یک اجرای مدل باشد
  نسبتِ قیمت 1.0   → بدونِ cache 1.0000 · با cache 1.1250 · نسبت 0.89
  نسبتِ قیمت 0.1   → بدونِ cache 1.0000 · با cache 0.2250 · نسبت 4.44
  نسبتِ قیمت 0.01  → بدونِ cache 1.0000 · با cache 0.1350 · نسبت 7.41
ساعت‌نمونه به ازای هر میلیون درخواست: بدونِ cache 27.6 · با cache 7.0
```

<div dir="rtl">

**خطِ اولِ جدول یک هشدارِ واقعی است: با نسبتِ قیمتِ ۱، `cache` سرویس را گران‌تر می‌کند، نه ارزان‌تر.**

منطقش ساده است: `cache` از هر میلیون درخواست، هشتصد و هفتاد و پنج هزار اجرای مدل را حذف می‌کند ولی **یک میلیون** خواندن اضافه می‌کند. اگر هر خواندن به‌اندازهٔ یک اجرای مدل خرج بردارد، معامله ضرر است.

**در عمل این نسبت خیلی کوچک است** — یک جست‌وجو در `cache` هزارها برابر ارزان‌تر از اجرای یک مدل است — پس جواب معمولاً روشن است. **ولی این را باید بدانی، نه فرض کنی**، و روزی که مدلت خیلی کوچک و `cache` ات روی شبکه باشد، همین حساب می‌تواند وارونه شود.

> 🌱 **ریشه‌اش کجاست:** «نقطهٔ سربه‌سر» یک اسمِ فنی برای یک کارِ آشناست: **دو عبارت را برابر بگذار و مجهول را دربیاور.** اینجا یک طرف هزینهٔ بدونِ `cache` است (`۲۰۰۰` اجرای مدل) و طرفِ دیگر هزینهٔ با `cache` (`۲۵۰ + r × ۲۰۰۰`)، و مجهولْ نسبتِ قیمتِ `r` است. حل کردنش دقیقاً همان قاعدهٔ [ریشه، ترم ۳ فصل ۳ — معادلهٔ خطی، قدم‌به‌قدم](/courses/risheh/lessons/term-3-algebra/session-03-solve-linear) است: **«برعکسِ ترتیبِ عملیات»** — اول جمع را بردار، بعد ضرب را. **پس عددِ ۰٫۸۷۵ یک ثابتِ جادویی نیست؛ جوابِ یک معادلهٔ خطیِ دومرحله‌ای است** — و اگر نرخِ اصابتت عوض شود، همان معادله عددِ دیگری می‌دهد.

**و به دو عددِ خطِ آخر نگاه کن:** ۲۷٫۶ در برابرِ ۷٫۰ ساعت‌نمونه در هر میلیون. هرکدام را در قیمتِ ساعتیِ فروشنده‌ات ضرب کن، و مجموعِ سه ضرب — اجرای مدل، خواندنِ `cache`، ساعت‌نمونه — کلِ هزینهٔ متغیرِ سرویس است.

## ۷. چه چیزی را مقیاس حل نمی‌کند

</div>

| اگر مشکل این است… | مقیاس کمک می‌کند؟ | کارِ درست |
|---|---|---|
| ساعتِ اوج سرویس کند می‌شود | بله، افقی | مقیاسِ خودکار روی منحنیِ بار |
| هر درخواست ذاتاً گران است | نه | `cache`، مدلِ کوچک‌تر، `batching` |
| هشتاد درصدِ سؤال‌ها تکراری‌اند | نه | `cache` (فصلِ ۵) |
| کارِ سنگین فوری نیست | نه | صف و اجرای شبانه (فصلِ ۴) |
| یک وابستگی افتاده | نه | قطع‌کننده و پشتیبان (فصلِ ۷) |
| حجمِ ذخیره‌سازی زیاد است | نه | مهلتِ نگه‌داری (ترمِ ۲ فصلِ ۸) |

<div dir="rtl">

**و بزرگ‌ترین هزینهٔ پنهانِ هیچ‌کدام از این ردیف‌ها نیست: هزینهٔ آدم.** یک سامانهٔ افقیِ خودکار با ده نمونه، مقیاسِ خودکار، و `cache` مشترک، هر ماه ساعت‌ها نگه‌داری می‌خواهد. **اگر صرفه‌جویی‌ات کمتر از دستمزدِ آن ساعت‌هاست، سادگی ارزان‌تر است** — و این همان تصمیمی است که ترمِ ۶ اسمش را «بساز یا بخر» می‌گذارد.

> 🔧 **اگر کار نکرد:** اگر `plan` برایت `ZeroDivisionError: division by zero` داد، `HEADROOM` یا `CAPACITY` را صفر گذاشته‌ای، چون `instances` بر حاصل‌ضربشان تقسیم می‌کند. برعکسش هم تله است: `hit_rate` برابرِ ۱ هیچ خطایی نمی‌دهد و `plan(1.0)` همان ۲۴ ساعت‌نمونه را برمی‌گرداند، چون `instances` را با `max(1, ...)` نوشته‌ایم؛ ولی **عددی که برمی‌گردد بی‌معنا است**: نرخِ اصابتِ صد درصد یعنی مدل هیچ‌وقت اجرا نمی‌شود، و آن‌وقت اصلاً به مدل نیازی نداری. **هر بار که یک محاسبهٔ هزینه عددِ صفر یا بی‌نهایت داد، اول به فرض‌هایت شک کن، بعد به کد.**

> 🤖 **از دستیارت بپرس:** «تفاوتِ `reserved` و `spot` و `on-demand` در خریدِ ظرفیت چیست و هرکدام چه ریسکی دارند؟» بعد این را بپرس: **«اگر منحنیِ بارِ من نسبتِ اوج به میانگینِ ۲ داشته باشد، چه ترکیبی از ظرفیتِ ثابت و ظرفیتِ کشسان کمترین هزینه را می‌دهد؟»** — جوابش همان تقسیمِ «کف با قیمتِ ارزان‌تر، اوج با قیمتِ گران‌تر» است.

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| cost per request | کاست پر ریکوئست | هزینهٔ متغیرِ سرویس تقسیم بر تعدادِ درخواست |
| load curve | لود کرو | شکلِ توزیعِ ترافیک در طولِ شبانه‌روز |
| peak-to-mean ratio | پیک تو مین ریشیو | نسبتِ بارِ اوج به بارِ میانگین |
| vertical scaling | ورتیکال اسکیلینگ | بزرگ‌تر کردنِ همان ماشین |
| horizontal scaling | هوریزنتال اسکیلینگ | زیاد کردنِ تعدادِ ماشین‌ها |
| headroom | هدروم | ظرفیتِ خالی که عمداً پر نمی‌شود |
| break-even | بریک-ایون | نقطه‌ای که دو گزینه هزینهٔ برابر دارند |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا نقطهٔ سربه‌سرِ `cache` دقیقاً برابرِ «نسبتِ اجراهای حذف‌شده به خواندن‌های اضافه‌شده» است؟

**تمرینِ اجباری:** منحنیِ بار را دو بار عوض کن: یک بار کاملاً صاف (همهٔ ساعت‌ها برابر) و یک بار با اوجِ ده‌برابری (یک ساعتِ خیلی شلوغ و بقیه خلوت). برای هر سه منحنی **سه عدد** بده: نسبتِ اوج به میانگین، ساعت‌نمونهٔ عمودی، و ساعت‌نمونهٔ افقی. **بعد نموداری از «نسبتِ اوج به میانگین» در برابرِ «صرفه‌جوییِ افقی» بکش و جواب بده: رابطه‌شان چه شکلی است و از کجا معلوم بود؟**

**تمرینِ ستاره‌دار ⭐:** یک بُعدِ سوم به حساب اضافه کن: **صف**. فرض کن سی درصدِ درخواست‌ها فوری نیستند و می‌شود آن‌ها را به ساعتِ خلوت انداخت. منحنیِ بارِ تازه را بساز و ساعت‌نمونهٔ افقی را دوباره حساب کن. **سه چیز را گزارش کن:** صرفه‌جویی نسبت به حالتِ بدونِ صف، **بیشترین تأخیری که یک کارِ به‌تعویق‌افتاده تحمل می‌کند**، و اینکه اگر آن سی درصد را با `cache` هم ترکیب کنی چه می‌شود. **و سؤالِ سخت را جواب بده: آیا صرفه‌جوییِ صف و صرفه‌جوییِ `cache` با هم جمع می‌شوند؟** — جوابت باید توضیح بدهد که هر دو روی **همان** اجراهای مدل کار می‌کنند یا نه.

## در فصل بعد

هشت فصل گذشت. **فصلِ آخر هفت قطعه از آن‌ها را در یک خطِ استقرار کنارِ هم می‌گذارد**: `artifact` با `MANIFEST`، سرویسِ نسخه‌دار، صفِ یکسان‌توان، `cache` کلیددارِ نسخه، انتشارِ قناری با دروازهٔ زیرگروهی، قطع‌کننده و پشتیبان، و سیاههٔ هزینه. **و چیزی که تا حالا نداشتیم: دکمهٔ برگشت** — با اندازه‌گیریِ اینکه از لحظهٔ خرابی تا لحظهٔ برگشت چند کاربر آسیب دیدند.

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t4/s08-cost-in-production (یادستان, Yaadestan)
