Scaling Aplikasi Flask: Horizontal Scaling dan Caching dengan Redis

Di artikel ini, kita akan membahas secara mendalam cara scaling aplikasi Flask, dengan fokus pada Horizontal Scaling dan Caching menggunakan Redis — dua teknik paling efektif dan umum digunakan.

1. Mengapa Perlu Scaling?

Beberapa tanda bahwa aplikasi Anda perlu di-scale:

• Response time semakin lambat saat traffic naik
• Server sering mengalami high CPU atau memory usage
• Database query menjadi bottleneck
• User mengalami timeout atau error 5xx
• Ingin meningkatkan availability (high availability)

2. Vertical Scaling vs Horizontal Scaling

Kesimpulan: Untuk aplikasi Flask modern, Horizontal Scaling adalah pilihan yang lebih baik dan sustainable.

3. Horizontal Scaling untuk Flask

Untuk melakukan horizontal scaling, Anda perlu:

1. Menjalankan multiple instance aplikasi Flask
2. Menggunakan Load Balancer di depan
3. Menyimpan session dan cache di tempat terpusat (Redis)
4. Menggunakan shared database

Arsitektur Dasar Horizontal Scaling

1
User → Load Balancer (Nginx/HAProxy/Cloud)
2
         ↓
3
    [Flask App 1] [Flask App 2] [Flask App 3]
4
         ↓              ↓              ↓
5
              Redis (Cache + Session)
6
         ↓
7
    PostgreSQL / MySQL (Database)

4. Caching dengan Redis (Sangat Penting)

Redis adalah in-memory data store yang sangat cepat. Caching adalah salah satu cara paling efektif untuk meningkatkan performa aplikasi Flask.

Instalasi Redis

1
# Ubuntu/Debian
2
sudo apt install redis-server
3

4
# Atau menggunakan Docker
5
docker run -d --name redis -p 6379:6379 redis

Integrasi Redis dengan Flask

Gunakan ekstensi Flask-Caching atau redis-py:

1
pip install flask-caching redis

Contoh Penggunaan Caching

1
from flask_caching import Cache
2

3
cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': 'redis://localhost:6379/0'})
4

5
def create_app():
6
    app = Flask(__name__)
7
    cache.init_app(app)
8
    return app
9

10
@app.route('/api/posts')
11
@cache.cached(timeout=300)  # Cache selama 5 menit
12
def get_posts():
13
    posts = Post.query.all()
14
    return jsonify([post.to_dict() for post in posts])

Strategi Caching yang Baik

5. Session Management dengan Redis

Saat menggunakan multiple instance Flask, session tidak boleh disimpan di memory lokal karena user bisa diarahkan ke instance berbeda.

Solusi: Simpan session di Redis.

Konfigurasi Flask Session dengan Redis

1
from flask import Flask
2
from flask_session import Session
3
import redis
4

5
app = Flask(__name__)
6
app.config['SESSION_TYPE'] = 'redis'
7
app.config['SESSION_REDIS'] = redis.from_url('redis://localhost:6379')
8

9
Session(app)

Dengan cara ini, session user akan tersedia di semua instance Flask.

6. Load Balancer

Menggunakan Nginx sebagai Load Balancer

1
upstream flask_app {
2
    server 127.0.0.1:8001;
3
    server 127.0.0.1:8002;
4
    server 127.0.0.1:8003;
5
}
6

7
server {
8
    listen 80;
9
    server_name yourdomain.com;
10

11
    location / {
12
        proxy_pass http://flask_app;
13
        proxy_set_header Host $host;
14
        proxy_set_header X-Real-IP $remote_addr;
15
    }
16
}

Alternatif Load Balancer

• HAProxy (sangat powerful)
• Traefik (bagus untuk Docker)
• Cloud Load Balancer (AWS ALB, DigitalOcean Load Balancer, Cloudflare, dll)

7. Background Tasks dengan Celery + Redis

Untuk tugas yang berat (mengirim email, generate laporan, resize gambar), jangan jalankan di request cycle.

Gunakan Celery dengan Redis sebagai message broker.

1
pip install celery redis

Contoh Penggunaan Celery

1
from celery import Celery
2

3
celery = Celery('tasks', broker='redis://localhost:6379/0')
4

5
@celery.task
6
def send_welcome_email(user_id):
7
    # proses berat di sini
8
    pass

8. Arsitektur yang Direkomendasikan untuk Scaling

Berikut arsitektur production yang umum digunakan:

1
Internet
2
   ↓
3
Cloudflare / CDN (Static + DDoS Protection)
4
   ↓
5
Load Balancer (Nginx / Traefik / Cloud LB)
6
   ↓
7
Flask App Instances (Docker / Kubernetes)
8
   ↓
9
Redis Cluster (Cache + Session + Celery Broker)
10
   ↓
11
PostgreSQL (Primary + Read Replicas)

9. Best Practices Scaling Flask

Kesimpulan

Scaling aplikasi Flask tidak harus rumit jika dilakukan secara bertahap:

1. Mulai dengan caching menggunakan Redis (impact paling besar)
2. Pindahkan session ke Redis
3. Tambahkan multiple instance + Load Balancer
4. Gunakan Celery untuk background jobs
5. Monitor dan optimalkan secara terus-menerus

Dengan kombinasi Horizontal Scaling dan Redis Caching, aplikasi Flask Anda bisa menangani traffic yang jauh lebih tinggi dengan tetap menjaga performa dan stabilitas.

Scaling adalah proses iteratif. Mulailah dari yang paling memberikan dampak besar (caching), lalu lanjutkan ke arsitektur yang lebih kompleks sesuai kebutuhan.

Thanks for reading!

Scaling Aplikasi Flask: Horizontal Scaling dan Caching dengan Redis

Sun Jun 07 2026

614 words · 5 minutes

Teknologi flask web-development redis python

---

© Rifky Awalul Huda | CC BY-NC-SA 4.0

Share

Share this article

X (Twitter) Telegram WhatsApp LinkedIn Reddit Facebook Email Copy Link

Close

Close