6 שלב האינטגרציה

Full-Stack חינמי — חיווט הכל ביחד, והחלטת Pay-or-Not

הלומד יחבר full-stack SaaS שלם וחי על ה-free tier בלבד (Worker + Static Assets + D1 + R2 + KV + Workers AI + RAG + Turnstile + Access), ויקבל החלטת pay-or-not מבוססת מספרים — לכל primitive: מה המגבלה שתיפול ראשונה, מתי לשדרג ל-$5, וכמה זה יעלה ב-1,000 משתמשים

כול למערכת SaaS (תוכנה כשירות) שלמה וחינמית לחלוטין. בפרק הזה נלמד לחווק את כל שירותי הענן של Cloudflare לפלט

מה יהיה לך ביד בסוף הפרק
מטרות למידה
מה צריך לפני שמתחילים
חוט הפרויקט

הפרק הקודם: בפרק הקודם הגדרנו את חומת האבטח והאימות באמצעות Turnstile ו-Zero Trust וייצרנו לוגים ראשוניים עם Analytics Engine.

הפרק הזה: הלומד יחבר full-stack SaaS שלם וחי על ה-free tier בלבד (Worker + Static Assets + D1 + R2 + KV + Workers AI + RAG + Turnstile + Access), ויקבל החלטת pay-or-not מבוססת מספרים — לכל primitive: מה המגבלה שתיפול ראשונה, מתי לשדרג ל-$5, וכמה זה יעלה ב-1,000 משתמשים

הפרק הבא: מכאן הסטודנט ממשיך לאפליקציה מלאה באוויר, ויכול לקבל את ההחלטה האם לשדרג ל-Workers Paid לפי התרחיש הפיננסי המדויק.

מילון מונחים — פרק 6
מונחהסבר
full-stack on free tierפיתוח מלא של צד שרת וצד לקוח על תשתית חינמית ללא שרתים ייעודיים.
binding compositionשילוב מספר משאבים (D1, KV, R2) תחת הגדרת ה-Worker הבודד בקובץ קונפיגורציה אחד.
first-limit-to-fallניתוח המזהה את המגבלה הספציפית שתגרום לקריסת ה-Free Tier של האפליקציה ראשונה.
Neuronsיחידת המדידה והתמחור של קריאות ה-AI ב-Cloudflare (מגבלה של 10k ביום ב-Free).
Turnstileחלופת ה-CAPTCHA החינמית והפרטית של Cloudflare שאינה דורשת אינטראקציה מעיקה מהמשתמש.
Analytics Engineשירות לוגים ואיסוף מטריקות מבוסס SQL של Cloudflare המאפשר ניתוח ביצועים ב-$0.
wrangler secret putכלי שורת הפקודה להזנת משתני סביבה מוצפנים ללא חשיפתם בגיט.
בינוני5 דקותחינםarchitecture

ארכיטקטורת ה-Free Full-Stack: מבנה הצינורות של אפליקציית Vibe מנצחת

בעולם פיתוח התוכנה המודרני, פיתוח יישום מלא בקצה (Full-Stack on Free Tier) — גישה המאפשרת להריץ גם את ממשק המשתמש (Client) וגם את קוד השרת ובסיס הנתונים (Server & DB) תחת מסלולים חינמיים לחלוטין של ספקי ענן — הפך לנשק הסודי של ה-Vibe Coders. במקום להסתבך עם הגדרות שרתים מורכבות, ניהול קונטיינרים (Containers) כבדים או חיווט ידני מתיש בין ספקים שונים (שרת ב-Vercel, בסיס נתונים ב-Supabase ואחסון קבצים ב-AWS), ארכיטקטורת הצינורות המודרנית של Cloudflare מרכזת את כל משאבי היישום תחת קורת גג אחת, ללא עלות ועם אפס "זמן עלייה קרה" (Cold Start). מודל זה מבוסס על מנוע בידוד V8 (V8 Isolate — טכנולוגיית הרצת קוד קלילה במיוחד של דפדפנים, המאפשרת להריץ פונקציות שרת ללא השהיית הפעלה ראשונית ובשבריר מהזיכרון שדורש שרת מסורתי).

החל משנת 2026, תבנית מוכנה לפיתוח מוצר (Free Full-Stack SaaS Starter) נשענת על שרתים חסרי שרת (Serverless Compute) המכונים Cloudflare Workers, בשילוב הדור החדש של Workers Static Assets (מנגנון מובנה לאירוח קבצים סטטיים ישירות מה-CDN). המשמעות היא שהאתר הסטטי שלכם (React, Vue או HTML פשוט) וכל נתיבי ה-API שלכם רצים יחד על אותה פלטפורמה קלה. החיבור לבסיס הנתונים נעשה באמצעות Cloudflare D1, בסיס נתונים יחסי מסוג SQLite המבוזר בקצה הרשת, בעוד שקבצים כבדים או תמונות נשמרים ב-Cloudflare R2, שירות אחסון קבצים (Object Storage) תואם S3 המצטיין באפס דמי תעבורה יוצאת (Egress Fees — העמלות שחברות הענן הגדולות גובות מכם כאשר קבצים או מידע יוצאים משרתי האחסון שלהן אל המשתמשים). ארכיטקטורה זו מבטיחה שהאפליקציה שלכם תישאר מהירה בצורה קיצונית ותעלה לכם בדיוק 0 שקלים כל עוד אתם בטווח מגבלות החינם.

החיווט המעשי: מבנה הצינורות בתוך קובץ ה-Wrangler

כדי לחבר את כל הרכיבים הללו יחד, אנו משתמשים ב-ממשק שורת פקודה Wrangler (Wrangler CLI — כלי הפיתוח הרשמי שבאמצעותו מנהלים, בודקים ומפיצים פרויקטים לפלטפורמה של Cloudflare). כל החיווטים והקשרים בין השרת, התיקיות הסטטיות, בסיס הנתונים ורכיבי הבינה המלאכותית מוגדרים בקובץ הגדרות יחיד בשם wrangler.toml. בקובץ זה אנו מייצרים "bindings" (קישורים ישירים) המאפשרים לקוד השרת לגשת למשאבים השונים כמשתנים גלובליים פשוטים ללא צורך בהגדרת מחרוזות חיבור (Connection Strings) מורכבות או מפתחות אבטחה המועברים ברשת.

שימו לב לשינוי המהותי של שנת 2026: בעוד שבעבר הייתם צריכים לנהל פרויקטים נפרדים ב-Cloudflare Pages וב-Cloudflare Workers, כיום מומלץ להשתמש ב-Workers Static Assets. הגדרת תיקיית הנכסים הסטטיים מתבצעת ישירות תחת בלוק ה-[assets] בקובץ הקונפיגורציה. כאשר תריצו פקודת פריסה, ה-CLI יעלה את התיקייה הסטטית לקצה הרשת, והקוד של ה-Worker שלכם ישמש כשרת ה-API ומנוע הניתוב הדינמי שלכם תחת אותו דומיין בדיוק, ללא שום בעיות של חלוקת משאבים בין מקורות שונים (CORS).

מתי לשלם ומתי להישאר בחינם? מטריצת ההחלטה (Pay-or-Not)

אחת הטעויות הנפוצות של מפתחי Vibe היא חוסר הבנה של מגבלות מסלול החינם, דבר המוביל לקריסת האפליקציה ברגע שמשתמשים ראשונים מתחילים להזרים מידע. כדי לקבל החלטה מושכלת מתי לשדרג למסלול בתשלום (שעלותו מתחילה ב-5$ בלבד לחודש ומעניקה נפחים עצומים), עליכם להכיר את צווארי הבקבוק האמיתיים של המערכת. הטבלה הבאה מרכזת את המגבלות הקריטיות ומתי הן מחייבות מעבר למסלול Paid:

רכיב במערכת מגבלת מסלול החינם (Free Tier) טריגר שדרוג נפוץ (Upgrade Trigger) מה מקבלים במסלול Paid ($5/mo)
Workers (Compute) 100,000 בקשות ביום / 10ms זמן מעבד (CPU) בלבד לבקשה. צורך בעיבוד כבד (כמו פענוח קבצי JSON גדולים או ריצת ביטויים רגולריים מורכבים המותחים את ה-CPU מעבר ל-10 מילי-שניות). חשוב: זמן המתנה ל-fetch חיצוני לא נספר כ-CPU! 10 מיליון בקשות בחודש / עד 30 שניות זמן CPU לבקשה כברירת מחדל.
D1 Database (SQLite) 5 מיליון שורות קריאה ביום / 100,000 שורות כתיבה ביום / נפח מקסימלי 5GB. אפליקציות עתירות כתיבה (כמו מעקב לוגים או צ'אט חי) שעוברות את רף ה-100 אלף כתיבות ביום, או שאילתות לא יעילות שמבצעות סריקת טבלה מלאה (Full Table Scan) ומרוקנות את מכסת הקריאה. 25 מיליארד שורות קריאה בחודש / 50 מיליון שורות כתיבה בחודש / 5GB כלולים (וניתן להרחיב בתוספת תשלום קטנה).
R2 Object Storage 10GB שטח אחסון / מיליון פעולות כתיבה (Class A) / 10 מיליון פעולות קריאה (Class B) בחודש. חריגה מנפח 10GB של קבצי מדיה של משתמשים. (העברת הנתונים עצמה תמיד נשארת בחינם, ללא דמי Egress). שלם לפי שימוש מעבר לחינם: $0.015 לכל GB נוסף לחודש, תעריפים מזעריים לפעולות קריאה/כתיבה נוספות.
Workers AI (Inference) 10,000 "ניורונים" (Neurons) ביום עבור מודלים מארחים (כמו Llama 3.1 8B). שימוש כבד במודלים של שפה או ייצור תמונות. שימו לב: שימוש ב-AI Gateway לניתוב ל-OpenAI אינו צורך ניורונים ומבוסס על ה-API key שלכם שם. חיוב מדויק של $0.011 לכל 1,000 ניורונים מעבר למכסה היומית החינמית.
טעות נפוצה: שכחה של קובץ .assetsignore בעת שימוש ב-Workers Static Assets

למה זה מפתה: אנחנו רגילים שפלטפורמות כמו Vercel או Netlify מזהות אוטומטית את קובץ ה-package.json שלנו ומעלות רק את תוצרי הבנייה (כמו תיקיית dist או build) תוך התעלמות אוטומטית מתיקיית הקידוד הכבדה node_modules.

למה זה טעות: בניגוד לפלטפורמות אלו, הפיצ'ר החדש של Workers Static Assets מעלה את כל מה שנמצא בתיקייה שהגדרתם ב-wrangler.toml ללא פילטרים אוטומטיים. אם לא תגדירו קובץ התעלמות, Wrangler ינסה להעלות עשרות אלפי קבצים קטנים מתוך node_modules, מה שיגרום לכם לעבור מיידית את מגבלת 20,000 הקבצים במסלול החינמי ולזמני פריסה (Deployment) ארוכים ומתישים.

מה לעשות במקום: צרו תמיד קובץ בשם .assetsignore בשורש הפרויקט שלכם, והוסיפו אליו שורות ברורות שמתעלמות מקבצי הפיתוח ומתיקיית המקור הלא-מהודרת, בדומה לקובץ .gitignore:

node_modules/
.git/
.DS_Store
src/
wrangler.toml
הקמת תבנית Full-Stack חינמית מקומית 12 דקות

בצעד זה נקים פרויקט מלא באמצעות כלי הפיגומים החדש של Cloudflare, נחבר אותו לבסיס נתונים D1 מקומי, ונשתמש ב-Wrangler Local Explorer (ממשק הדפדפן החדש משנת 2026) כדי לבחון את המידע שלנו.

  1. פתחו את מסוף הפקודות (Terminal) והריצו את פקודת ההקמה הבאה ליצירת פרויקט חדש המבוסס על שלד קוד נקי של JavaScript/TypeScript: 
    npm create cloudflare@latest vibe-fullstack -- --template=vanilla
    במהלך הריצה, אינכם חייבים להתחבר לחשבון Cloudflare שלכם עדיין (בחרו No בשאלת ה-Deploy). התהליך ייצור תיקייה חדשה בשם vibe-fullstack.
  2. היכנסו לתיקייה שנוצרה ופתחו את קובץ ה-wrangler.toml שלכם. החליפו את תוכנו בהגדרות הבאות, המגדירות את אירוח הקבצים הסטטיים מתוך תיקיית public ומחברות בסיס נתונים מקומי בשם DB: 
    name = "vibe-fullstack"
main = "src/index.js"
compatibility_date = "2026-03-19"

[assets]
directory = "./public"
binding = "ASSETS"

[[d1_databases]]
binding = "DB"
database_name = "vibe-db"
database_id = "local-only-db-id"
  3. צרו תיקייה בשם public ובתוכה קובץ index.html פשוט שישמש כממשק המשתמש שלנו: 
    <!DOCTYPE html>
<html>
<head>
    <title>Vibe SaaS Starter</title>
    <meta charset="UTF-8">
</head>
<body>
    <h1>ברוכים הבאים לאפליקציית ה-Vibe שלכם!</h1>
    <button onclick="fetchData()">משוך נתונים מהשרת</button>
    <pre id="output"></pre>

    <script>
        async function fetchData() {
            const res = await fetch('/api/todos');
            const data = await res.json();
            document.getElementById('output').innerText = JSON.stringify(data, null, 2);
        }
    </script>
</body>
</html>
  4. כתבו את קוד השרת בקובץ src/index.js. קוד זה יאזין לנתיב ה-API ויבצע שאילתה מבסיס הנתונים הקיים ב-binding שלנו: 
    export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    
    // ניתוב נתיב ה-API שלנו
    if (url.pathname === "/api/todos") {
      try {
        const { results } = await env.DB.prepare(
          "SELECT * FROM todos"
        ).all();
        return new Response(JSON.stringify(results), {
          headers: { "Content-Type": "application/json" }
        });
      } catch (err) {
        return new Response(JSON.stringify({ error: err.message }), {
          status: 500,
          headers: { "Content-Type": "application/json" }
        });
      }
    }
    
    // החזרת קבצים סטטיים כברירת מחדל
    return env.ASSETS.fetch(request);
  }
};
  5. ניצור קובץ הגדרת טבלה ראשונית בשם schema.sql בשורש הפרויקט כדי לאתחל את בסיס הנתונים: 
    DROP TABLE IF EXISTS todos;
