Bagaimana Anda mendeployme aplikasi Django ke production?

Question

Accepted Answer

Mendeployme Django ke production melibatkan menjalankannya di belakang **WSGI/ASGI server** yang tepat dan **web server**, melayani file statis dengan benar, mengamankan settings, dan mengelola database — sangat berbeda dari built-in development server (yang **bukan** untuk production).

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

Dev server tidak cocok untuk production. Standard stack: sebuah **application server** (Gunicorn/uWSGI untuk WSGI, Uvicorn untuk ASGI/async) menjalankan Django dengan multiple workers, di belakang **web server** (nginx) yang menangani incoming connections, TLS, dan file statis.

## Production settings (security-critical)

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

## Static files

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

## Database dan migrations

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

## Typical deployment 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 deployment approaches

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

## Mengapa ini penting

Mendeployme Django ke production dengan benar adalah pengetahuan essential untuk membawa aplikasi dari development ke penggunaan real-world, dan ini melibatkan pertimbangan penting yang berbeda secara fundamental dari local development — melakukannya dengan salah menghasilkan security vulnerabilities, poor performance, atau broken applications.

Memahami **production stack** adalah foundational: development server built-in (`runserver`) secara eksplisit bukan untuk production (single-threaded, insecure, dan tidak dapat menangani load), jadi Anda harus menjalankan Django di belakang **application server** yang tepat (Gunicorn/uWSGI untuk WSGI, atau Uvicorn untuk ASGI/async) dengan multiple workers, di depan **web server** (nginx) yang menangani connections, TLS, dan static file serving.

Beberapa aspek adalah security- dan correctness-critical: **production settings** (terutama `DEBUG=False`, yang mandatory karena `DEBUG=True` bocor sensitive tracebacks dan configuration kepada attackers, plus `ALLOWED_HOSTS`, secret `SECRET_KEY` dari environment, dan HTTPS enforcement), **static file handling** (menjalankan `collectstatic` dan melayani files via nginx/CDN/WhiteNoise, karena Django tidak melayaninya sendiri di production — sebuah common deployment failure), dan **database management** (sebuah real database seperti PostgreSQL, menerapkan migrations, backups).

Mengetahui deployment checklist, modern approaches (Docker/containers, managed platforms, cloud storage untuk media, Celery workers sebagai separate services, horizontal scaling dengan stateless app), dan operational concerns (logging, monitoring dengan Sentry, health checks, process management) adalah apa yang memisahkan working production deployment dari fragile atau insecure one.

Karena setiap real Django application pada akhirnya harus di-deploy, dan karena deployment mistakes (meninggalkan `DEBUG=True`, mishandling static files, exposing secrets, menggunakan dev server) menyebabkan real security dan reliability problems, memahami bagaimana mendeployme Django dengan benar — stack, security-critical settings, static/media handling, dan modern deployment practices — adalah important, high-stakes knowledge yang mencerminkan ability untuk ship production-ready applications, sebuah frequently-relevant dan professionally-essential topic untuk setiap Django developer yang responsible untuk live systems.