Kubernetes Deployment untuk Flask

Di artikel ini, kita akan membahas cara mendeploy aplikasi Flask ke Kubernetes secara lengkap dan praktis.

1. Mengapa Menggunakan Kubernetes untuk Flask?

Keunggulan Kubernetes:

Auto-scaling (Horizontal Pod Autoscaler)
Self-healing (otomatis restart container yang gagal)
Load balancing built-in
Rolling updates tanpa downtime
Service discovery & konfigurasi terpusat
Cocok untuk arsitektur microservices

Jika aplikasi Flask Anda hanya kecil-menengah, Docker + Docker Compose sudah cukup. Kubernetes lebih cocok untuk aplikasi yang kompleks dan membutuhkan skalabilitas tinggi.

2. Persiapan Docker Image

Sebelum deploy ke Kubernetes, pastikan aplikasi Flask sudah dibungkus dalam Docker image yang baik.

Contoh `Dockerfile` untuk Production

1
FROM python:3.11-slim
2

3
WORKDIR /app
4

5
COPY requirements.txt .
6
RUN pip install --no-cache-dir -r requirements.txt gunicorn
7

8
COPY . .
9

10
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "app:create_app('production')"]

Build image:

1
docker build -t my-flask-app:latest .

3. Konsep Dasar Kubernetes

Konsep	Penjelasan
Pod	Unit terkecil yang bisa di-deploy (biasanya 1 container)
Deployment	Mengelola replicasi dan update Pod
Service	Load balancing antar Pod
Ingress	Mengatur akses dari luar cluster (HTTP/HTTPS)
ConfigMap	Menyimpan konfigurasi non-sensitive
Secret	Menyimpan data sensitif (password, API key)

4. Deployment Manifest

Buat file deployment.yaml:

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: flask-app
5
spec:
6
  replicas: 3
7
  selector:
8
    matchLabels:
9
      app: flask-app
10
  template:
11
    metadata:
12
      labels:
13
        app: flask-app
14
    spec:
15
      containers:
16
      - name: flask
17
        image: my-flask-app:latest
18
        ports:
19
        - containerPort: 8000
20
        env:
21
        - name: FLASK_ENV
22
          value: "production"
23
        resources:
24
          requests:
25
            memory: "256Mi"
26
            cpu: "250m"
27
          limits:
28
            memory: "512Mi"
29
            cpu: "500m"

Terapkan:

1
kubectl apply -f deployment.yaml

5. Service

Buat file service.yaml:

1
apiVersion: v1
2
kind: Service
3
metadata:
4
  name: flask-service
5
spec:
6
  selector:
7
    app: flask-app
8
  ports:
9
  - protocol: TCP
10
    port: 80
11
    targetPort: 8000
12
  type: ClusterIP

6. Ingress (Akses dari Luar)

Buat file ingress.yaml:

1
apiVersion: networking.k8s.io/v1
2
kind: Ingress
3
metadata:
4
  name: flask-ingress
5
  annotations:
6
    nginx.ingress.kubernetes.io/rewrite-target: /
7
spec:
8
  rules:
9
  - host: flask.yourdomain.com
10
    http:
11
      paths:
12
      - path: /
13
        pathType: Prefix
14
        backend:
15
          service:
16
            name: flask-service
17
            port:
18
              number: 80

7. ConfigMap & Secret

ConfigMap

1
apiVersion: v1
2
kind: ConfigMap
3
metadata:
4
  name: flask-config
5
data:
6
  FLASK_ENV: "production"
7
  LOG_LEVEL: "INFO"

Secret

1
apiVersion: v1
2
kind: Secret
3
metadata:
4
  name: flask-secret
5
type: Opaque
6
stringData:
7
  SECRET_KEY: "your-super-secret-key"
8
  DATABASE_URL: "postgresql://user:pass@db:5432/mydb"

Gunakan di Deployment:

1
envFrom:
2
- configMapRef:
3
    name: flask-config
4
- secretRef:
5
    name: flask-secret

8. Health Checks (Liveness & Readiness Probe)

Sangat penting untuk production:

1
livenessProbe:
2
  httpGet:
3
    path: /health
4
    port: 8000
5
  initialDelaySeconds: 30
6
  periodSeconds: 10
7

8
readinessProbe:
9
  httpGet:
10
    path: /ready
11
    port: 8000
12
  initialDelaySeconds: 5
13
  periodSeconds: 5

Pastikan aplikasi Flask memiliki endpoint /health dan /ready.

9. Horizontal Pod Autoscaler (HPA)

1
apiVersion: autoscaling/v2
2
kind: HorizontalPodAutoscaler
3
metadata:
4
  name: flask-hpa
5
spec:
6
  scaleTargetRef:
7
    apiVersion: apps/v1
8
    kind: Deployment
9
    name: flask-app
10
  minReplicas: 3
11
  maxReplicas: 10
12
  metrics:
13
  - type: Resource
14
    resource:
15
      name: cpu
16
      target:
17
        type: Utilization
18
        averageUtilization: 70

10. Best Practices Kubernetes untuk Flask

Praktik	Rekomendasi
Gunakan non-root user di container	Tingkatkan keamanan
Set resource requests & limits	Hindari resource starvation
Gunakan liveness & readiness probe	Self-healing & traffic management
Simpan secret di Kubernetes Secret	Jangan hardcode
Gunakan ConfigMap untuk konfigurasi	Lebih fleksibel
Implementasikan HPA	Auto scaling berdasarkan beban
Gunakan Ingress + TLS	Akses aman dari luar
Rolling Update strategy	Zero downtime deployment
Monitor dengan Prometheus + Grafana	Observability

Kesimpulan

Kubernetes memberikan kekuatan yang sangat besar untuk menjalankan aplikasi Flask di production, terutama ketika Anda membutuhkan:

Skalabilitas otomatis
High availability
Zero-downtime deployment
Manajemen konfigurasi yang terpusat

Namun, Kubernetes juga memiliki kurva belajar yang cukup curam. Untuk proyek kecil atau menengah, Docker Compose atau platform managed seperti Render, Railway, atau Heroku mungkin lebih efisien.

Jika proyek Anda sudah besar, kompleks, dan membutuhkan skalabilitas tinggi, maka Kubernetes adalah pilihan yang tepat.

Thanks for reading!