---
title: "Cara Deploy Django + PostgreSQL ke Helipod dalam 5 Menit"
url: "https://helipod.io/blog/cara-deploy-django-ke-helipod"
date: "2026-05-02"
updated: "2026-05-02"
author: "Tim Helipod"
tags: ["django", "python", "postgresql", "tutorial", "deployment"]
excerpt: "Tutorial cara deploy Django dan PostgreSQL ke Helipod: deteksi otomatis, collectstatic, migrasi database, sampai custom domain. Tanpa Dockerfile."
---

# Cara Deploy Django + PostgreSQL ke Helipod dalam 5 Menit

Django adalah framework Python paling populer untuk membangun web application dan REST API. Tapi deploy Django ke production punya beberapa tantangan: setup `gunicorn`, konfigurasi `collectstatic`, manage `requirements.txt`, sampai koneksi database yang aman.

Helipod menyelesaikan semua ini secara otomatis.

Ketika kamu connect repository Django ke Helipod, **Helipack** mendeteksi framework, install dependencies dari `requirements.txt`, jalankan `collectstatic`, dan deploy dengan `gunicorn` sebagai server, semua tanpa konfigurasi manual.

## Yang Kamu Butuhkan

- Akun Helipod (daftar gratis di [helipod.io](https://helipod.io))
- Repository Django di GitHub atau GitLab
- File `requirements.txt` (atau `pyproject.toml` jika pakai Poetry/uv)
- Django 3.2+ (semua versi modern didukung)

## Persiapan Project Django

Sebelum deploy, pastikan beberapa hal sudah dikonfigurasi di project kamu:

### 1. Tambahkan gunicorn ke requirements

```txt
# requirements.txt
Django>=4.2
gunicorn>=21.0
psycopg2-binary>=2.9  # untuk PostgreSQL
whitenoise>=6.0       # untuk serve static files
```

### 2. Konfigurasi WhiteNoise untuk Static Files

Di `settings.py`:

```python
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',  # tambahkan ini
    # middleware lainnya...
]

STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
```

### 3. Konfigurasi Allowed Hosts

```python
import os

ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', 'localhost').split(',')

# Atau lebih simpel untuk Helipod:
ALLOWED_HOSTS = ['*']  # ganti dengan domain spesifik di production
```

### 4. Konfigurasi Database dari Environment Variable

```python
import os
import dj_database_url  # pip install dj-database-url

DATABASES = {
    'default': dj_database_url.config(
        default=os.environ.get('DATABASE_URL', 'sqlite:///db.sqlite3')
    )
}
```

Atau manual:

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME', 'mydb'),
        'USER': os.environ.get('DB_USER', 'postgres'),
        'PASSWORD': os.environ.get('DB_PASSWORD', ''),
        'HOST': os.environ.get('DB_HOST', 'localhost'),
        'PORT': os.environ.get('DB_PORT', '5432'),
    }
}
```

## Langkah 1: Tambahkan PostgreSQL Service

Login ke dashboard Helipod, buat **New Project**. Sebelum connect repo Django, tambahkan dulu service PostgreSQL dengan klik **+** di canvas dan pilih **PostgreSQL**.

Catat nama service PostgreSQL yang kamu buat, ini akan dipakai sebagai `DB_HOST`.

## Langkah 2: Connect Repository Django

Klik **+** lagi dan pilih repository Django dari GitHub atau GitLab. Helipack otomatis mendeteksi Python/Django dan menampilkan konfirmasi.

## Langkah 3: Set Environment Variables

Buka tab **Variables** pada service Django dan masukkan:

```env
SECRET_KEY=django-insecure-ganti-dengan-secret-key-yang-kuat
DEBUG=False
ALLOWED_HOSTS=nama-project.helipod.app,yourdomain.com
DATABASE_URL=postgresql://postgres:password@nama-service-postgres:5432/mydb

# Atau gunakan individual vars:
DB_HOST=nama-service-postgres
DB_PORT=5432
DB_NAME=mydb
DB_USER=postgres
DB_PASSWORD=secret

DJANGO_SETTINGS_MODULE=myproject.settings
```

> **Penting:** `DB_HOST` harus diisi dengan nama service PostgreSQL di canvas Helipod, bukan `localhost`. Semua service dalam satu project terhubung via internal network.

> **Secret Key:** Generate secret key baru dengan `python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"`.

## Langkah 4: Deploy

Klik **Deploy**. Helipack akan:

1. Clone repository
2. Detect Python/Django
3. Install dependencies (`pip install -r requirements.txt`)
4. Jalankan `python manage.py collectstatic --noinput`
5. Build Docker image
6. Deploy dengan `gunicorn` sebagai server

Pantau prosesnya di **Deployments → Build logs**.

## Dockerfile yang Dihasilkan Helipack

Ini Dockerfile optimal yang Helipack generate untuk Django:

