Kako implementirati Django aplikaciju u produkciji?

Question

Accepted Answer

Implementacija Django-a u produkciji uključuje pokretanje iza odgovarajućeg **WSGI/ASGI servera** i **web servera**, ispravno posluživanje statičnih datoteka, osiguranje postavki i upravljanje bazom podataka — što je sasvim drugačije od ugrađenog razvojnog servera (koji **nije** za produkciju).

## Produktivni stack

```text
Client → NGINX (web server) → GUNICORN (WSGI app server) → DJANGO
           │                      (runs your Python app, multiple workers)
           └─ serves static/media files directly (efficient)

❌ NEVER use `python manage.py runserver` in production — it's single-threaded,
   insecure, and not built for load. Use Gunicorn (WSGI) or Uvicorn (ASGI for async).
```

Razvojni server nije prikladan za produkciju. Standardni stack: **aplikacijski server** (Gunicorn/uWSGI za WSGI, Uvicorn za ASGI/async) pokreće Django s više radnika, iza **web servera** (nginx) koji obrađuje dolazne veze, TLS i statične datoteke.

## Produktivne postavke (kritično za sigurnost)

```python
DEBUG = False                            # ❗ MUST be False — DEBUG=True leaks sensitive info
ALLOWED_HOSTS = ["example.com"]          # required when DEBUG=False
SECRET_KEY = os.environ["SECRET_KEY"]    # from the environment, NOT committed
SECURE_SSL_REDIRECT = True               # force HTTPS
SESSION_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
```

## Statične datoteke

```bash
python manage.py collectstatic           # gather static files into STATIC_ROOT
# then serve them via nginx or a CDN — or use WhiteNoise to serve them from the app
# (Django does NOT serve static files itself in production)
```

## Baza podataka i migracije

```bash
python manage.py migrate                  # apply migrations to the production DB
# use a real database (PostgreSQL), connection pooling, regular backups
```

## Tipična lista provjere za implementaciju

```text
1. Set production environment variables (SECRET_KEY, DB credentials, DEBUG=False)
2. Run migrations (manage.py migrate)
3. Collect static files (collectstatic) → serve via nginx/CDN/WhiteNoise
4. Run the app with Gunicorn/Uvicorn (multiple workers, behind nginx)
5. Enable HTTPS (TLS certificates, e.g. Let's Encrypt)
6. Set up logging, error monitoring (Sentry), health checks
7. Add a process manager (systemd/supervisor) or use containers (Docker) + orchestration
8. Run `manage.py check --deploy` to audit security settings
```

## Moderni pristupi implementaciji

```text
✓ Containers (Docker) + orchestration (Kubernetes) or platforms (Heroku, Railway, Render)
✓ Managed databases, separate static/media storage (S3 + CDN)
✓ Background workers (Celery) + a broker (Redis) as separate services
✓ Horizontal scaling: multiple app instances behind a load balancer (keep app STATELESS)
```

## Zašto je to važno

Ispravljanje Django-a u produkciji je ključno znanje za premještanje aplikacija iz razvoja u stvarni svijet, a uključuje važna razmatranja koja se fundamentalno razlikuju od lokalnog razvoja — greške dovode do sigurnosnih propusta, loše performanse ili neispravnih aplikacija.

Razumijevanje **produktivnog stacka** je temeljno: ugrađeni razvojni server (`runserver`) eksplicitno nije za produkciju (jednonitkast je, nesiguran i ne može rukovanje opterećenjem), pa morate pokrenuti Django iza odgovarajućeg **aplikacijskog servera** (Gunicorn/uWSGI za WSGI, ili Uvicorn za ASGI/async) s više radnika, spred **web servera** (nginx) koji obrađuje veze, TLS i posluživanje statičnih datoteka.

Nekoliko aspekata je kritično za sigurnost i ispravnost: **produktivne postavke** (posebno `DEBUG=False`, što je obavezno jer `DEBUG=True` otkriva osjetljive praćenja i konfiguraciju napadačima, plus `ALLOWED_HOSTS`, tajni `SECRET_KEY` iz okoline i forsiranje HTTPS-a), **rukovanjem statičnim datotekama** (pokretanje `collectstatic` i posluživanje datoteka preko nginx-a/CDN-a/WhiteNoise-a, jer Django sam ne posluživač u produkciji — česta greška u implementaciji), i **upravljanjem bazom podataka** (prava baza kao PostgreSQL, primjena migracija, sigurnosne kopije).

Znanje liste provjere za implementaciju, modernih pristupa (Docker/kontejneri, upravljane platforme, pohrana u oblaku za medije, Celery radnici kao odvojene usluge, horizontalno skaliranje sa bezstanjskom aplikacijom) i operativnih pitanja (bilježenje, praćenje sa Sentry-jem, provjere zdravlja, upravljanje procesima) je ono što razlikuje radnu produktivnu implementaciju od krhke ili nesigurne.

Jer svaka prava Django aplikacija na kraju mora biti implementirana, a jer greške pri implementaciji (ostavljanje `DEBUG=True`, loše rukovanje statičkim datotekama, izlaganje tajni, korištenje razvojnog servera) uzrokuju stvarne sigurnosne i pouzdanosti probleme, razumijevanje kako pravilno implementirati Django — stack, postavke kritične za sigurnost, rukovanje statičnim/medijske datotekama i moderne prakse implementacije — je važno, visoko-ulog znanje koje odražava sposobnost isporuke produktivnih aplikacija, često-relevantna i profesionalno-bitna tema za bilo kojeg Django razvojnog inženjera odgovornog za live sustave.