Backend ו-API

Backend ב-Python ו-FastAPI — ממשקי API מודרניים וסקיילביליים

‏FastAPI הוא ה-framework המוביל של Python לממשקי REST API אסינכרוניים. הוא משלב type hints מובנים של Python עם אימות אוטומטי של Pydantic, תיעוד OpenAPI שנוצר אוטומטית וביצועי ASGI דומים ל-Node.js — בלי לוותר על קריאות הקוד.

FastAPI — ה-framework המהיר ביותר של Python

‏FastAPI רץ על Uvicorn (שרת ASGI) עם Gunicorn לריבוי תהליכים בפרודקשן. ‏Dependency Injection מובנה מאפשר בדיקה מבודדת של כל שכבה בלי mocks מורכבים: אימות, ‏session של מסד הנתונים, ‏rate limiting — כל אחד מהם הוא dependency שניתן להזרקה.

תיעוד OpenAPI 3.1 נוצר אוטומטית מה-type hints — ‏Swagger UI ו-ReDoc זמינים ב-`/docs` וב-`/redoc` בסביבת פיתוח. סכמת Pydantic v2 (ולידטור מבוסס Rust) מאמתת בקשות ותגובות. כל שדה לא תקין מחזיר 422 עם הודעות שגיאה ברורות ומותאמות לשפה.

  • ‏async/await מובנה — ‏I/O לא חוסם בכל פעולות ה-DB וה-HTTP
  • ‏BackgroundTasks לפעולות אחרי התגובה (אימייל, ‏webhook, ‏log)
  • תמיכה מובנית ב-WebSocket ליכולות בזמן אמת (צ'אט, התראות)
  • ‏Rate limiting עם slowapi (מבוסס limits) — לפי IP ולפי משתמש
  • ‏CORS, דחיסה (‏gzip/brotli), ‏request ID, ‏middleware למדידת זמנים

PostgreSQL, ‏SQLAlchemy ו-Alembic

אנו משתמשים ב-SQLAlchemy 2.0 async (דרייבר asyncpg) לכל פעולות ה-DB. המודלים מוגדרים עם טיפוסי Mapped — בטוחים מבחינת טיפוסים, בלי מחרוזות. שאילתות מורכבות נכתבות ב-SQLAlchemy Core (נבדק בזמן קומפילציה) או ב-SQL טהור דרך `text()` עם bind parameters — לעולם לא באינטרפולציית מחרוזות (מניעה מלאה של SQLi).

מיגרציות Alembic נוצרות אוטומטית משינויים במודלים ונבדקות ידנית לפני היישום. לכל מיגרציה יש `upgrade()` ו-`downgrade()` שנבדקו. בפרודקשן המיגרציות רצות ב-CI לפני הפריסה — מסד הנתונים תמיד מסונכרן עם הקוד. ‏Connection pooling דרך asyncpg עם גודל pool הניתן להגדרה לכל שירות.

  • ‏Row-level locking עם `SELECT ... FOR UPDATE` לפעולות מקביליות קריטיות
  • חיפוש טקסט מלא עם pg_trgm ו-tsvector — בלי Elasticsearch למקרים פשוטים
  • ‏JSONB לנתונים חצי-מובנים עם אינדוקס GIN
  • טבלאות מחולקות (partition) לטבלאות עם מיליוני שורות (לוגים, אירועים)

מטמון Redis וסקיילביליות אופקית

‏Redis 7 משמש למטמון אפליקציה (‏TTL לכל endpoint), ל-session store (‏refresh tokens של JWT עם ביטול סלקטיבי), ל-pub/sub לאירועים בזמן אמת ולתורים למשימות רקע (‏Celery או ARQ). אסטרטגיית המטמון היא cache-aside עם ביטול תוקף מפורש — ולא TTL עיוור שעלול להגיש נתונים מיושנים.

  • אימות JWT עם access token (‏15 דקות) + ‏refresh token ב-Redis (‏7 ימים)
  • ‏Celery + broker של Redis למשימות אסינכרוניות (יצירת PDF, אימייל, ייבוא)
  • ‏endpoint ‏health check ‏`/health` עם סטטוס DB ו-Redis וגרסת הפריסה
  • לוגים מובנים ב-JSON (‏structlog) — תואם ל-Loki/Datadog/ELK

יתרונות וחסרונות

יתרונות

  • ביצועי ASGI דומים ל-Node.js ול-Go ב-I/O.
  • תיעוד OpenAPI שנוצר אוטומטית מה-type hints.
  • אימות Pydantic v2 מהיר, עם שגיאות 422 ברורות.
  • קוד קריא, ו-Python מוכרת לרוב הצוותים.

מגבלות

  • ‏Python נשארת איטית יותר מ-Go או Rust במשימות עתירות CPU.
  • ‏async/await דורש משמעת — קריאה חוסמת אחת תוקעת את כל ה-event loop.
  • אקוסיסטם צעיר יותר מ-Django ביכולות מובנות (batteries-included).
  • אין ORM או אדמין מובנים — בוחרים אותם בנפרד.

סיכום קצר

בחרו ב-FastAPI לממשקי REST API אסינכרוניים, ל-microservices ול-backend של SPA/מובייל. ליישומים קיצוניים עתירי CPU או למונוליטים עם אדמין מוכן, ‏Go או Django בהתאמה עשויים להתאים יותר.

טבלת מפרט

יכולתמגבלה / סףשימוש טיפוסי
מקביליות‏async/await, ‏I/O לא חוסםמשימות עתירות CPU דורשות workers נפרדים‏API עם הרבה קריאות DB/HTTP
השהיהendpoint שקורא ממטמון Redisגדלה עם סריאליזציה של payload גדול‏SaaS, מובייל, backend בזמן אמת
אימות ותיעוד‏Pydantic v2 + OpenAPI 3.1 אוטומטיסכמות מורכבות מאריכות את זמן ההפעלה‏API ציבוריים עם Swagger/ReDoc
עלות טיפוסיתקוד פתוח, רץ על vCPU אחדסקיילינג אופקי דורש יותר תהליכיםמ-MVP ועד פרודקשן

FastAPI לעומת חלופות

קריטריוןFastAPIDjango / Express
ביצועים אסינכרונייםמצוינים (‏ASGI מובנה)‏Django חלקי, ‏Express טוב
תיעוד OpenAPI אוטומטיכן, מה-type hintsדורש חבילות נוספות
אדמין / ORM מובניםלא (בוחרים בנפרד)‏Django: כן; ‏Express: לא

שאלות נפוצות

האם FastAPI מהיר יותר מ-Django?

כן ב-I/O. ‏FastAPI רץ באופן אסינכרוני על ASGI, ולכן מטפל בהרבה יותר בקשות מקבילות עם קריאות DB/HTTP מאשר Django הסינכרוני הקלאסי. עם זאת, ל-Django יש יותר יכולות מובנות.

למה FastAPI לא מתאים?

למשימות עתירות CPU (עיבוד תמונה, חישובים נומריים כבדים) ‏Python איטית יותר מ-Go או Rust, ולכן מעבירים אותן ל-workers נפרדים. כמו כן, אין בו אדמין מוכן כמו ב-Django.

האם FastAPI דורש ORM?

לא חובה. אנו משתמשים ב-SQLAlchemy 2.0 async עם Alembic למיגרציות, אבל אפשר לכתוב SQL טהור. ה-ORM אינו חלק מהחבילה, ולכן בוחרים אותו לכל פרויקט.

איך מבצעים סקיילינג ל-backend של FastAPI?

בצורה אופקית: מריצים כמה תהליכי Uvicorn תחת Gunicorn מאחורי load balancer, עם מטמון Redis ומשימות כבדות שמועברות ל-Celery. עיצוב stateless מאפשר להוסיף מופעים לפי הצורך.