Hogyan telepítesz egy Django alkalmazást éles környezetbe?

Question

Accepted Answer

A Django telepítése éles környezetbe magában foglalja a futtatást egy megfelelő **WSGI/ASGI szerver** és **webszerver** mögött, a statikus fájlok helyes kiszolgálását, a beállítások biztonságát és az adatbázis kezelését — amely jelentősen különbözik a beépített fejlesztési szervertől (amely **nem** éles környezetre való).

## Az éles környezet stackje

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

A fejlesztési szerver alkalmatlan éles használatra. A szokásos stack: egy **alkalmazásszerver** (Gunicorn/uWSGI a WSGI-hez, Uvicorn az ASGI/aszinkron-hoz) futtatja a Django-t több worker-rel, egy **webszerver** (nginx) mögött, amely kezel bejövő kapcsolatokat, TLS-t és statikus fájlokat.

## Éles beállítások (biztonsági kritikus)

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

## Statikus fájlok

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

## Adatbázis és migrációk

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

## Tipikus telepítési ellenőrzőlista

```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 telepítési módszerek

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

## Miért számít

A Django helyes telepítése éles környezetbe létfontosságú tudás az alkalmazások fejlesztésből a valós felhasználásba való átvételéhez, és olyan szempontokat tartalmaz, amelyek alapvetően különböznek a helyi fejlesztéstől — a helytelen megvalósítás biztonsági sebezhetőségekhez, gyenge teljesítményhez vagy hibás alkalmazásokhoz vezethet.

Az **éles stack** megértése alapvető: a beépített fejlesztési szerver (`runserver`) kifejezetten nem éles használatra (egyszálú, nem biztonságos, és nem képes a terhelés kezelésére), ezért a Django-t egy megfelelő **alkalmazásszerver** (Gunicorn/uWSGI a WSGI-hez vagy Uvicorn az ASGI/aszinkron-hoz) mögött kell futtatni több worker-rel, egy **webszerver** (nginx) előtt, amely kezel kapcsolatokat, TLS-t és statikus fájlok kiszolgálását.

Néhány aspektus biztonsági és helyesség szempontjából kritikus: **éles beállítások** (különösen `DEBUG=False`, amely kötelező, mivel a `DEBUG=True` érzékeny traceback-eket és konfigurációkat fed fel a támadók felé, valamint `ALLOWED_HOSTS`, titkos `SECRET_KEY` a környezetből és HTTPS kényszerítés), **statikus fájlok kezelése** (a `collectstatic` futtatása és fájlok nginx/CDN/WhiteNoise-on keresztüli kiszolgálása, mivel a Django maga nem szolgálja ki őket éles környezetben — gyakori telepítési hiba), és **adatbázis kezelés** (valós adatbázis, mint a PostgreSQL, migrációk alkalmazása, biztonsági másolatok).

A telepítési ellenőrzőlista, modern megközelítések (Docker/containerek, felügyelt platformok, felhőalapú tárolás médiumhoz, Celery workerek külön szolgáltatásként, vízszintes skálázás állapotmentes alkalmazással) és az operatív szempontok (naplózás, monitorozás Sentry-vel, egészségügyi ellenőrzések, folyamat-kezelés) ismerete az, ami egy működő éles telepítést egy törékeny vagy nem biztonságos telepítéstől megkülönböztet.

Mivel minden valós Django alkalmazást végül telepíteni kell, és mivel a telepítési hibák (`DEBUG=True` meghagyása, statikus fájlok helytelen kezelése, titkos adatok felégetése, a fejlesztési szerver használata) valós biztonsági és megbízhatósági problémákat okoznak, a Django helyes telepítésének megértése — a stack, a biztonsági kritikus beállítások, a statikus/média kezelés és a modern telepítési gyakorlatok — fontos, nagy tétű tudás, amely a termelésre kész alkalmazások szállítására való képességet tükrözi, egy gyakran releváns és szakmailag nélkülözhetetlen téma minden olyan Django fejlesztőnek, aki felelős az éles rendszerekért.