Jak nasadíte Django aplikaci do produkce?

Question

Accepted Answer

Nasazení Django do produkce zahrnuje spuštění za řádným **WSGI/ASGI serverem** a **webovým serverem**, správné servírování statických souborů, zabezpečení nastavení a správu databáze — což je výrazně odlišné od vestavěného vývojového serveru (který **není** vhodný pro produkci).

## Produkční 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).
```

Vývojový server není vhodný pro produkci. Standardní stack: **aplikační server** (Gunicorn/uWSGI pro WSGI, Uvicorn pro ASGI/async) spouští Django s více workery, za **webovým serverem** (nginx), který zpracovává příchozí připojení, TLS a statické soubory.

## Produkční nastavení (kritické pro bezpečnost)

```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
```

## Statické soubory

```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)
```

## Databáze a migrace

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

## Typický nasazovací checklist

```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
```

## Moderní přístupy k nasazení

```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)
```

## Proč na tom záleží

Správné nasazení Django do produkce je základní znalostí pro převedení aplikací z vývoje do reálného světa a zahrnuje důležité úvahy, které se zásadně liší od místního vývoje — špatné provedení vede na bezpečnostní chyby, špatný výkon nebo nefunkční aplikace.

Rozeznání **produkčního stacku** je základem: vestavěný vývojový server (`runserver`) explicitně není určen pro produkci (je single-threaded, nezabezpečený a nemůže zvládat zátěž), takže musíte spustit Django za řádným **aplikačním serverem** (Gunicorn/uWSGI pro WSGI nebo Uvicorn pro ASGI/async) s více workery, před kterým je **webový server** (nginx) zpracovávající připojení, TLS a servírování statických souborů.

Několik aspektů je kritických z hlediska bezpečnosti a správnosti: **produkční nastavení** (zejména `DEBUG=False`, což je povinné, protože `DEBUG=True` prozrazuje citlivé traceback a konfiguraci útočníkům, navíc `ALLOWED_HOSTS`, tajný `SECRET_KEY` z prostředí a vynucování HTTPS), **práce se statickými soubory** (spuštění `collectstatic` a servírování souborů přes nginx/CDN/WhiteNoise, protože Django je v produkci sám neservíruje — to je běžná chyba nasazení) a **správa databáze** (reálná databáze jako PostgreSQL, aplikace migrací, zálohování).

Znalost nasazovacího checklistu, moderních přístupů (Docker/kontejnery, spravované platformy, cloudové úložiště pro média, Celery workers jako samostatné služby, horizontální škálování s bezstavovou aplikací) a operačních aspektů (logging, monitoring pomocí Sentry, health checks, správa procesů) je to, co odlišuje funkční produkční nasazení od křehkého nebo nezabezpečeného.

Protože každá reálná Django aplikace musí být nakonec nasazena a protože chyby při nasazení (ponechání `DEBUG=True`, špatná práce se statickými soubory, odhalení tajemství, použití vývojového serveru) způsobují opravdové problémy se bezpečností a spolehlivostí, porozumění tomu, jak správně nasadit Django — stack, nastavení kritické pro bezpečnost, práce se statickými/mediálními soubory a moderní praktiky nasazení — je důležitá, vysokorisková znalost, která odráží schopnost dodávat produkční aplikace, běžně relevantní a profesionálně nezbytné téma pro každého Django vývojáře odpovídajícího za živé systémy.