CREATE TABLE todos (id INTEGER PRIMARY KEY, title TEXT, completed INTEGER);
INSERT INTO todos (title, completed) VALUES ('להקים אפליקציה חינמית', 1);
INSERT INTO todos (title, completed) VALUES ('להפוך ל-Vibe Coder מקצוען', 0);
  6. כעת, הריצו את פקודת ההרצה המקומית המדמה את בסיס הנתונים שלכם על המחשב המקומי (באמצעות Miniflare המובנה): 
    npx wrangler d1 execute DB --local --file=./schema.sql
    הפלט הצפוי יראה אישור על הרצת קובץ ה-SQL ויצירת בסיס נתונים מקומי זמני בקובץ מוסתר במחשב שלכם.
  7. הריצו את השרת המקומי עם ממשק ה-Local Explorer פתוח: 
    npx wrangler dev

פלט נראה לעין שתסיים איתו: הדפדפן שלכם יפתח בכתובת http://localhost:8787. לחיצה על הכפתור "משוך נתונים מהשרת" תבצע קריאת API לקוד ה-Worker שלכם, שימשוך את שתי השורות שהזנתם לתוך בסיס הנתונים ה-D1 המקומי ויציג אותן על המסך בפורמט JSON נקי. במקביל, הטרמינל יציג קישור ל-Wrangler Local Explorer המאפשר לכם לצפות בטבלאות בתוך הדפדפן בזמן אמת.

בינוני5 דקותחינםconfiguration

קובץ wrangler.toml אחד למשול בכולם: קומפוזיציית bindings מלאה

כשאתם בונים אפליקציית Full-Stack מסורתית, שלב החיווט של חלקי המערכת השונים הוא לעיתים קרובות כאב ראש לא קטן. אתם צריכים לנהל מפתחות API, להגדיר משתני סביבה בקובצי .env מקומיים, לדאוג לאבטחה שלהם בשרת, ולכתוב קוד אתחול (Boilerplate) ארוך ומייגע רק כדי להתחבר למסד הנתונים או לשירות ה-AI שלכם. בתוך האקוסיסטם של Cloudflare, הארכיטקטורה הזו מפנה את מקומה לטובת קונספט מהפכני שנקרא קומפוזיציית קישורים (Binding Composition). קישור (Binding) הוא הדרך שבה Cloudflare מזריקה משאבי תשתית – כמו מסדי נתונים, שטחי אחסון, הגדרות, ואפילו מודלי בינה מלאכותית – ישירות לתוך הקוד שלכם. במקום לפתוח חיבורי רשת ידניים או לנהל סיסמאות, המשאבים הללו פשוט מופיעים כאובייקטים חיים על אובייקט ה-env של ה-Worker שלכם בזמן הריצה. קובץ ה-wrangler.toml הוא המקום היחיד שבו מתרחש הקסם הזה. הוא משמש כחוזה הרשמי בין הקוד שלכם לבין התשתיות הפיזיות שרצות ב-300+ ערים ברחבי העולם על גבי מנועי הרצה מבודדים (V8 Isolates) – טכנולוגיה קלת-משקל המריצה קוד במהירות ובלי זמני עליה קרים (Cold Starts). בשנת 2026, פלטפורמת ה-Workers עברה שדרוג משמעותי: היא מציעה כעת תאימות מלאה לנכסים סטטיים (Workers Static Assets), המאפשרת לארח את כל ה-Frontend (קובצי HTML, CSS ו-JS) לצד ה-API באותו פרויקט בדיוק, תוך החלפת פלטפורמת Pages הישנה. המשמעות עבורכם כ-Vibe Coders היא דרמטית: קובץ wrangler.toml אחד ויחיד מגדיר את ה-Frontend, ה-Backend, מסד הנתונים SQLite שלכם (D1), זיכרון המטמון המהיר (KV), ואפילו את הגישה למודלי שפה גדולים (LLMs). הכל מוגדר במקום אחד, מאובטח כברירת מחדל, ומסובסד לחלוטין במסגרת השכבה החינמית הנדיבה של Cloudflare.

המבנה של קובץ wrangler.toml מאוחד

בואו נראה כיצד נראה המבנה הכללי של קובץ הקונפיגורציה שמאחד את כל חלקי הפאזל. הקובץ מגדיר את נקודת הכניסה של האפליקציה, את תיקיית הנכסים הסטטיים של ממשק המשתמש, ואת כל הקישורים לשירותי הנתונים וה-AI. 
name = "vibe-fullstack-app"
main = "src/index.ts"
compatibility_date = "2026-03-19"

# 1. Frontend: הגדרת נכסים סטטיים (Static Assets)
[assets]
directory = "./public"
binding = "ASSETS"

# 2. Database: קישור למסד הנתונים SQLite (D1)
[[d1_databases]]
binding = "DB"
database_name = "vibe-production-db"
database_id = "YOUR_D1_DATABASE_ID_GOES_HERE"

# 3. Cache & Secrets: קישור ל-Workers KV (Key-Value)
[[kv_namespaces]]
binding = "KV_STORE"
id = "YOUR_KV_NAMESPACE_ID_GOES_HERE"

# 4. Generative AI: קישור מובנה ל-Workers AI ללא מפתחות API
[ai]
binding = "AI"
בקונפיגורציה הזו, הגדרנו ארבעה סוגי קישורים שונים. ה-[assets] מורה ל-Wrangler (כלי הפיתוח והפריסה הרשמי של Cloudflare) להעלות את כל הקבצים שבתיקיית public ישירות ל-CDN הגלובלי. קבצים אלו יוגשו בחינם ובאופן בלתי מוגבל. ה-[[d1_databases]] מקשר בין מסד הנתונים SQL שלנו לקוד תחת השם DB. ה-[[kv_namespaces]] יוצר גישה לזיכרון ה-Key-Value המהיר תחת השם KV_STORE, והבלוק [ai] מאפשר לנו להריץ מודלי שפה מקומיים כמו Llama 3.1 ישירות על גבי המעבדים הגרפיים (GPUs) של Cloudflare בקצה, תחת הקישור AI.

איך צורכים את הקישורים האלה בקוד?

היופי בקומפוזיציית הקישורים הוא המעבר החלק לקוד. נשתמש ב-Hono, מסגרת עבודה (Framework) קלת-משקל ומהירה במיוחד המותאמת אישית לסביבות קצה (Edge), כדי לקבל את הטיפוסים החזקים (TypeScript Types) של הקישורים שלנו וליהנות מהשלמה אוטומטית של קוד בזמן הפיתוח. בואו נבחן דוגמה מעשית של נתיב (API Route) המשלב את כל המשאבים יחד: 
import { Hono } from 'hono';

// הגדרת הטיפוסים של הקישורים שלנו לצורך השלמה אוטומטית (IntelliSense)
type Env = {
  DB: D1Database;
  KV_STORE: KVNamespace;
  AI: Ai;
};

const app = new Hono<{ Bindings: Env }>();

app.post('/api/summarize', async (c) => {
  // 1. קריאה מתוך KV לבדיקה האם התכונה מאופשרת במערכת
  const isAiEnabled = await c.env.KV_STORE.get('feature_ai_enabled');
  if (isAiEnabled !== 'true') {
    return c.json({ error: 'AI service temporarily disabled' }, 503);
  }

  // 2. קריאה ממסד הנתונים D1 (SQLite) לשליפת המאמר האחרון
  const { results } = await c.env.DB.prepare(
    "SELECT id, title, content FROM articles ORDER BY created_at DESC LIMIT 1"
  ).all();

  const latestArticle = results[0];
  if (!latestArticle) {
    return c.json({ error: 'No articles found to summarize' }, 404);
  }

  // 3. שימוש ב-Workers AI להפקת סיכום מהיר באמצעות Llama 3.1 8B
  const aiOutput = await c.env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
    prompt: `Summarize the following article in two sentences: ${latestArticle.content}`
  });

  return c.json({
    article_id: latestArticle.id,
    title: latestArticle.title,
    summary: aiOutput
  });
});

export default app;
שימו לב לקלות הביצוע: אין כאן אף קריאת fetch() חיצונית עם כותרי אבטחה (Headers), אין מפתחות API של OpenAI או Supabase, ואין צורך באתחול דרייברים מורכבים של מסדי נתונים. הכל פשוט זמין דרך c.env. הדבר לא רק מקל על כתיבת הקוד (מושלם עבור פיתוח מונחה AI שבו קל ל-LLM לעבוד עם ממשקים נקיים כאלו), אלא גם מבטיח ביצועים אולטרה-מהירים מאחר וכל התקשורת בין ה-Worker ל-D1, KV ו-AI מתבצעת בתוך הרשת הפנימית המאובטחת של Cloudflare ללא מעבר ברשת האינטרנט הציבורית.
משימה מהירה: חיווט ראשון והרצה מקומית 10 דקות

כדי להרגיש את כוחה של קומפוזיציית הקישורים, נקים כעת פרויקט מקומי מינימלי ונריץ אותו בסביבת הפיתוח המקומית המדמה את שירותי הענן של Cloudflare באופן מלא בעזרת Miniflare.

  1. פתחו את הטרמינל בתיקייה חדשה והריצו את הפקודה להתקנת Wrangler (אם אינו מותקן): 
    npm install -g wrangler
  2. צרו קובץ חדש בשם wrangler.toml והדביקו בתוכו את התוכן הבא (נשתמש בקישורי D1 ו-KV מקומיים בלבד, ללא צורך בהקמתם בענן בשלב זה): 
    name = "vibe-compose-demo"
main = "index.js"
compatibility_date = "2026-03-19"

[[kv_namespaces]]
binding = "DEMO_KV"
id = "fake-local-kv-id"

