Bagaimanakah anda menskalakan Django pada peringkat pangkalan data?

Question

Accepted Answer

Apabila aplikasi Django berkembang, **pangkalan data** biasanya menjadi bottleneck yang pertama dan paling penting. Menskalakannya melibatkan pengoptimuman pertanyaan, pengindeksan, pengurusan sambungan, read replica, caching, dan akhirnya perubahan senibina — menangani pangkalan data ialah kerja penskalaan yang paling berkesan untuk kebanyakan aplikasi Django.

## 1. Optimumkan pertanyaan dahulu (kemenangan terbesar, termurah)

```python
# ✅ eliminate N+1 queries (the #1 issue) with select_related/prefetch_related
Book.objects.select_related("author").prefetch_related("tags")

# ✅ fetch only needed columns
Article.objects.only("title", "created_at")        # SELECT just these
Article.objects.values("title")                     # dicts, even lighter

# ✅ use database aggregation instead of Python loops
from django.db.models import Count, Sum
Author.objects.annotate(book_count=Count("books"))  # let the DB do the work
```

Pengoptimuman pertanyaan (membaiki masalah N+1, memilih hanya data yang diperlukan, menolak agregasi ke pangkalan data) biasanya memberikan peningkatan prestasi terbesar dengan usaha paling sedikit — lakukan ini sebelum menambah infrastruktur.

## 2. Tambah indeks

```python
class Article(models.Model):
    slug = models.SlugField(db_index=True)              # index a frequently-queried field
    class Meta:
        indexes = [
            models.Index(fields=["author", "-created_at"]),  # composite index for common queries
        ]
```

Indeks mempercepatkan pertanyaan yang menapis/mengisih mengikut lajur tersebut secara mendadak — penting untuk mana-mana medan yang anda kerap tanya (indeks yang hilang ialah punca biasa pertanyaan yang perlahan).

## 3. Connection pooling

```text
Reuse database connections instead of opening one per request (expensive at scale).
Use a pooler (PgBouncer for PostgreSQL) or Django's CONN_MAX_AGE for persistent connections.
```

## 4. Read replica (penghalaan pangkalan data)

```python
# route READ queries to replicas, WRITES to the primary
class PrimaryReplicaRouter:
    def db_for_read(self, model, **hints): return "replica"   # reads → replica
    def db_for_write(self, model, **hints): return "primary"  # writes → primary
# DATABASES = { "primary": {...}, "replica": {...} }
```

Read replica mengagihkan beban bacaan merentasi berbilang salinan pangkalan data (kebanyakan aplikasi adalah berat-bacaan), dengan penulisan pergi ke primary — penghala pangkalan data Django mengarahkan pertanyaan dengan sewajarnya.

## 5. Caching untuk mengurangkan beban pangkalan data

```python
# cache expensive query results (Redis) so they don't hit the DB every time
result = cache.get_or_set("expensive", lambda: expensive_query(), 3600)
```

## 6. Penskalaan lanjut (apabila yang di atas tidak mencukupi)

```text
✓ Caching layers (Redis) — biggest load reduction for read-heavy workloads
✓ Database tuning (query plans, vacuuming, configuration)
✓ Denormalization / materialized views for expensive aggregations
✓ Partitioning large tables; archiving old data
✓ Sharding (splitting data across databases) — last resort, complex
✓ Move heavy/async work to background tasks (Celery) off the request path
```

## Ukur dahulu

```text
Use Django Debug Toolbar, django-silk, slow-query logs, and EXPLAIN to find the
ACTUAL bottleneck. Optimize what's slow, not what you guess is slow.
```

## Mengapa ia penting

Menskalakan Django pada peringkat pangkalan data ialah pengetahuan peringkat senior yang kritikal kerana pangkalan data hampir selalu menjadi bottleneck utama apabila aplikasi berkembang — memahami cara menanganinya ialah apa yang membolehkan aplikasi Django mengendalikan beban dan volum data yang semakin meningkat.

Wawasan utamanya ialah penskalaan pangkalan data mengikut susunan keutamaan yang jelas, dengan intervensi yang paling berkesan dan termurah dahulu: **pengoptimuman pertanyaan** (terutamanya menghapuskan masalah N+1 dengan `select_related`/`prefetch_related`, mengambil hanya lajur yang diperlukan, dan menolak agregasi ke pangkalan data) biasanya memberikan peningkatan terbesar dengan usaha paling sedikit dan sentiasa patut didahulukan sebelum menambah infrastruktur, dan **pengindeksan yang betul** adalah penting kerana indeks yang hilang ialah punca pertanyaan perlahan yang kerap berlaku.

Di luar asas ini, memahami perkembangan teknik penskalaan — **connection pooling** (menggunakan semula sambungan pangkalan data yang mahal pada skala), **read replica dengan penghalaan pangkalan data** (mengagihkan beban bacaan merentasi salinan pangkalan data, berharga kerana kebanyakan aplikasi adalah berat-bacaan), **caching** (Redis untuk mengurangkan akses pangkalan data sepenuhnya untuk data berat-bacaan), dan akhirnya langkah yang lebih kompleks (denormalisasi, partitioning, sharding sebagai pilihan terakhir) — memberikan anda set alat untuk menangani prestasi pada setiap peringkat pertumbuhan.

Sama pentingnya ialah disiplin **mengukur dahulu** (menggunakan Django Debug Toolbar, slow-query log, dan EXPLAIN untuk mencari bottleneck sebenar dan bukannya meneka), kerana mengoptimumkan perkara yang salah membazirkan usaha.

Mengetahui perkembangan penskalaan pangkalan data ini — pengoptimuman pertanyaan dan pengindeksan dahulu, kemudian pooling/replica/caching, kemudian perubahan senibina, semuanya dipandu oleh pengukuran — ialah apa yang membezakan pembangun yang boleh memastikan aplikasi Django pantas dan boleh berskala apabila ia berkembang daripada mereka yang aplikasinya merosot di bawah beban sebenar.

Kerana pangkalan data ialah kekangan penskalaan yang paling biasa dan teknik-tekniknya berjulat daripada pembaikan pertanyaan ringkas kepada infrastruktur kompleks, memahami cara menskalakan Django pada peringkat pangkalan data secara sistematik ialah pengetahuan penting bernilai tinggi untuk membina dan mengendalikan aplikasi pengeluaran yang mesti mengendalikan pertumbuhan, menjadikannya topik yang kerap relevan untuk jurutera senior yang bertanggungjawab terhadap prestasi dan kebolehskalaan aplikasi.