Backend Python & FastAPI — API-uri moderne și scalabile
FastAPI este framework-ul Python de referință pentru API-uri REST asincrone. Combină type hints native Python cu validare automată Pydantic, documentație OpenAPI generată automat și performanță ASGI comparabilă cu Node.js — fără a sacrifica lizibilitatea codului.
FastAPI — cel mai rapid framework Python
FastAPI rulează pe Uvicorn (ASGI server) cu Gunicorn pentru multi-process în producție. Un endpoint simplu care citește din cache Redis răspunde în sub 5ms pe hardware standard. Dependency Injection nativă permite testarea izolată a oricărui layer fără mock-uri complexe: autentificarea, database session, rate limiting — fiecare este o dependință injectabilă.
Documentația OpenAPI 3.1 se generează automat din type hints — Swagger UI și ReDoc disponibile la `/docs` și `/redoc` în development. Schema Pydantic v2 (Rust-based validator) validează request-urile și response-urile de 10–20x mai rapid decât Pydantic v1. Orice câmp invalid returnează un 422 cu mesaje de eroare clare, localizate.
- async/await nativ — I/O non-blocant pe toate operațiile DB și HTTP
- BackgroundTasks pentru operații post-response (email, webhook, log)
- WebSocket suport nativ pentru funcționalități real-time (chat, notificări)
- Rate limiting cu slowapi (bazat pe limits) — per-IP și per-user
- Middleware CORS, compression (gzip/brotli), request ID, timing
PostgreSQL, SQLAlchemy și Alembic
Folosim SQLAlchemy 2.0 async (asyncpg driver) pentru toate operațiile DB. Modelele sunt definite cu Mapped types — type-safe, fără string-uri. Query-urile complexe se scriu în SQLAlchemy Core (compile-time checked) sau SQL pur prin `text()` cu parametri bind — niciodată string interpolation (prevenție SQLi completă).
Migrările Alembic sunt auto-generate din schimbările de model și revizuite manual înainte de aplicare. Fiecare migrare are `upgrade()` și `downgrade()` testate. În producție, migrările rulează în CI înainte de deploy — baza de date este întotdeauna în sync cu codul. Connection pooling via asyncpg cu pool size configurabil per-service.
- Row-level locking cu `SELECT ... FOR UPDATE` pentru operații concurente critice
- Full-text search cu pg_trgm și tsvector — fără Elasticsearch pentru cazuri simple
- JSONB pentru date semi-structurate cu indexare GIN
- Partition tables pentru tabele cu milioane de rânduri (logs, events)
Caching Redis și scalabilitate orizontală
Redis 7 este folosit pentru cache aplicativ (TTL per-endpoint), session store (JWT refresh tokens cu revocare selectivă), pub/sub pentru events real-time și queues pentru background jobs (Celery sau ARQ). Strategia de caching este cache-aside cu invalidare explicită — nu TTL orb care poate servi date stale.
- Autentificare JWT cu access token (15min) + refresh token Redis (7 zile)
- Celery + Redis broker pentru task-uri asincrone (PDF gen, email, importuri)
- Health check endpoint `/health` cu status DB, Redis și versiune deploy
- Structurat logging JSON (structlog) — compatibil cu Loki/Datadog/ELK
Avantaje și limitări
Avantaje
- Performanță ASGI comparabilă cu Node.js și Go pe I/O.
- Documentație OpenAPI generată automat din type hints.
- Validare Pydantic v2 rapidă, cu erori 422 clare.
- Cod lizibil, Python familiar pentru majoritatea echipelor.
Limitări
- Python rămâne mai lent decât Go sau Rust pe task-uri CPU-intensive.
- async/await cere disciplină — un apel blocant blochează tot event loop-ul.
- Ecosistem mai tânăr decât Django pentru funcții batteries-included.
- Nu include ORM sau admin built-in — le alegi separat.
Verdict scurt
Alege FastAPI pentru API-uri REST async, microservicii și backend-uri pentru SPA/mobile. Pentru aplicații CPU-bound extreme sau monoliți cu admin gata făcut, Go respectiv Django pot fi mai potrivite.
Tabel de specificații
| Capabilitate | Limită / prag | Utilizare tipică | |
|---|---|---|---|
| Concurență | async/await, I/O non-blocant | CPU-bound necesită worker-i separați | API-uri cu multe apeluri DB/HTTP |
| Latență | < 5ms pe endpoint cu cache Redis | Crește cu serializarea payload-urilor mari | Checkout, coș, stocuri în timp real |
| Validare & docs | Pydantic v2 + OpenAPI 3.1 auto | Schema complexă crește timpul de pornire | API-uri publice cu Swagger/ReDoc |
| Cost tipic | Open-source, rulează pe 1 vCPU | Scalare orizontală cere mai multe procese | De la MVP la producție |
FastAPI vs alternative
| Criteriu | FastAPI | Django / Express |
|---|---|---|
| Performanță async | Excelentă (ASGI nativ) | Django parțial, Express bună |
| Docs OpenAPI automate | Da, din type hints | Necesită pachete extra |
| Admin / ORM built-in | Nu (alegi separat) | Django: da; Express: nu |
Întrebări frecvente
FastAPI este mai rapid decât Django?
Da pe I/O. FastAPI rulează async pe ASGI, deci gestionează mult mai multe cereri concurente cu apeluri DB/HTTP decât Django sincron clasic. Django are însă mai multe funcții built-in.
Pentru ce nu este potrivit FastAPI?
Pentru task-uri intens CPU-bound (procesare imagine, calcul numeric greu) Python e mai lent decât Go sau Rust; le muți pe worker-i separați. Și nu vine cu admin gata făcut precum Django.
Are FastAPI nevoie de un ORM?
Nu obligatoriu. Folosim SQLAlchemy 2.0 async cu Alembic pentru migrări, dar poți scrie SQL pur. ORM-ul nu este inclus, deci îl alegi în funcție de proiect.
Cum scalez un backend FastAPI?
Orizontal: rulezi mai multe procese Uvicorn sub Gunicorn, în spatele unui load balancer, cu cache Redis și task-uri grele mutate pe Celery. Stateless design permite adăugarea de instanțe la nevoie.