[[d1_databases]]
binding = "DEMO_DB"
database_name = "demo-db"
database_id = "fake-local-d1-id"
  3. צרו קובץ בשם index.js והדביקו בו את קוד ה-Worker הפשוט הבא: 
    export default {
  async fetch(request, env) {
    // כתיבה וקריאה מ-KV מקומי
    await env.DEMO_KV.put("last_access", new Date().toISOString());
    const lastAccess = await env.DEMO_KV.get("last_access");

    // יצירת טבלה ושאילתה ב-D1 מקומי (SQLite)
    await env.DEMO_DB.exec(`
      CREATE TABLE IF NOT EXISTS logs (id INTEGER PRIMARY KEY, message TEXT);
    `);
    await env.DEMO_DB.prepare("INSERT INTO logs (message) VALUES (?)").bind("Hello Vibe Coders!").run();
    
    const { results } = await env.DEMO_DB.prepare("SELECT * FROM logs").all();

    return new Response(JSON.stringify({
      message: "Bindings work perfectly!",
      kv_last_access: lastAccess,
      db_records: results
    }), {
      headers: { "content-type": "application/json" }
    });
  }
};
  4. הריצו את פקודת הפיתוח המקומית בטרמינל: 
    wrangler dev
    הטרמינל יציג לכם כתובת מקומית (למשל, http://localhost:8787). פתחו אותה בדפדפן.

פלט נראה לעין שתסיים איתו: בדפדפן יתקבל קובץ JSON המציג את תאריך הגישה שנשמר בתוך ה-KV המקומי שלכם, לצד רשומות שהוכנסו ונשלפו בהצלחה ממסד הנתונים D1 המקומי שנוצר אוטומטית על המחשב שלכם, ללא צורך בהגדרת שרתי SQL חיצוניים.

שליטה במגבלות החינמיות של הקישורים

כאשר משתמשים בקומפוזיציה של מספר שירותים, חשוב מאוד להבין את נקודות התורפה של המגבלות החינמיות (Free Tier quotas) של כל קישור כדי להימנע מהפתעות או מהשבתה פתאומית של האפליקציה:
שם הקישור מכסה יומית חינמית (Free Tier) מתי תצטרכו לשלם? (Overage / Pay-or-Not)
Workers Compute 100,000 בקשות ביום, מקסימום 10ms זמן מעבד (CPU time) לריצה. מעבר לתוכנית Workers Paid בעלות של 5$ לחודש. נדרש אם תרוצו מעל 100k בקשות ביום או אם תבצעו פעולות כבדות של עיבוד נתונים או פיענוח JSON מסיבי שיחרגו מ-10ms זמן מעבד אמיתי.
Workers KV 100,000 פעולות קריאה ביום, 1,000 פעולות כתיבה ביום, 1GB נפח אחסון. מגבלת 1,000 פעולות הכתיבה ביום היא החומה הראשונה שנתקלים בה. אם האפליקציה שלכם כותבת נתוני סשן או אנליטיקה ל-KV בכל בקשה של משתמש, תגיעו לתקרת התשלום מהר מאוד ותאלצו לעבור למסלול ה-Paid שמספק מיליון כתיבות בחודש.
D1 Database 5 מיליון שורות קריאה (Rows Read) ביום, 100,000 שורות כתיבה (Rows Written) ביום, 5GB נפח אחסון כולל. היזהרו משאילתות לא יעילות (ללא אינדקסים או עם SELECT * ללא הגבלה), שכן הן מבצעות סריקת טבלה מלאה (Full Table Scan) ומבזבזות את מכסת ה-5 מיליון קריאות במהירות. חריגה מהמכסה תגרום ל-API להחזיר שגיאה (Error) מיידית במקום להיכשל בשקט.
Workers AI 10,000 נוירונים (Neurons - יחידת חישוב מנורמלת של GPU) ביום עבור מודלים מאוחסנים (Hosted Models). מספיק לכ-350 קריאות למודל Llama 3.1 8B ביום. שימו לב: מודלים המופנים לשירותים חיצוניים (Proxied Models דרך AI Gateway) אינם נהנים ממכסה חינמית ומחויבים ישירות דרך צד שלישי (כמו OpenAI/Anthropic).
הבנת המגבלות הללו מאפשרת לכם לתכנן נכון את הארכיטקטורה שלכם: השתמשו ב-KV בעיקר עבור קריאות תכופות של הגדרות מערכת (שם תקבלו 100,000 קריאות בחינם), והימנעו מכתיבות חוזרות ונשנות אליו. שמרו את המידע הדינמי והטרנזקציונלי ב-D1, וודאו שאתם מגדירים אינדקסים (Indexes) מתאימים על עמודות השאילתה שלכם כדי לשמור על מדד שורות הקריאה נמוך ככל האפשר. בעזרת ניהול קפדני זה, תוכלו להריץ אפליקציות Full-Stack שלמות ומתוחכמות, המחוטבות לחלוטין תחת קובץ wrangler.toml יחיד, מבלי להוציא אפילו דולר אחד מהכיס.
בינוני5 דקותחינםcode

ראוטינג אלגנטי עם Hono: תעבורת API, Middleware וטיפול ב-Static Assets

ריצו את פקודת ההתקנה של ה-CLI הרשמי create-cloudflare (המכונה c3) כדי לייצר פרויקט חדש: 
npm create cloudflare@latest vibe-hono-app -- --framework=hono
פלט צפוי בטרמינל: כלי ההתקנה ישאל אתכם מספר שאלות. בחרו ב-TypeScript, ואשרו התקנה של Wrangler במידה ותתבקשו.
  • עברו לתיקיית הפרויקט החדשה שנוצרה: 
    cd vibe-hono-app
  • צרו תיקייה חדשה בשם public בשורש הפרויקט שבה נשמור את קבצי ה-Frontend הסטטיים שלנו: 
    mkdir public
  • צרו קובץ חדש בשם public/index.html והדביקו בתוכו את קוד ה-HTML וה-JavaScript הבא: 
    <!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
    <meta charset="UTF-8">
    <title



    מתקדם5 דקותחינםintegration
    

    חיווט מנוע ה-RAG לתוך ה-SaaS: חיבור Workers AI, Vectorize ו-D1
    
` div, right after the `
    פלט נראה לעין שתסיים איתו: ...
    ` element.
    Let's place:
    ``

19. **Strict HTML Tags Checks**:
    - No ``, ``, ``, ``, ``, ``, ``, `
    `, `
    `.
    - No `
    `.
    - Inner headings must be `
    `.
    - Let's double check if my content has any `
    `. No, I will use `
    ` for subheaders inside.
    - Double check CSS classes: only double quotes, no chaining. `class="do-now"`, `class="exercise"`.
    - Let's make sure every callout starts with `...`.
    - Check the `do-



    בינוני5 דקותחינםsecurity
    

    גידור אבטחתי ב-$0: שילוב Turnstile ו-Zero Trust Access
    

    החליפו את התוכן של הקובץ src/index.ts בקוד הבא. זכרו להחליף את המחרוזת YOUR_SITE_KEY במפתח הציבורי שהעתקתם בשלב 1:
    
      
    import { Hono } from 'hono'

    const app = new Hono<{ Bindings: { TURNSTILE_SECRET_KEY: string } }>()

    // 1. הגשת דף הבית עם הטופס והווידג'ט של Turnstile
    app.get('/', (c) => {
      return c.html(`
        <!DOCTYPE html>
        <html lang="he" dir="rtl">
        <head>
          <meta charset="UTF-8">
          <title>הגנה הרמטית ב-$0</title>
          <script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>
          <style>
            body { font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 10



    מתקדם5 דקותחינםobservability
    

    ניטור, לוגים ו-Observability: הטמעת Analytics Engine ללא עלות
    

    כשאתם משיקים אפליקציית בינה מלאכותית (AI) לשוק, האתגר הגדול ביותר שלכם אינו כתיבת הקוד, אלא ההבנה של מה שקורה מאחורי הקלעים בזמן אמת. ללא מערכת ניטור עמוקה (Observability), אתם מגששים באפילה: כמה בדיוק עולה לכם כל משתמש? אילו מודלים מניבים שגיאות? והאם מישהו מנצל את ה-API שלכם לרעה ומרוקן לכם את הארנק? עבור מפתחי Vibe, הכלים המסורתיים כמו Datadog או New Relic הם מורכבים מדי, יקרים בטירוף ודורשים הגדרות שרתים מפותלות. כאן נכנסת האקוסיסטם החינמי של Cloudflare, המציעה פתרון ניטור מובנה בקצה (Edge) ללא עלות נוספת.
    


    הכלי הראשון בארסנל שלנו הוא AI Gateway (שער בינה מלאכותית). זהו פרוקסי (Proxy — שרת מתווך) חכם שיושב בין האפליקציה שלכם לבין ספקי ה-LLM (כמו OpenAI, Anthropic, או מודלים מקומיים של Cloudflare). במקום לפנות ישירות ל-API של OpenAI, אתם משנים את כתובת היעד (Endpoint) לזו של ה-AI Gateway שלכם. מרגע זה, כל בקשה מתועדת אוטומטית. ה-Gateway מספק לכם ממשק ניהול (Dashboard) ויזואלי מקיף המציג את כמות הטוקנים (Tokens) שנצרכו, עלויות מוערכות, זמני תגובה (Latency), ואחוזי שגיאות. הוא מגיע עם מנגנון זיכרון מטמון (Caching) מובנה שחוסך כסף על שאילתות זהות ומערכת הגבלת קצב (Rate Limiting) כדי למנוע מתקפות מניעת שירות (DDoS). התוכנית החינמית מאפשרת לשמור עד 100,000 לוגים יציבים (Persistent Logs) בכל החשבון — כלי מושלם לשלבי ה-Bootstrap הראשונים.
    


    הכלי השני, המיועד למדדים מותאמים אישית, הוא Workers Analytics Engine (מנוע אנליטיקה מבוסס זמן). זהו מסד נתונים ייעודי לסדרות עתיות (Time-series database) המובנה ישירות בתוך ה-Worker שלכם. בניגוד למסדי נתונים רגילים, הוא מותאם לכתיבה מהירה במיוחד של מיליוני נקודות מידע (Data Points) ללא השפעה על ביצועי האפליקציה. אתם יכולים לשלוח אליו מדדים מותאמים אישית מתוך הקוד — למשל, כמות ה-Neurons (ניורונים — יחידת המידה של Cloudflare לחישוב ביצועי GPU של מודלים מקומיים) שנצרכו בבקשה ספציפית, מזהה המשתמש, ושם המודל שבו נעשה שימוש. לאחר מכן, תוכלו לתשאל את הנתונים הללו באמצעות שאילתות SQL סטנדרטיות ישירות מתוך ממשק הניהול או דרך ה-API של Cloudflare כדי ליצור דוחות כספיים וביצועיים מדויקים. התוכנית החינמית מציעה עד 100,000 כתיבות ביום ו-10,000 שאילתות קריאה ביום ללא תשלום, מה שמאפשר לכם לבנות פאנל ניטור עצמאי לחלוטין.
    


    
הקמת AI Gateway בחצי דקה 5 דקות

    כדי להתחיל לנטר את כל שיחות ה-AI שלכם, הקימו שער פרוקסי ייעודי:
    

      
  
    1. היכנסו ללוח הבקרה של Cloudflare, ובסרגל הצד בחרו ב-AI Gateway.
      2. 
  
    2. לחצו על Add Gateway, העניקו לו את השם vibe-core-gateway, והגדירו את ה-URL שלו.
      3. 
  
    3. בתוך הגדרות ה-Gateway, הפעילו את כפתורי ה-Log Responses וה-Cache Responses. כעת, העתיקו את כתובת ה-API הייחודית שלכם והשתמשו בה כ-baseURL בקוד ה-OpenAI SDK שלכם במקום הכתובת הרגילה. כל בקשה שתשלחו תופיע מיד בגרפים בלוח הבקרה!
      4. 

    

    


    אבטחה וניטור בקצה: הגנה על ה-API ומעקב אחר עלויות
    

    כדי למנוע מבוטים זדוניים לנצל את נקודות הקצה של ה-AI שלכם (מה שעלול לרוקן את מכסת ה-Neurons החינמית שלכם במהירות), חובה להטמיע מערכת אימות חכמה. Cloudflare Turnstile הוא תחליף CAPTCHA חכם וידידותי למשתמש שעובד ברקע ללא צורך בפתירת פאזלים מעצבנים. על ידי שילוב של אימות Turnstile בצד השרת (כחלק מה-Middleware של ה-Worker), אתם מבטיחים שרק משתמשים אנושיים אמיתיים מסוגלים להפעיל את מודלי ה-AI שלכם. בנוסף, עבור דפי הניהול הפנימיים שלכם (כמו נתיב ה-/admin שבו אתם צופים במטריקות), כלי ה-Zero Trust Access של Cloudflare מאפשר לנעול את הנתיב מאחורי הזדהות מבוססת Google או GitHub מבלי לכתוב שורת קוד אחת של מערכת משתמשים.
    


    
גידור ה-SaaS: אבטחה וניטור ב-$0 30 דקות

    בתרגיל זה נבנה פרויקט מאובטח מאפס בעזרת קוד מלא. נבדוק את סביבת העבודה, ניצור פרויקט Hono, נשלב אימות Turnstile מובנה, נגן על נתיב ניהול, ונכתוב נתונים אנליטיים ישירות ל-Analytics Engine בכל פעם שמתבצעת קריאת AI.
    

      
  
    1. 
    
      צעד 1: הכנת סביבת העבודה והתחברות לחשבון
      
    
      פתחו את ממשק השורה (Terminal) ובצעו את הבדיקות וההתקנות הבאות כדי לוודא שכל הכלים מותקנים ומעודכנים:
      
    
      # 1. בדקו שגרסת Node.js מותקנת (נדרשת גרסה 18 ומעלה)
node -v
# פלט צפוי: v18.x.x או v20.x.x ומעלה. אם לא מותקן, הורד מאתר nodejs.org

# 2. התקינו את כלי ה-CLI הרשמי של Cloudflare (Wrangler) באופן גלובלי
npm install -g wrangler
# פלט צפוי: תהליך התקנה שבסופו מופיעה גרסת Wrangler

# 3. התחברו לחשבון ה-Cloudflare שלכם דרך ה-CLI
wrangler login
# פלט צפוי: ייפתח חלון דפדפן המבקש אישור גישה. לאחר האישור, הטרמינל יציג: Successfully logged in!
      
  
      2. 
  
    2. 
    
      צעד 2: יצירת פרויקט Worker חדש מבוסס Hono
      
    
      ניצור פרויקט חדש באמצעות כלי הפיגומים של Cloudflare:
      
    
      # יצירת פרויקט חדש המבוסס על שלד Hono המהיר
npm create cloudflare@latest vibe-secure-app -- --framework=hono
# פלט צפוי: תהליך הורדה והתקנה אוטומטי של תלויות. לחצו Enter לכל שאלות ברירת המחדל.

# כנסו לתיקיית הפרויקט שנוצרה
cd vibe-secure-app
      
  
      3. 
  
    3. 
    
      צעד 3: הגדרת קובץ ההגדרות של ה-Worker לחיבור ה-Analytics Engine
      
    
      פתחו את קובץ ה-wrangler.toml בתיקיית השורש של הפרויקט שלכם, ומחקו את תוכנו. הדביקו את התוכן הבא במלואו כדי להגדיר את קישור האנליטיקה (Binding):
      
    
      name = "vibe-secure-app"
main = "src/index.ts"
compatibility_date = "2026-03-19"

# חיבור ה-Worker למנוע האנליטיקה לצורך שמירת נתונים
[[analytics_engines]]
binding = "ANALYTICS_ENGINE"
dataset = "ai_usage_metrics"
      
  
      4. 
  
    4. 
    
      צעד 4: כתיבת קוד האפליקציה המאובטח
      
    
      פתחו את הקובץ src/index.ts והחליפו את כל תוכנו בקוד המלא הבא. קוד זה מכיל דף נחיתה אינטראקטיבי המציג טופס עם Turnstile, מנגנון אימות בצד השרת, הדמיית הפעלת מודל AI וכתיבה של צריכת ה-Neurons שלכם ישירות לתוך ה-Analytics Engine:
      
    
      import { Hono } from 'hono';

type Bindings = {
  ANALYTICS_ENGINE: {
    writeDataPoint: (data: {
      blobs?: string[];
      doubles?: number[];
      indexes?: string[];
    }) => void;
  };
};

const app = new Hono<{ Bindings: Bindings }>();

// 1. דף הבית המציג טופס אינטראקטיבי עם יישומון Turnstile מובנה
app.get('/', (c) => {
  return c.html(`
    <!DOCTYPE html>
    <html lang="he" dir="rtl">
    <head>
      <meta charset="UTF-8">
      <title>Vibe AI Portal</title>
      <script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>
      <style>
        body { font-family: system-ui, sans-serif; background: #f3f4f6; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        .card { background: white; padding: 2rem; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); width: 350px; text-align: center; }
        button { background: #0070f3; color: white; border: none; padding: 0.75rem 1.5rem; border-radius: 4px; cursor: pointer; width: 100%; margin-top: 1rem; }
      </style>
    </head>
    <body>
      <div class="card">
        <h3>שער ייצור תוכן AI מאובטח</h3>
        <p>אנא אשרו שאינכם בוט כדי להמשיך:</p>
        <form action="/api/generate" method="POST">
          <!-- מפתח האתר הבדיקתי של Turnstile (מיועד לפיתוח מקומי) -->
          <div class="cf-turnstile" data-sitekey="1x00000000000000000000AA"></div>
          <button type="submit">הפעל מודל AI</button>
        </form>
      </div>
    </body>
    </html>
  `);
});

// 2. נתיב ה-API המאובטח שמבצע אימות ל-Turnstile ושולח אנליטיקה
app.post('/api/generate', async (c) => {
  const body = await c.req.parseBody();
  const token = body['cf-turnstile-response'];

  if (!token) {
    return c.text('אימות נכשל: ה-Token של Turnstile חסר!', 400);
  }

  // אימות ה-Token מול שרתי Cloudflare
  const formData = new FormData();
  formData.append('secret', '1x0000000000000000000000000000000AA'); // מפתח סודי בדיקתי
  formData.append('response', token as string);

  const verifyResponse = await fetch('https://challenges.cloudflare.com/turnstile/v0/siteverify', {
    method: 'POST',
    body: formData
  });

  const outcome = await verifyResponse.json() as { success: boolean };

  if (!outcome.success) {
    return c.text('האימות נכשל! זוהתה פעילות חשודה של בוט.', 403);
  }

  // דימוי הרצת מודל AI וצריכת Neurons
  const simulatedNeuronsUsed = 450; 
  const modelName = 'llama-3.1-8b-instruct';

  // כתיבת הנתונים האנליטיים ישירות לתוך ה-Analytics Engine
  if (c.env.ANALYTICS_ENGINE) {
    c.env.ANALYTICS_ENGINE.writeDataPoint({
      blobs: [modelName, 'success'], // נתונים טקסטואליים
      doubles: [simulatedNeuronsUsed], // ערכים מספריים (מדד הניורונים)
      indexes: ['user-session-123'] // מפתח אינדקס לחיפוש מהיר
    });
  }

  return c.json({
    status: 'success',
    message: 'תוכן ה-AI נוצר בהצלחה!',
    neuronsConsumed: simulatedNeuronsUsed,
    analyticsLogged: true
  });
});

// 3. נתיב הניהול המוגן (באמצעות Cloudflare Zero Trust Access בקונפיגורציית הענן שלכם)
app.get('/admin', (c) => {
  // בזמן ריצה בענן, Cloudflare Access מזריק כותרת אימות (JWT Assertion) לנתיבים מוגנים
  const accessIdentity = c.req.header('Cf-Access-Authenticated-User-Email') || 'סביבת פיתוח מקומית';
  
  return c.html(`
    <div style="font-family: sans-serif; padding: 2rem; direction: rtl;">
      <h3>פאנל ניהול ואבטחה - גישה מוגנת</h3>
      <p>שלום, <strong>${accessIdentity}</strong>. יש לך הרשאת גישה לנתיב הניהול של האפליקציה.</p>
      <p>כדי לראות את האנליטיקה, הרץ שאילתת SQL בממשק הניהול של Cloudflare על הטבלה <code>ai_usage_metrics</code>.</p>
    </div>
  `);
});

export default app;
      
  
      5. 
  
    5. 
    
      צעד 5: פריסת האפליקציה לענן של Cloudflare
      
    
      נבצע פריסה מהירה ישירות לקצה העולמי כדי לבדוק את התוצאות בשידור חי:
      
    
      # הרצת פקודת הפריסה המובנית של Wrangler
npx wrangler deploy
# פレット צפוי: ה-Worker ייבנה במהירות, יועלה לענן, ותקבלו כתובת URL חיה, לדוגמה:
# https://vibe-secure-app.your-subdomain.workers.dev
      
  
      6. 

    

    פלט נראה לעין שתסיים איתו: תקבלו כתובת אינטרנט חיה בעלת פרוטוקול HTTPS מאובטח. בכניסה לכתובת זו, תראו את דף הבית המציג תיבת אימות בלתי נראית של Turnstile המאשרת אתכם כבני אנוש. בלחיצה על כפתור "הפעל מודל AI", הטופס יישלח, ה-Token שלכם יאומת בשרתי Cloudflare, ותקבלו חיווי JSON המאשר שהמערכת רשמה בהצלחה 450 ניורונים במערכת האנליטיקה של ה-Analytics Engine שלכם ללא שום עלות כספית!
    


    



    מתקדם5 דקותחינםanalysis
    

    סדר נפילת המגבלות: מיפוי ה-Walls באפליקציות Production אמיתיות
    

    כשאתה בונה אפליקציית Full-Stack שלמה על גבי התשתית של Cloudflare, קל מאוד להסתנוור מהבטחות ה-Free Tier (המסלול החינמי). מספרים כמו "100,000 בקשות ביום" או "5 מיליון שורות קריאה ביום ב-D1" נשמעים כמו מרחב עבודה עצום וכמעט בלתי מוגבל עבור Vibe Coders שרוצים להרים מוצרים במהירות. אבל בעולם האמיתי של מוצרי Production (סביבת ייצור פעילה), המציאות מורכבת יותר. אפליקציות לא קורסות בגלל מחסור בנפח בקשות כללי; הן נתקעות בקירות ספציפיים ונסתרים של מגבלות פלטפורמה הרבה לפני שהן מתקרבות לקצה המכסה המוצהרת.
    


    כדי להתמודד עם זה, אנו משתמשים במתודולוגיה שנקראת first-limit-to-fall analysis (ניתוח המגבלה הראשונה שתיפול). זהו תהליך שבו אנחנו ממפים מראש את צווארי הבקבוק של הארכיטקטורה שלנו על פי דפוסי השימוש הצפויים של המשתמשים. במקום לשאול "כמה משתמשים האפליקציה יכולה להכיל באופן כללי?", אנחנו שואלים "איזה פרימיטיב אחסון או משאב מחשוב יגיע למגבלת ה-Free Tier שלו ראשון, ואיך זה ישפיע על חוויית המשתמש?". הבנה מדויקת של נקודות הכשל האלו מאפשרת לנו לעצב את האפליקציה בצורה חכמה, לעקוף מגבלות חינמיות באופן חוקי, ולדעת בדיוק מתי כדאי לשלוף את כרטיס האשראי ולעבור למסלול ה-$5 לחודש.
    


    הדינמיקה של ה-Walls: מפת הדרכים הנסתרת של ה-Storage
    

    בואו נפרק את פרימיטיבי האחסון המרכזיים שבהם נשתמש בתוכניות שלנו, ונבין היכן נמצאים ה"קירות" האמיתיים שלהם:
    


      
    
    • Workers KV (Key-Value Store): מאגר מפתח-ערך מבוזר ברמה הגלובלית. הוא מצוין לקריאות מהירות במיוחד (כי המידע נשמר ב-Edge - נקודות הקצה של הרשת הקרובות למשתמש), אך הוא מבוסס על מודל של Eventually Consistent (עקביות בסופו של דבר - המידע שנכתב מופץ לכל השרתים בעולם תוך כ-60 שניות, ולכן קריאה מיידית עלולה להחזיר מידע ישן). המגבלה הגדולה ביותר שלו בגרסה החינמית היא 1,000 כתיבות ביום. אם בניתם מנגנון סשנים (Sessions) או מעקב משתמשים שכותב ל-KV בכל כניסה או פעולה, אפליקציה עם 50 משתמשים פעילים בלבד תגרום לקריסת ה-Worker שלכם תוך שעות בודדות בגלל חריגה ממכסת הכתיבה.
      • 
    
    • Durable Objects (DO): אובייקטים עמידים בעלי מצב (Stateful) המבטיחים מופע יחיד ועקביות חזקה (Strong Consistency) בכל נקודה בעולם. נכון לעדכוני 2026, Cloudflare מאפשרת שימוש ב-Durable Objects מבוססי SQLite במסלול החינמי. עם זאת, כאן אנו נתקלים בצוואר בקבוק של GB-seconds (מכפלת נפח הזיכרון של האובייקט בזמן הריצה שלו). אובייקט בודד שנשאר פעיל בזיכרון במשך שעה כדי לנהל חיבור WebSocket רציף, צורך כ-460GB-s. אם יש לכם מספר חדרים פעילים במקביל, המכסה היומית החינמית של 13,000GB-s תתאדה במהירות.
      • 
    
    • D1 (Serverless SQLite Database): בסיס הנתונים הרילציוני של Cloudflare. הוא מציע 5 מיליון שורות קריאה ו-100,000 שורות כתיבה ביום במסלול החינמי. כאן הטעות הנפוצה היא חוסר הבנה של הדרך שבה D1 סופר קריאות: שאילתת SELECT פשוטה ללא סינון מתאים (כמו WHERE) על טבלה של 10,000 שורות, תיספר כ-10,000 שורות קריאה! מספר שאילתות כאלה מצד משתמשים בודדים יחסלו את המכסה היומית שלכם במהירות, ללא קשר לכמות התעבורה האמיתית לאתר.
      • 

    


    
    מטריצת בחירת פרימיטיב אחסון וזיהוי Bottlenecks
    
    שלב 1: אפיין את סוג הנתונים המרכזי של האפליקציה שלך
    
    
      
        
    • אם מדובר בנתונים סטטיים, קובצי תצורה או הגדרות מערכת שמשתנים לעיתים נדירות - בחר ב-Workers KV.
      • 
        
    • אם מדובר בנתונים מובנים (Structured Data), טבלאות משתמשים, פוסטים או קשרים רילציוניים - בחר ב-D1 SQL.
      • 
        
    • אם מדובר בקבצים גדולים, תמונות שהועלו על ידי משתמשים או גיבויים - בחר ב-R2 Object Storage.
      • 
        
    • אם מדובר בנתונים בזמן אמת הדורשים עקביות מוחלטת (כגון צ'אט קבוצתי, קואורדינטות של שחקנים או ניהול תורים מורכב) - בחר ב-Durable Objects.
      • 
    
    
    
    שלב 2: זהה את ה-Limit הראשון שיעצור אותך ב-Free Tier
    
    
    
        
            
    
                פרימיטיב
                סוג נתונים אופייני
                מגבלה חינמית קריטית
                התרחיש ששובר את המגבלה
            
    
            
        
            
    
                Workers KV
                תצורת מערכת, Feature Flags
                1,000 כתיבות ביום
                עדכון סטטוס משתמש/סשן בכל בקשת HTTP.
            
    
            
    
                D1 Database
                פרופילי משתמשים, הודעות, פוסטים
                100,000 כתיבות / 5M קריאות ביום
                הרצת שאילתות חיפוש ללא אינדקסים (Full Table Scans) על טבלאות גדולות.
            
    
            
    
                Durable Objects
                חדרי צ'אט, Real-time Collaboration
                13,000 GB-seconds ביום
                השארת חיבורי WebSockets פתוחים ללא הפסקה עבור עשרות משתמשים במקביל.
            
    
            
    
                R2 Storage
                תמונות פרופיל, מסמכים, וידאו
                10 GB שטח אחסון, 1M כתיבות Class A
                מנגנון העלאת תמונות ללא הגבלת גודל מצד המשתמשים או ביצוע סנכרון קבצים תכוף מדי.
            
    
            
    
    
    
    שלב 3: קבע את אסטרטגיית המעבר למסלול בתשלום (Pay-or-Not Decision)
    
    
      
        
    • אם האפליקציה חווה גידול קבוע אך לא מייצרת הכנסה ישירה: בצע אופטימיזציה ברמת הקוד (למשל, שמירת נתוני סשן ב-Encrypted Cookies על גבי הדפדפן במקום כתיבה ל-KV, או שימוש באינדקסים קשיחים ב-D1).
      • 
        
    • אם האפליקציה דורשת יכולות מחשוב כבדות ב-Edge (כמו עיבוד תמונות או ריצת קוד ארוכה מ-10ms CPU): שדרג מיד לתוכנית ה-$5 בחודש (Workers Paid) כדי לפתוח מגבלת CPU של עד 30 שניות לכל ריצה.
      • 
    
    

    


    כיצד למנוע "מוות פתאומי" של ה-Free Tier בקוד שלך
    

    כדי להימנע ממצבים שבהם האפליקציה שלכם ננעלת באמצע היום ומחזירה שגיאות HTTP 429 Too Many Requests או שגיאות מכסה פנימיות של Cloudflare, עליכם לאמץ תרבות פיתוח מבוססת מגבלות. כשאתם כותבים שאילתת SQL או שומרים מפתח ב-KV באמצעות Hono (פריימוורק TypeScript קל ומהיר המותאם ל-Workers), תמיד תחשבו על כמות הפעמים שהקוד הזה ירוץ תחת עומס.
    


    לדוגמה, אל תשתמשו ב-D1 בשביל לכתוב לוגים של המערכת. עבור לוגים ומטריקות, השתמשו ב-Analytics Engine של Cloudflare (מערכת ייעודית מבוססת סדרות עיתיות המאפשרת כתיבה חינמית של עד 100,000 נקודות מידע ביום). באותו אופן, אל תשתמשו ב-KV עבור נתונים שמתעדכנים לעיתים קרובות כמו מוני צפיות או עגלות קניות של משתמשים. השתמשו בזיכרון המקומי של ה-Worker (באמצעות משתנים גלובליים בריצה הנוכחית) או החזיקו את המידע בצד הלקוח (Client-side) והעלו אותו לבסיס הנתונים רק בעת ביצוע פעולה סופית של המשתמש.
    



    
    הפעלת Wrangler Local Explorer וניתוח מגבלות מקומיות 8 דקות
    
    כדי לראות בדיוק כמה משאבים האפליקציה שלכם צורכת עוד לפני שאתם מעלים אותה לרשת ומסתכנים בחסימה, נפעיל את כלי הניטור המקומי המובנה של Wrangler.
    
    
      
        
    1. וודאו שמותקנת אצלכם הגרסה העדכנית ביותר של Wrangler על ידי הרצת הפקודה הבאה במסוף שלכם:
            
      npm install wrangler@latest --save-dev
      
            
      הפלט הצפוי: עדכון החבילה והצגת מספר הגרסה העדכנית (למשל wrangler v3.x.x).
      
        
      2. 
        
    2. הריצו את שרת הפיתוח המקומי שלכם עם דגל הדפדפן המיוחד המאפשר לפתוח את ה-Local Explorer:
            
      npx wrangler dev --explore
      
            
      הפלט הצפוי: הודעה שהשרת המקומי רץ בכתובת http://localhost:8787 וקישור ישיר לפתיחת ממשק ה-Local Explorer בדפדפן שלכם בכתובת http://localhost:8788/explore.
      
        
      3. 
        
    3. פתחו את הקישור בדפדפן. בצעו מספר פעולות באפליקציה המקומית שלכם (למשל, רישום משתמש או טעינת דף), וצפו בזמן אמת בלוח הבקרה בכמות השאילתות שנשלחו ל-D1 המקומי ובכמות הכתיבות שבוצעו לסימולטור ה-KV.
      4. 
        
    4. חשבו את קצב הגידול: אם פעולה בודדת של משתמש ייצרה 5 כתיבות ל-KV ו-15 קריאות שורות ב-D1, הכפילו את המספר הזה ב-100 משתמשים פעילים כדי לראות האם תפגעו ב"קיר" החינמי תוך פחות מיום עבודה אחד.
      5. 
    
    
    
    פלט נראה לעין שתסיים איתו: דפדפן פתוח המציג את ממשק ה-Wrangler Local Explorer, ובו פירוט מדויק של כל ה-Databases המקומיים שלכם, כולל היסטוריית השאילתות האחרונות ומספר שורות ה-SQL שנצרכו בפועל בכל קליק באפליקציה.
    

    



    בינוני5 דקותpaid-considerationstrategy
    

    מטריצת ה-Pay-or-Not המלאה: מתי לשדרג ומתי להישאר ב-Free
    

    כשאתם בונים אבטיפוס (Prototype) ראשוני, התוכנית החינמית של Cloudflare מרגישה כמו קסם אמיתי. הכל עולה לאוויר במהירות, אין שרתים לנהל, והתשתית מגיבה במהירות הבזק בזכות פריסה גלובלית בטכנולוגיית V8 isolates (סביבות ריצה מבודדות וקלות משקל, הפועלות ישירות על מנוע הדפדפן ללא צורך בקונטיינרים כבדים). הארכיטקטורה הזו מעלימה לחלוטין את מה שנקרא Cold Starts (אתחול קר – העיכוב המרגיז שנוצר כשפונקציה חסרת שרת מתעוררת משינה). אבל ברגע שהאפליקציה שלכם מתחילה לראות משתמשים אמיתיים, או כשהסוכנים החכמים (AI Agents) שבניתם מתחילים לעבוד שעות נוספות, אתם עלולים להיתקל בקירות בלתי נראים. זהו הרגע שבו נכנסת לתמונה "מטריצת ה-Pay-or-Not" – הכלי שיעזור לכם להבין מתי שדרוג קטן של $5 בחודש חוסך לכם אלפי דולרים של זמן פיתוח ותקלות ייצור, ומתי אתם יכולים להישאר בתוכנית החינמית בלב שקט.
    


    הטעות הנפוצה ביותר של מפתחים מתחילים היא אי-הבנה של המושג CPU Time (זמן מעבד) לעומת Wall-clock Time (זמן שעון קיר). בתוכנית החינמית, ה-Worker שלכם מוגבל ל-10ms של CPU Time בלבד לכל הפעלה. מה זה אומר בפועל? כשאתם מבצעים קריאת fetch() ל-API חיצוני כמו OpenAI או Anthropic והשרת שלהם מתעכב 5 שניות כדי להחזיר תשובה, ה-Worker שלכם פשוט ממתין (במצב Idle). הזמן הזה אינו נספר כזמן CPU! המעבד שלכם פנוי, ולכן הבקשה לא תיחסם. עם זאת, ברגע שהתשובה מגיעה, ואתם צריכים לפענח קובץ JSON ענק, להריץ ביטויים רגולריים (Regex) מורכבים על טקסט ארוך, או לחשב לוגיקה פנימית מסובכת – השעון מתחיל לתקתק במהירות. פעולות אלו צורכות כוח עיבוד אמיתי, ואם הן יעברו את רף ה-10ms, ה-Worker שלכם יקרוס מיד ויחזיר שגיאת שרת למשתמש.
    


    נקודת כשל נוספת קשורה למגבלות האחסון ומסדי הנתונים בתוך המערכת. מסד הנתונים D1 (פתרון ה-SQLite המבוזר של Cloudflare) מעניק בתוכנית החינמית כמות נדיבה מאוד של 5 מיליון קריאות שורות ביום, אך רק 100,000 כתיבות שורות ביום. בדומה לכך, שירות ה-KV (רכיב לשמירת מפתח-ערך עם זמני תגובה מהירים במיוחד) מוגבל ל-1,000 כתיבות ביום בלבד בגרסה החינמית. אם בניתם אפליקציית סוכן AI שמתעדת כל צעד בשיחה, שומרת היסטוריית סשן או כותבת נתוני אנליטיקה בכל קליק, אתם תגיעו לתקרת הכתיבה הזו מהר מאוד, אפילו עם שלושה או ארבעה משתמשים פעילים בו-זמנית. ברגע שהמגבלה נחצית, ה-API מחזיר שגיאה קשיחה והאפליקציה פשוט מפסיקה לתפקד.
    


    מתי כדאי לשקול מעבר לתוכנית Workers Paid ($5/month)?
    

    תוכנית ה-Paid של Cloudflare, שמתחילה בעלות מינימלית של $5 לחודש בלבד, היא למעשה פוליסת הביטוח הזולה ביותר שתוכלו לקנות לפרויקט שלכם. היא פותחת מיידית את מגבלת ה-CPU ל-30 שניות כברירת מחדל (עלייה של פי 3,000 מהתוכנית החינמית!), ומאפשרת לכם להריץ סקריפטים מורכבים, לעבד קבצים גדולים, ולבצע אינטגרציות כבדות ללא חשש מקריסה. בנוסף, היא משדרגת את נפח כתיבות ה-KV ל-1 מיליון בחודש ואת כתיבות ה-D1 ל-50 מיליון בחודש, מה שמאפשר לאפליקציה שלכם לצמוח באופן אורגני מבלי לדאוג לתקציב יומי שנעלם בחצי היום.
    


    שינוי דרמטי נוסף שהתרחש לאחרונה נוגע לטכנולוגיות מתקדמות שנכנסו לשימוש מלא. החל מאפריל 2026, שירות ה-Containers של Cloudflare (הרצת קונטיינרים של Docker ישירות בקצוות הרשת) הפך לזמין לציבור הרחב (GA). שירות זה, המאפשר הרצת ספריות קוד שאינן JavaScript ומשימות עיבוד כבדות במיוחד, דורש מנוי Paid מהרגע הראשון ואינו כולל גרסה חינמית כלל. גם שירות ה-Email Service החדש, המאפשר לסוכני AI לשלוח מיילים באופן אוטונומי, מוגבל לחלוטין למשתמשי התוכנית בתשלום, בעוד שהתוכנית החינמית מאפשרת רק ניתוב וקבלת אימיילים (Email Routing) ללא יכולת שליחה אקטיבית.
    



    
  
    
    
      שירות / תכונה
      תוכנית חינמית (Free Tier)
      תוכנית בתשלום (Paid Tier - $5/mo)
      מתי זה הופך לקריטי?
    
    
      
  
    
    
      זמן מעבד (CPU Time)
      עד 10ms לבקשה
      עד 30 שניות כברירת מחדל
      בעיבוד טקסטים ארוכים, קבצי JSON גדולים או חישובים מתמטיים.
    
    
    
    
      כתיבות ל-KV Store
      1,000 כתיבות ביום
      1 מיליון כתיבות כלולות בחודש
      באפליקציות עם ניהול סשנים אקטיבי או שמירת העדפות משתמש תכופה.
    
    
    
    
      מסד נתונים D1 (כתיבה)
      100,000 שורות ביום
      50 מיליון שורות כלולות בחודש
      באפליקציות מרובות משתמשים השומרות היסטוריית צ'אט או לוגים.
    
    
    
    
      תור הודעות (Queues)
      10,000 פעולות ביום (שמירת הודעות ל-24 שעות בלבד)
      1,000,000 פעולות בחודש (שמירה של עד 14 יום)
      כאשר תהליכים א-סינכרוניים נכשלים בסוף השבוע ואתם צריכים שהמידע יישמר.
    
    
    
    
      שליחת אימייל (Email Service)
      לא זמין (0 הודעות)
      3,000 אימיילים כלולים בחודש
      כאשר סוכן ה-AI שלכם צריך לשלוח התראות או דוחות ישירות למשתמשים.
    
    
    
    
      הרצת קונטיינרים (Docker)
      לא נתמך כלל
      נתמך (מבוסס שימוש מעבד וזיכרון)
      כאשר יש צורך להריץ כלי CLI מיוחדים, קוד פייתון מורכב או ספריות בינאריות.
    
    
      

    


    
  מודל קבלת החלטת Pay-or-Not ($5 Plan Break-even)
  
    השתמשו בעץ ההחלטות המובנה הבא כדי להבין בדיוק מתי כדאי לשלוף את כרטיס האשראי ולשדרג לתוכנית ה-Paid של $5 בחודש, ומתי אפשר להישאר בגרסה החינמית בראש שקט:
    
  
  
    שאלה 1: האם ה-Worker שלכם מבצע עיבוד מידע מקומי משמעותי מעבר לשליחת בקשות (כמו מיזוג נתונים, עבודה עם קבצי זיפ או ניתוח מבני נתונים מורכבים)?
    
  
      
    
    • אם כן: שדרגו מיד. מגבלת ה-10ms CPU בתוכנית החינמית היא קשיחה. גם אם האפליקציה עובדת כרגע בבדיקות מקומיות, תחת עומס קל של נתוני אמת היא תתחיל לזרוק שגיאות Timeout ותפגע בחוויית המשתמש.
      • 
    
    • אם לא (האפליקציה רק מנתבת בקשות ל-APIs חיצוניים ומחזירה את התשובה כמו שהיא): עברו לשאלה הבאה.
      • 
  
    

  
    שאלה 2: מהו קצב כתיבת הנתונים הצפוי שלכם ל-KV (Key-Value) או ל-D1 Database בכל יום?
    
  
      
    
    • אם כתיבות ה-KV שלכם צפויות לעבור את ה-1,000 ביום, או כתיבות ה-D1 עומדות לעבור את ה-100,000 ביום: שדרגו. חריגה מהמגבלות האלו תגרום לנעילת מסד הנתונים שלכם לכתיבה עד לחצות UTC, מה שישבית את האפליקציה לחלוטין עבור כל המשתמשים החדשים.
      • 
    
    • אם האפליקציה שלכם היא בעיקר Read-Heavy (מציגה נתונים קיימים כמעט ללא כתיבות חדשות): עברו לשאלה הבאה.
      • 
  
    

  
    שאלה 3: האם אתם בונים תהליכי עבודה א-סינכרוניים קריטיים, מערכות שליחת מיילים אקטיביות, או משתמשים בקונטיינרים של Docker?
    
  
      
    
    • אם כן: שדרגו. שירותים כמו ה-Email Service החדש לשליחת הודעות, קונטיינרים להרצת קוד מורכב, או הגדרת זמן שמירה (Retention) של יותר מ-24 שעות בתורים (Queues) חיוניים ליציבות המערכת ודורשים תוכנית בתשלום כדרישת קדם (Prerequisite).
      • 
    
    • אם לא: תוכלו להישאר בתוכנית החינמית בבטחה וליהנות מרוחב פס ללא הגבלה ומביצועים מעולים בקצוות הרשת!
      • 
  
    

    


    
  בדקו את צריכת ה-CPU הנוכחית שלכם 5 דקות
  
    לפני שאתם מקבלים החלטה, בואו נבדוק כמה משאבי מערכת האפליקציה שלכם באמת צורכת כרגע בסביבת הפיתוח או הייצור.
    
  
      
    
    1. פתחו את הטרמינל (Terminal) בתיקיית הפרויקט שלכם.
      2. 
    
    2. ודאו שאתם מחוברים לחשבון ה-Cloudflare שלכם דרך ה-CLI על ידי הרצת הפקודה הבאה:
      
      wrangler login
      
    
      3. 
    
    3. לאחר ההתחברות, הריצו את פקודת המעקב בזמן אמת עבור ה-Worker הפעיל שלכם:
      
      wrangler tail
      
      הפלט יציג לכם זרם חי של בקשות נכנסות. חפשו את הפרמטר cpuTime בכל בקשה המודפסת למסך.
    
      4. 
    
    4. בצעו מספר פעולות מאמץ באפליקציה שלכם (כמו שליחת הודעה ארוכה במיוחד לצ'אטבוט או יצירת דוח). אם ה-cpuTime מראה ערכים שמתקרבים ל-8ms או 9ms, זהו הסימן הברור ביותר לכך שאתם חייבים לשדרג לתוכנית ה-Paid כדי למנוע קריסות פתאומיות.
      5. 
  
    

    



    מתקדם5 דקותpaid-considerationfinance
    

    ניתוח עלויות ב-Scale: תרחיש 1,000 DAU וחישוב ה-Break-Even של $5
    
כאשר בונים אפליקציות full-stack מודרניות בעזרת כלי AI, קל מאוד להסתחרר מהיכולת להרים מוצרים מורכבים בתוך שעות בודדות. אך הרגע האמיתי שבו ה-"Vibe" פוגש את המציאות הכלכלית מתרחש כאשר המוצר מתחיל לצבור תאוצה אמיתית ומגיע לרף של 1,000 משתמשים פעילים ביום (DAU - Daily Active Users). במצב זה, ארכיטקטורת המחשוב ללא שרתים (Serverless) מציגה את יתרונה הגדול ביותר: היא מתרחבת באופן מיידי (Scale-to-Zero), ללא צורך בניהול שרתים או דאגה מקריסות חומרה. עם זאת, כל משאב בקצה (Edge) כפוף למכסות קשיחות של המסלול החינמי. הבנת עקרונות ה-cost-at-scale estimation (הערכת עלויות בקנה מידה רחב) היא קריטית כדי למנוע השבתה פתאומית של השירות בדיוק ברגע שהוויראליות מתחילה.

בואו ננתח את המספרים היבשים של תרחיש 1,000 DAU. נניח שכל משתמש מבצע בממוצע 50 בקשות ביום לאפליקציה (שילוב של טעינת דפים, שליפת נתונים ועדכוני מצב). המשמעות היא נפח תעבורה יומי של 50,000 בקשות ל-Worker של Cloudflare. על הנייר, המסלול החינמי מעניק 100,000 בקשות ביום, כך שאנו נמצאים לכאורה בטווח הבטוח. אולם, צוואר הבקבוק האמיתי במסלול החינמי הוא מגבלת ה-10ms CPU time (זמן עיבוד מעבד של 10 מילישניות). נתון זה אינו מתייחס לזמן ההמתנה הכולל של הבקשה (Wall-clock time) – פניות לרשת (כמו קריאה ל-API חיצוני) שמתבצעות עם `await` אינן צורכות זמן מעבד. אך ברגע שה-Worker נדרש לבצע פעולות חישוביות כמו פענוח קבצי JSON כבדים, הרצת ביטויים רגולריים (Regex) על טקסטים ארוכים, או חתימה דיגיטלית של אסימוני אבטחה, מגבלת ה-10ms עלולה להיחצות במהירות ולגרור שגיאות HTTP 500 קריטיות עבור המשתמשים שלכם.


    
בדיקת זמן ריצה של ה-Worker הפעיל שלכם 5 דקות

    כדי להבין כמה קרובים אתם למגבלת ה-CPU החינמית, הריצו בטרמינל את פקודת מעקב הנתונים בזמן אמת של Wrangler עבור ה-Worker שלכם:
    

    npx wrangler tail --format pretty
    

    בצעו מספר פעולות באפליקציה החשופה לאינטרנט והביטו בפלט הטרמינל. חפשו את השדה CPU Time המופיע בכל בקשה. אם אתם רואים ערכים שמתקרבים ל-8ms או 9ms בפעולות שגרתיות, דעו כי תחת עומס של משתמשים מרובים אתם מסתכנים בחריגה מהמגבלה וחסימת בקשות.
    

    

מעבר לזמן העיבוד, הכלים המשלימים באקו-סיסטם מחזיקים במגבלות קשיחות אף יותר. ניקח לדוגמה את Workers KV (מסד נתוני המפתח-ערך הגלובלי). הוא מעניק 100,000 קריאות ביום בחינם, אך מגביל את הכתיבות (Writes) ל-1,000 פעולות ביום בלבד. אם 1,000 המשתמשים היומיים שלכם יבצעו רק פעולת כתיבה אחת ביום (כמו שמירת העדפת עיצוב, עדכון סטטוס אחרון או רישום סשן), אתם תחסמו את המכסה היומית לחלוטין כבר בשעות הבוקר. מנגד, מסד הנתונים היחסי D1 (המבוסס על SQLite) מציע נדיבות רבה יותר עם 5 מיליון קריאות שורות (Rows read) ו-100,000 כתיבות שורות ביום. אך גם כאן מסתתר מוקש: אם תכתבו שאילתת SQL לא יעילה ללא אינדקסים מתאימים, שאילתה אחת פשוטה עלולה לבצע סריקת טבלה מלאה (Full-table scan) ולצרוך 10,000 קריאות שורות בבת אחת. מספיק ש-500 משתמשים יריצו את השאילתה הזו פעם אחת כדי לחסל את כל התקציב היומי שלכם.

כאן נכנסת לתמונה נקודת האיזון של $5 (the $5 break-even point). שדרוג למסלול ה-Workers Paid בעלות של 5 דולרים בחודש אינו רק משחרר אתכם מהחרדה של השבתת האתר; הוא משנה לחלוטין את מודל העבודה מ-"מחסום קשיח" ל-"חיוב על חריגות" (Overage billing). עם השדרוג, מגבלת ה-CPU מזנקת מ-10ms ל-30 שניות כברירת מחדל, מגבלת הבקשות החודשית גדלה ל-10 מיליון בקשות כלולות (ורק 0.30$ לכל מיליון בקשות נוספות), ומכסת קריאות השורות ב-D1 מזנקת ל-25 מיליארד שורות בחודש. ההחלטה לעבור לפלאן בתשלום צריכה להתקבל ברגע שהסימולציה הכלכלית מראה כי חוויית המשתמש נפגעת כתוצאה מהמגבלות החינמיות, או כאשר עלויות הפיתוח האלטרנטיביות (כמו כתיבת קוד מורכב ומסורבל רק כדי לעקוף את מגבלת ה-KV Writes) עולות על שווי של 5 דולרים.


    חישוב עלויות ה-Scale באמצעות סימולטור
    

    כדי לקבל החלטות ארכיטקטוניות מבוססות נתונים, עלינו לבנות כלי סימולציה שיודע לקחת את מדדי השימוש המצופים שלנו, להשוות אותם מול תנאי הסף הרשמיים של Cloudflare (מעודכן ל-2026), ולייצר תחזית עלויות מדויקת כולל עלויות חריגה (Overages).
    



    
הסימולטור הכלכלי: בניית דשבורד Pay-or-Not מבוסס שימוש 30 דקות

    בתרגיל זה נבנה סימולטור קוד פתוח בקובץ JavaScript יחיד. הסקריפט יקבל פרמטרים של תנועת משתמשים (DAU), בקשות למשתמש, פעולות בסיס נתונים ושימוש ב-AI, ויפיק דוח מפורט המזהה את צוואר הבקבוק הראשון שמחייב שדרוג לפלאן ה-$5, לצד חישוב העלות הצפויה במקרה של מעבר למסלול בתשלום.
    

      

    1. 

      שלב 1: הכנת סביבת העבודה ובדיקת תנאים מקדימים
      
וודאו שמותקנת אצלכם סביבת הריצה Node.js על ידי הרצת הפקודה הבאה בטרמינל המחשב שלכם:
      

      node -v
      

      אם הפקודה אינה מזוהה, עליכם להוריד ולהתקין את Node.js מהאתר הרשמי שלהם לפני המעבר לשלב הבא. במידה והתוקנה תקינה, תראו פלט המציין את גרסת ה-Node (לדוגמה: v20.11.0).
      

      2. 

    2. 

      שלב 2: התקנת Wrangler והתחברות לחשבון (אופציונלי להמשך הפיתוח)
      
כדי לוודא שיש לכם גישה לכלי הניהול הרשמיים של Cloudflare, נתקין את Wrangler CLI באופן גלובלי ונבצע התחברות לחשבון שלכם:
      

      npm install -g wrangler && wrangler login
      

      הדפדפן שלכם ייפתח ותתבקשו לאשר את הגישה של Wrangler לחשבון ה-Cloudflare שלכם. לאחר האישור, הטרמינל יציג הודעת הצלחה: Successfully logged in!.
      

      3. 

    3. 

      שלב 3: יצירת קובץ הסימולטור הכלכלי
      
צרו תיקייה חדשה בשם cf-estimator, היכנסו אליה, וצרו קובץ חדש בשם simulator.js. העתיקו לתוכו את הקוד המלא הבא:
      

      // simulator.js - Cloudflare Free vs Paid Estimator for 2026

// הגדרת משתני נפח התנועה באפליקציה (ניתן לשנות ערכים אלו לבדיקת תרחישים שונים)
const config = {
  dau: 1000,                  // כמות משתמשים יומית פעילה
  requestsPerUser: 45,        // בקשות ל-Worker עבור כל משתמש ביום
  kvWritesPerUser: 1.5,       // כתיבות ל-KV עבור כל משתמש ביום
  kvReadsPerUser: 10,         // קריאות מ-KV עבור כל משתמש ביום
  d1ReadsPerUser: 25,         // שורות נקראות במסד נתונים D1 לכל משתמש ביום
  d1WritesPerUser: 5,         // שורות נכתבות במסד נתונים D1 לכל משתמש ביום
  aiNeuronsPerUser: 15        // נוירונים של Workers AI לכל משתמש ביום (למשל שימוש קל ב-Llama 3.1 8B)
};

function runEstimation(metrics) {
  const dailyReqs = metrics.dau * metrics.requestsPerUser;
  const dailyKvWrites = metrics.dau * metrics.kvWritesPerUser;
  const dailyKvReads = metrics.dau * metrics.kvReadsPerUser;
  const dailyD1Reads = metrics.dau * metrics.d1ReadsPerUser;
  const dailyD1Writes = metrics.dau * metrics.d1WritesPerUser;
  const dailyAiNeurons = metrics.dau * metrics.aiNeuronsPerUser;

  // הגדרת מגבלות המסלול החינמי היומיות
  const freeLimits = {
    requests: 100000,
    kvWrites: 1000,
    kvReads: 100000,
    d1Reads: 5000000,
    d1Writes: 100000,
    aiNeurons: 10000
  };

  const breaches = [];
  if (dailyReqs > freeLimits.requests) breaches.push(`Requests: ${dailyReqs.toLocaleString()} > ${freeLimits.requests.toLocaleString()}`);
  if (dailyKvWrites > freeLimits.kvWrites) breaches.push(`KV Writes: ${dailyKvWrites.toLocaleString()} > ${freeLimits.kvWrites.toLocaleString()} (קריטי!)`);
  if (dailyKvReads > freeLimits.kvReads) breaches.push(`KV Reads: ${dailyKvReads.toLocaleString()} > ${freeLimits.kvReads.toLocaleString()}`);
  if (dailyD1Reads > freeLimits.d1Reads) breaches.push(`D1 Rows Read: ${dailyD1Reads.toLocaleString()} > ${freeLimits.d1Reads.toLocaleString()}`);
  if (dailyD1Writes > freeLimits.d1Writes) breaches.push(`D1 Rows Written: ${dailyD1Writes.toLocaleString()} > ${freeLimits.d1Writes.toLocaleString()}`);
  if (dailyAiNeurons > freeLimits.aiNeurons) breaches.push(`Workers AI Neurons: ${dailyAiNeurons.toLocaleString()} > ${freeLimits.aiNeurons.toLocaleString()}`);

  console.log("=========================================");
  console.log(`  ניתוח עלויות ותרחיש עומס עבור ${metrics.dau.toLocaleString()} DAU`);
  console.log("=========================================");
  console.log(`בקשות יומיות: ${dailyReqs.toLocaleString()} / ${freeLimits.requests.toLocaleString()}`);
  console.log(`כתיבות KV יומיות: ${dailyKvWrites.toLocaleString()} / ${freeLimits.kvWrites.toLocaleString()}`);
  console.log(`קריאות D1 יומיות: ${dailyD1Reads.toLocaleString()} / ${freeLimits.d1Reads.toLocaleString()}`);
  console.log(`שימוש ב-Workers AI (נוירונים): ${dailyAiNeurons.toLocaleString()} / ${freeLimits.aiNeurons.toLocaleString()}`);
  console.log("-----------------------------------------");

  const needsUpgrade = breaches.length > 0;
  
  if (needsUpgrade) {
    console.log("🚨 סטטוס מסלול חינמי: נחסם! חרגת מהמגבלות הבאות:");
    breaches.forEach(b => console.log(`   - ${b}`));
  } else {
    console.log("✅ סטטוס מסלול חינמי: תקין. האפליקציה פועלת בטווח החינמי.");
  }

  // חישוב עלות חודשית במסלול בתשלום ($5) הכולל חריגות (Overage)
  const monthlyReqsMillions = (dailyReqs * 30) / 1000000;
  const monthlyKvWritesMillions = (dailyKvWrites * 30) / 1000000;
  const monthlyKvReadsMillions = (dailyKvReads * 30) / 1000000;
  const monthlyD1ReadsBillions = (dailyD1Reads * 30) / 1000000000;
  const monthlyD1WritesMillions = (dailyD1Writes * 30) / 1000000;
  const monthlyAiNeuronsThousands = (dailyAiNeurons * 30) / 1000;

  // עלויות בסיס וחריגה של פלאן Paid
  const basePrice = 5.00; // מחיר מינימום לפלאן Paid
  
  // חישוב עלויות חריגה מעבר למכסה הכלולה בפלאן של $5
  const reqOverage = Math.max(0, monthlyReqsMillions - 10) * 0.30;
  const kvReadOverage = Math.max(0, monthlyKvReadsMillions - 10) * 0.50;
  const kvWriteOverage = Math.max(0, monthlyKvWritesMillions - 1) * 5.00;
  const d1ReadOverage = Math.max(0, monthlyD1ReadsBillions - 25) * 0.001; // $0.001 per million rows
  const d1WriteOverage = Math.max(0, monthlyD1WritesMillions - 50) * 1.00;
  const aiOverage = Math.max(0, (dailyAiNeurons - 10000) * 30 / 1000) * 0.011; // 10k/day free, then $0.011 per 1,000 neurons

  const totalCost = basePrice + reqOverage + kvReadOverage + kvWriteOverage + d1ReadOverage + d1WriteOverage + aiOverage;

  console.log("\n=========================================");
  console.log("        תחזית עלויות חודשית לפלאן Paid");
  console.log("=========================================");
  console.log(`עלות בסיס: $5.00`);
  console.log(`חריגת בקשות: $${reqOverage.toFixed(2)} (${monthlyReqsMillions.toFixed(2)}M requests)`);
  console.log(`חריגת כתיבות KV: $${kvWriteOverage.toFixed(2)} (${monthlyKvWritesMillions.toFixed(2)}M writes)`);
  console.log(`חריגת כתיבות D1: $${d1WriteOverage.toFixed(2)} (${monthlyD1WritesMillions.toFixed(2)}M writes)`);
  console.log(`חריגת Workers AI: $${



      בינוני5 דקותחינםaudit
      

      מה לא לשים ב-Free Tier: מוצרי Beta, דפרקציות וחלופות ייצור
      
בשלב שבו האפליקציה שלכם מתחילה לקבל צורה ומחברת בין מספר שירותים, החיווט (Wiring) של כל חלקי ה-Full-Stack נראה כמעט קסום. עם זאת, כאן טמון המכשול הגדול ביותר של ה-Vibe Coder: ההנחה שכל מה שעובד על המחשב המקומי (Localhost) או בסביבת הפיתוח החינמית יעבוד באותה צורה גם כאשר משתמשים אמיתיים יתחילו להזרים תעבורה. כדי למנוע קריסה מביכה ביום ההשקה, עלינו לבצע סיווג קפדני של השירותים שלנו באמצעות "מבדק סיכוני יציבות" (GA vs Beta Risk Audit) ולעבוד לפי רשימת בדיקה מסודרת לקראת עלייה לאוויר (Production Checklist). 

שירותים הנמצאים במצב GA (כלומר General Availability — גרסה יציבה ונתמכת רשמית לציבור הרחב) מציעים רמת אמינות גבוהה והתחייבות לשירות רציף. לעומת זאת, מוצרים המוגדרים כ-Beta (גרסת ניסוי) או כאלה שנמצאים במסלול הוצאה משימוש (Deprecation) עלולים להשתנות, להתייקר או פשוט להיעלם ללא התרעה מוקדמת. דוגמה קלאסית לכך היא מודלי בינה מלאכותית ב-Workers AI. מודלים פופולריים בעבר כמו llama-3-8b-instruct או mistral-7b-instruct-v0.1 מסומנים כעת להוצאה משימוש. קוד קשיח שמפנה אליהם ישירות ייכשל ברגע שהם יוסרו לחלוטין מהשרתים, ללא כל הודעת שגיאה בזמן הפירוס (Deployment).


      צוואר הבקבוק הנסתר של Hyperdrive ומסדי הנתונים
      

      
כאשר מחברים את האפליקציה למסד נתונים חיצוני (כמו Supabase או Neon), מקובל להשתמש ב-Hyperdrive — מנהל חיבורים חכם (Connection Pooler) המותקן ישירות בקצוות הרשת (Edge) ומאפשר לקצר את זמני הגישה לבסיס הנתונים על ידי שמירת חיבורים פתוחים מראש ומטמון (Cache) לשאילתות נפוצות. בתוכנית החינמית, Hyperdrive מאפשר עד 20 חיבורים פתוחים בו-זמנית ומגביל אתכם ל-100,000 שאילתות ביום. 

      

      
המלכוד הגדול ב-Hyperdrive, המהווה הפתעה לא נעימה למפתחים רבים, הוא שכל שאילתה נספרת במניין המכסה היומית — גם אם היא הוגשה ישירות מהמטמון (Cache Hit) ולא פנתה בפועל למסד הנתונים שלכם. המשמעות היא שאפליקציה בעלת תעבורה גבוהה המבצעת קריאות תכופות לקצה בדיקה פופולרי תנצל את מכסת ה-100,000 שאילתות במהירות ותתחיל להחזיר שגיאות למשתמשים, אף על פי שבסיס הנתונים המרוחק שלכם נותר רגוע לחלוטין.

      


      מגבלות זיכרון וזמן מעבד (CPU Time) ב-Workers
      

      
כל Worker (סביבת הרצת קוד Serverless מבוססת מנוע ה-V8 של גוגל) הרץ במסלול החינמי מוגבל ל-10 מילישניות (ms) של זמן מעבד בלבד לכל הפעלה. חשוב להבין: לא מדובר בזמן ההמתנה הכולל של הבקשה (Wall-clock time). אם הקוד שלכם מבצע קריאת fetch() שלוקחת חצי שנייה לשרת חיצוני, המעבד אינו עובד בזמן ההמתנה והזמן הזה לא נספר. עם זאת, ברגע שהתגובה חוזרת ואתם מפענחים קובץ JSON ענק בגודל של 10MB או מריצים ביטויים רגולריים (Regex) מורכבים על טקסט ארוך, אתם עלולים לעבור את רף ה-10ms בקלות ולהביא לקטיעת הפעולה באופן מיידי. מעבר לתוכנית בתשלום ($5 בחודש) פותר זאת על ידי הגדלת המכסה ל-30 שניות כברירת מחדל.

      


      
טעות נפוצה: פגיעה באמינות היישום בגלל שימוש במוצרי Beta ללא חלופת כשל

      למה זה מפתה: שירותים חדשים כמו AI Search (מנגנון RAG מנוהל כרובוט סריקה) או מודלי LLM חדשים שמוכרזים כחלק מגרסאות בטא נראים נוצצים, קלים להטמעה ומציעים לפעמים שימוש חינמי נדיב מאוד בשלבי ההשקה הראשונים.
      

      למה זה טעות: שירותי בטא בתוך פלטפורמות ענן סובלים משינויי API תכופים, יציבות נמוכה יותר, ומכסות שיכולות להצטמצם מהיום למחר. הסתמכות בלעדית עליהם ללא חלופה בקוד (Fallback) תגרום לקריסת חלקי מפתח באפליקציה שלכם ברגע שהשירות יעבור שינוי או יחרוג ממגבלות זמניות.
      

      מה לעשות במקום: הגדירו מנגנון כשל חכם בקוד. השתמשו אך ורק במודלים ובשירותים המסומנים באופן רשמי כ-GA עבור פונקציונליות הליבה שלכם, ובצעו בדיקת סיכונים חצי-שנתית (Risk Audit) כדי לאתר רכיבי בטא ולעטוף אותם בלוגיקת טיפול בשגיאות שמפנה לשירות יציב ומגובה.
      

      


      ארכיטקטורת חיווט בטוחה עם Hono ו-AI Gateway
      

      
כדי להבטיח שהאפליקציה שלכם לא תקרוס כאשר מודל ספציפי יוצא משימוש או כשאתם עוברים את רף 10,000 ה-Neurons (יחידות חישוב ייעודיות ל-GPU של Cloudflare) החינמיות ביום, מומלץ להשתמש ב-Hono — מסגרת עבודה (Framework) קלה ומהירה במיוחד המותאמת ל-Workers, בשילוב עם AI Gateway (שער ניהול חכם המאפשר ניתוב, הגבלת קצב ושמירה במטמון לקריאות AI).

      

      
להלן קוד מלא המציג חיווט נכון של Worker המבצע פנייה למודל שפה מקומי ב-Cloudflare, וכולל מנגנון Fallback אוטומטי למודל גיבוי חיצוני במידה והמכסה היומית הסתיימה או שהמודל אינו זמין:

      


      import { Hono } from 'hono';

const app = new Hono();

app.post('/api/chat', async (c) => {
  // קבלת מפתח ה-API הסודי של OpenAI שהוגדר באמצעות wrangler secret put
  const openAiApiKey = c.env.OPENAI_API_KEY;
  const requestBody = await c.req.json();
  const userMessage = requestBody.message || "Hello";

  try {
    // ניסיון ראשון: שימוש ב-Workers AI המקומי והחינמי (מודל GA יציב)
    const response = await c.env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
      messages: [{ role: 'user', content: userMessage }]
    });
    
    return c.json({ source: 'cloudflare-local', text: response.response });
  } catch (error) {
    console.warn("Primary Workers AI failed or quota exceeded. Routing to fallback...", error);
    
    // ניסיון שני: שימוש ב-AI Gateway כדי לגשת ל-OpenAI כגיבוי מאובטח
    if (!openAiApiKey) {
      return c.json({ error: "Primary model failed and no fallback API key is configured." }, 500);
    }

    try {
      const fallbackResponse = await fetch(`https://gateway.ai.cloudflare.com/v1/${c.env.CF_ACCOUNT_ID}/${c.env.AI_GATEWAY_NAME}/openai/chat/completions`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${openAiApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          model: 'gpt-4o-mini',
          messages: [{ role: 'user', content: userMessage }]
        })
      });

      const fallbackData = await fallbackResponse.json();
      return c.json({ 
        source: 'fallback-openai-gateway', 
        text: fallbackData.choices[0].message.content 
      });
    } catch (fallbackError) {
      return c.json({ error: "Both primary and fallback systems failed.", details: fallbackError.message }, 500);
    }
  }
});

export default app;

      


      
טעות נפוצה: זליגת מפתחות וסודות לקבצי קוד במקום שימוש ב-wrangler secrets

      למה זה מפתה: במהלך פיתוח מהיר ואינטנסיבי (Vibe Coding), הכי נוח להדביק את מפתח ה-API של OpenAI או את מחרוזת החיבור של מסד הנתונים ישירות בתוך משתנה בקוד ה-Worker כדי "לראות שזה עובד" במהירות באופן מקומי.
      

      למה זה טעות: בעת הרצת הפקודה wrangler deploy, הקוד שלכם נארז ונשלח במלואו לשרתי הענן של Cloudflare. אם הקוד הזה נשמר במאגר גיט (Git) ציבורי או אפילו פרטי, או שהלוגים של הפירוס נחשפים, מפתחות ה-API היקרים שלכם חשופים לחלוטין לשימוש לרעה על ידי בוטים שירוקנו לכם את הארנק תוך דקות.
      

      מה לעשות במקום: לעולם אל תציבו סודות בקוד. השתמשו בפקודה wrangler secret put KEY_NAME כדי להעלות את הסודות בצורה מוצפנת ומאובטחת לחשבון שלכם. לאחר מכן, גשו אליהם דרך אובייקט הסביבה c.env ואמתו את פעולתם על ידי הרצת בדיקות מול הסביבה המרוחקת באמצעות הדגל --remote.
      

      


      
מיפוי ואבטחת סביבת העבודה שלכם 15 דקות

      בצעו כעת את השלבים הבאים כדי לנקות את הקוד שלכם מסודות גלויים ולהכין אותו לעבודה בטוחה מול הסביבה המרוחקת:
      

        
  
      1. פתחו את קובץ ה-wrangler.toml שלכם וודאו שאין בו מחרוזות חיבור רגישות או מפתחות API קשיחים.
        2. 
  
      2. הריצו בטרמינל את הפקודה הבאה כדי להגדיר את מפתח ה-API שלכם בצורה מוצפנת בענן (החליפו את הערך במפתח האמיתי שלכם):
        wrangler secret put OPENAI_API_KEY
        הפלט הצפוי: Success! Uploaded secret OPENAI_API_KEY.
        3. 
  
      3. עדכנו את קוד ה-Worker שלכם להשתמש ב-env.OPENAI_API_KEY כפי שמוצג בדוגמת הקוד למעלה.
        4. 
  
      4. הריצו בדיקת עבודה מקומית שמחוברת ישירות למשאבי הענן האמיתיים כדי לוודא שאין שגיאות הרשאה:
        wrangler dev --remote
        5. 

      

      


      
  שגרת עבודה
  
      
    
      
      
        תדירות
        פעולה
      
      
          
    
      
      
        יומי
        מעקב אחר מדדי צריכת Neurons (יחידות החישוב של Cloudflare להרצת מודלי AI) וצריכת KV writes (כתיבות למסד הנתונים המהיר) כדי לוודא שאיננו מתקרבים לקו האדום של ה-Free Tier.
      
      
      
      
        שבועי
        בדיקת ה-DAU (Daily Active Users — משתמשים פעילים יומיים) בלוח ה-Analytics של Cloudflare לצורך חיזוי נקודת השדרוג לתוכנית ה-Paid.
      
      
      
      
        חודשי
        סריקת ה-wrangler.toml והחלפת מודלי AI שנמצאים בגרסאות Beta זמניות במודלים יציבים בסטטוס GA (Generally Available — זמין לציבור הרחב) כדי למנוע נפילת קוד עקב שינויי גרסאות (Deprecation).
      
      
      
      
        לפני פריסה
        הרצת Smoke Test (בדיקת תקינות בסיסית) בסביבת עבודה מרוחקת באמצעות הפקודה wrangler deploy --dry-run או בדיקה מול סביבה זמנית.
      
      
          
  
      

      


      
  דבר אחד שכדאי לעשות עכשיו
  
      הפעולה בעלת המינוף הגבוה ביותר כרגע היא הטמעת מנגנון הגנה של Cloudflare Turnstile (שירות הגנה חינמי המונע מבוטים להריץ טפסים) על נתיב ה-RAG (Retrieval-Augmented Generation — שליפת מידע מבוססת הקשר) שלכם. בבוט אחד שיבצע לופים על ה-API שלכם עלול לחסל את מכסת ה-Neurons החינמית היומית תוך דקות ספורות. שילוב Turnstile יבטיח שרק משתמשים אמיתיים יצרכו את משאבי ה-AI שלכם.
      

      


      
  בדוק את עצמך — 5 שאלות
  
        
    
      1. מהו צוואר הבקבוק החינמי הראשון שלרוב נפגוש באפליקציית Full-Stack חיה, וכיצד ניתן לעכב את ההגעה אליו? (רמז: מכסת ה-KV Writes העומדת על 1,000 כתיבות ביום, ושימוש ב-Caching חכם בצד הלקוח או ב-D1 לנתונים משתנים)
        2. 
    
      2. מדוע מפתחי SaaS מקצועיים נמנעים משימוש במודלים שאינם GA (Generally Available) בסביבות ייצור? (רמז: מודלים אלה נוטים להשתנות מהר, לסבול מבעיות זמינות, ולבסוף להיות מוסרים מהפלטפורמה באופן שמצריך שינויי קוד דחופים)
        3. 
    
      3. כיצד קובץ הגדרות יחיד מסוג wrangler.toml פותר לנו את בעיית חיווט התשתית (Infrastructure Wiring)? (רמז: הוא מייצר bindings — קישורים קשיחים ישירים שמזריקים משאבים כמו D1 ,R2 ו-KV ישירות לתוך משתנה ה-env של ה-Worker ללא צורך במפתחות גישה בקוד)
        4. 
    
      4. מה קורה כאשר ה-Worker שלכם חורג ממגבלת ה-CPU Time (זמן עיבוד מרכזי) החינמית (10ms) וכיצד תוכנית ה-Paid ב-$5 פותרת זאת? (רמז: ה-Worker יחזיר שגיאת 500 למשתמש, בעוד שתשלום של $5 פותח את מודל ה-Unbound המאפשר ריצה של עד 50ms כסטנדרט ולעיתים אף יותר)
        5. 
    
      5. מהי הדרך הנכונה לנהל מפתחות API של שירותים צד שלישי בפרויקט Cloudflare מבלי לחשוף אותם ב-Git? (רמז: שימוש בפקודת ה-CLI של Wrangler המזריקה סודות מוצפנים ישירות לשרתי Cloudflare)
        6. 
  
      

      


      
  סיכום הפרק
  
      בפרק זה חיברנו את כל חלקי הפאזל של ארכיטקטורת Full-Stack מודרנית וחינמית על גבי התשתית של Cloudflare. ראינו כיצד קובץ wrangler.toml אחד מחזיק את כל ה-Bindings (קישורים קשיחים בין הקוד לשירותים חיצוניים) — החל מבסיס הנתונים D1, דרך אחסון קבצים ב-R2, ועד ליכולות AI מתקדמות כמו Vectorize (בסיס נתונים וקטורי) ו-Workers AI (הרצת מודלי שפה מקומית). הדבר מאפשר לנו להקים SaaS מהיר להפליא עם אפס עלויות שרתים חודשיות.
      
  
      למדנו לנתח בעיניים מפוקחות את "מטריצת ה-Pay-or-Not". הבנו בדיוק מתי המודל החינמי מספיק (עד כ-500 משתמשים יומיים פעילים) ומתי שדרוג של $5 בחודש הופך לצעד הכלכלי והטכני המשתלם ביותר, שמונע קריסה של שירותים קריטיים כמו כתיבה ל-KV או הרצת מודלי RAG (RAG — Retrieval-Augmented Generation) מורכבים.
      
  
      כעת, כשהאפליקציה שלכם באוויר, מאובטחת באמצעות Turnstile ומוכנה לקבל תנועה אמיתית, אתם מחזיקים בסט כלים של ארכיטקטים אמיתיים. בפרק הבא נצלול אל תוך עולם הניטור, האופטימיזציה של שאילתות ושימוש ב-Analytics Engine כדי להבין בדיוק כיצד המשתמשים שלכם מתנהגים בזמן אמת, ולייעל את עלויות הריצה שלכם לאפס מוחלט.
      

      


      צ'קליסט — סיכום