```dockerfile
# syntax=docker/dockerfile:1
FROM python:3.12-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1

RUN apt-get update && apt-get install -y --no-install-recommends \
    curl build-essential libffi-dev libssl-dev \
    libpq-dev libpq5 \
    && rm -rf /var/lib/apt/lists/*

FROM base AS deps
WORKDIR /app
COPY requirements.txt ./
RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=secret,id=build_env,dst=/app/.env \
    pip install --no-cache-dir -r requirements.txt

FROM base AS runner
WORKDIR /app

COPY --from=deps /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
COPY --from=deps /usr/local/bin /usr/local/bin

COPY . .

RUN --mount=type=secret,id=build_env,dst=/app/.env \
    python manage.py collectstatic --noinput || true

RUN useradd --no-create-home --shell /bin/false appuser && \
    chown -R appuser:appuser /app
USER appuser

EXPOSE 8000
CMD ["gunicorn", "myproject.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "2"]
```

## Langkah 5: Jalankan Migrasi Database

Setelah status **LIVE**, buka tab **Terminal** dan jalankan:

```bash
python manage.py migrate
python manage.py createsuperuser  # opsional, untuk Django Admin
```

## Otomasi Migrasi dengan helipack.json

Agar migrasi berjalan otomatis setiap deploy, buat `helipack.json` di root repository:

```json
{
  "run": {
    "port": 8000,
    "before": "python manage.py migrate --run-syncdb"
  },
  "health": {
    "path": "/",
    "duration": 20
  }
}
```

Dengan `run.before`, command ini akan dieksekusi sebelum server Django start, setiap kali ada deployment baru.

## Menggunakan Poetry atau uv

Helipack juga mendukung package manager modern:

### Poetry

```toml
# pyproject.toml
[tool.poetry]
name = "myproject"
version = "0.1.0"

[tool.poetry.dependencies]
python = "^3.12"
Django = "^4.2"
gunicorn = "^21.0"
psycopg2-binary = "^2.9"
```

Helipack otomatis mendeteksi `pyproject.toml` + `poetry.lock` dan menggunakan `poetry install --no-interaction --no-root`.

### uv (Rekomendasi untuk Speed)

```toml
# pyproject.toml dengan uv
[project]
name = "myproject"
requires-python = ">=3.12"
dependencies = [
    "django>=4.2",
    "gunicorn>=21.0",
    "psycopg2-binary>=2.9",
]
```

uv install dependencies 10-100x lebih cepat dibanding pip.

## Konfigurasi Gunicorn Lanjutan

Default Helipack menggunakan 2 workers. Untuk production dengan traffic lebih tinggi, override di `helipack.json`:

```json
{
  "run": {
    "port": 8000,
    "command": "gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 4 --threads 2 --worker-class gthread --timeout 120"
  }
}
```

Atau gunakan **uvicorn** untuk Django async (Django 4.1+):

```json
{
  "run": {
    "command": "uvicorn myproject.asgi:application --host 0.0.0.0 --port 8000 --workers 4"
  }
}
```

## Verifikasi dan Monitoring

Buka URL aplikasi di **Settings → Networking & Domains**. Pastikan:

- Homepage load tanpa error
- Django Admin bisa diakses di `/admin/`
- Static files ter-serve dengan benar (CSS/JS tampil normal)

Pantau resource usage di tab **Metrics**: CPU, Memory, Uptime, dan Restarts tersedia real-time.

## Troubleshooting Umum

**"DisallowedHost" error**
Tambahkan domain Helipod ke `ALLOWED_HOSTS` di environment variables: `ALLOWED_HOSTS=nama-project.helipod.app`.

**"collectstatic" gagal saat build**
Pastikan `DJANGO_SETTINGS_MODULE` di-set dengan benar dan `STATIC_ROOT` sudah dikonfigurasi di `settings.py`.

**Database connection refused**
Pastikan `DB_HOST` menggunakan nama service PostgreSQL di canvas, bukan `localhost` atau IP address.

**"No module named 'psycopg2'"**
Tambahkan `psycopg2-binary` ke `requirements.txt`. Jika masih error, coba `psycopg[binary]` untuk psycopg3.

**Static files 404 setelah deploy**
Pastikan WhiteNoise sudah ditambahkan ke `MIDDLEWARE` dan `collectstatic` sudah berjalan. Cek di Build logs apakah ada error saat collectstatic.

## Kesimpulan

Deploy Django ke Helipod tidak membutuhkan pengetahuan DevOps. Helipack mengurus semua setup, dari install dependencies, collectstatic, sampai konfigurasi gunicorn, secara otomatis.

Ingin tahu lebih tentang cara Helipack bekerja untuk Python? Baca [Cara Helipack Generate Dockerfile Otomatis](/blog/helipack-dockerfile-otomatis).

Butuh setup background task dengan Celery? Baca [Panduan Internal Network Helipod](/blog/internal-network-pod-to-pod-helipod) untuk cara connect Celery worker ke Redis dan Django dalam satu project.

Punya pertanyaan? Hubungi kami di [support@helipod.io](mailto:support@helipod.io) atau bergabung ke komunitas di [hangar.helipod.io](https://hangar.helipod.io).