---
title: "Cara Deploy Flask ke Helipod: dari Development ke Production dalam Menit"
url: "https://helipod.io/blog/cara-deploy-flask-ke-helipod"
date: "2026-05-05"
updated: "2026-05-05"
author: "Tim Helipod"
tags: ["flask", "python", "tutorial", "deployment", "gunicorn"]
excerpt: "Tutorial lengkap deploy aplikasi Flask ke Helipod, auto-detect Python, setup gunicorn, konfigurasi environment variables, dan PostgreSQL tanpa ribet."
---

# Cara Deploy Flask ke Helipod: dari Development ke Production dalam Menit

Flask adalah framework Python yang ringan, fleksibel, dan mudah dipelajari. Banyak developer Indonesia memulai backend journey mereka dengan Flask, dari REST API sederhana, webhook handler, sampai web app full-featured dengan Jinja2.

Tapi ada satu masalah yang sering dikeluhkan: *"Flask-ku jalan di local, tapi gimana cara deploy ke production yang bener?"*

Jawabannya: Helipod. Connect repository, set environment variables, klik deploy, selesai.

## Yang Kamu Butuhkan

- Akun Helipod (daftar gratis di [helipod.io](https://helipod.io))
- Repository Flask di GitHub atau GitLab
- Python 3.10+

## Persiapan Project Flask

### 1. Struktur Project yang Direkomendasikan

```
myapp/
├── app.py           # atau wsgi.py
├── requirements.txt
├── .env.example
└── templates/       # jika menggunakan Jinja2
```

Untuk project lebih besar dengan Application Factory pattern:

```
myapp/
├── wsgi.py
├── requirements.txt
├── app/
│   ├── __init__.py  # Application factory
│   ├── routes/
│   ├── models/
│   └── config.py
```

### 2. Gunakan Application Factory Pattern

```python
# app/__init__.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import os

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    
    # Config dari environment
    app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-secret-key')
    app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
        'DATABASE_URL', 
        'sqlite:///dev.db'
    )
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['ENV'] = os.environ.get('FLASK_ENV', 'production')
    
    db.init_app(app)
    
    # Register blueprints
    from app.routes.main import main_bp
    from app.routes.api import api_bp
    app.register_blueprint(main_bp)
    app.register_blueprint(api_bp, url_prefix='/api')
    
    return app
```

```python
# wsgi.py
from app import create_app

app = create_app()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))
```

### 3. requirements.txt

```txt
Flask>=3.0.0
gunicorn>=21.0.0
flask-sqlalchemy>=3.1.0
flask-migrate>=4.0.0
psycopg2-binary>=2.9.9
python-dotenv>=1.0.0
flask-cors>=4.0.0

# Opsional
flask-jwt-extended>=4.6.0
marshmallow>=3.21.0
```

### 4. Konfigurasi Port yang Benar

```python
# app.py (untuk project sederhana)
from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def index():
    return {'message': 'Hello from Helipod!'}

@app.route('/health')
def health():
    return {'status': 'ok'}

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=False)
```

> **Jangan gunakan Flask development server di production.** Helipack otomatis menggunakan `gunicorn` sebagai WSGI server, bukan `flask run`.

## Langkah 1: Tambahkan PostgreSQL Service (Opsional)

Jika aplikasi Flask kamu butuh database, buat service PostgreSQL terlebih dahulu di canvas Helipod. Catat nama service-nya untuk dipakai di environment variables.

## Langkah 2: Connect Repository

Login ke dashboard Helipod, klik **New Project**, pilih repository Flask dari GitHub. Helipack mendeteksi Python + Flask dari `requirements.txt`.

## Langkah 3: Set Environment Variables

Buka tab **Variables**:

```env
FLASK_ENV=production
SECRET_KEY=ganti-dengan-secret-key-yang-kuat-dan-random

# Database PostgreSQL
DATABASE_URL=postgresql://postgres:password@nama-service-postgres:5432/flaskdb

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

# CORS (jika pakai flask-cors)
ALLOWED_ORIGINS=https://yourdomain.com

# JWT (jika pakai flask-jwt-extended)
JWT_SECRET_KEY=jwt-secret-key-yang-berbeda
```

> **Tips:** Jangan pernah commit `SECRET_KEY` ke repository. Selalu generate random key yang kuat: `python -c "import secrets; print(secrets.token_hex(32))"`.

## Langkah 4: Deploy

Klik **Deploy**. Helipack akan:

1. Detect Python + Flask dari `requirements.txt`
2. Install dependencies
3. Build Docker image
4. Deploy dengan `gunicorn` sebagai WSGI server
5. Setup domain dan SSL otomatis

## Dockerfile yang Dihasilkan Helipack

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

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

FROM base AS deps
WORKDIR /app
COPY requirements.txt ./
RUN --mount=type=cache,target=/root/.cache/pip \
    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 useradd --no-create-home --shell /bin/false appuser && \
    chown -R appuser:appuser /app
USER appuser

EXPOSE 5000
CMD ["gunicorn", "wsgi:app", "--bind", "0.0.0.0:5000", "--workers", "2", "--timeout", "120"]
```

> Helipack otomatis mendeteksi entry point, bisa `app.py`, `wsgi.py`, atau `application.py`.

## Langkah 5: Jalankan Migrasi Database

Setelah **LIVE**, buka tab **Terminal**:

```bash
# Menggunakan Flask-Migrate
flask db upgrade

# Atau langsung SQLAlchemy
flask shell
>>> from app import db
>>> db.create_all()
>>> exit()
```

## Otomasi Migrasi dengan helipack.json

```json
{
  "run": {
    "port": 5000,
    "before": "flask db upgrade",
    "command": "gunicorn wsgi:app --bind 0.0.0.0:5000 --workers 2"
  },
  "health": {
    "path": "/health",
    "duration": 15
  }
}
```

## Flask dengan Flask-SQLAlchemy dan Migrasi

Setup lengkap Flask + PostgreSQL + Flask-Migrate:

```python
# extensions.py
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

db = SQLAlchemy()
migrate = Migrate()
```

```python
# app/__init__.py
from flask import Flask
from .extensions import db, migrate
import os

def create_app():
    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
    
    db.init_app(app)
    migrate.init_app(app, db)
    
    from .routes import main
    app.register_blueprint(main)
    
    return app
```

```python
# models.py
from .extensions import db
from datetime import datetime

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(120), unique=True, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    def to_dict(self):
        return {
            'id': self.id,
            'email': self.email,
            'created_at': self.created_at.isoformat()
        }
```

## Flask REST API dengan flask-smorest

Untuk API yang lebih structured dengan auto-docs:

```python
# requirements.txt
flask-smorest>=0.44.0
marshmallow>=3.21.0
```

```python
from flask import Flask
from flask_smorest import Api

app = Flask(__name__)
app.config['API_TITLE'] = 'My API'
app.config['API_VERSION'] = 'v1'
app.config['OPENAPI_VERSION'] = '3.0.2'
app.config['OPENAPI_URL_PREFIX'] = '/'
app.config['OPENAPI_SWAGGER_UI_PATH'] = '/docs'
app.config['OPENAPI_SWAGGER_UI_URL'] = 'https://cdn.jsdelivr.net/npm/swagger-ui-dist/'

api = Api(app)
```

Setelah deploy, akses dokumentasi API di `https://nama-project.helipod.app/docs`.

## Tips Performa Gunicorn di Production

Override default gunicorn config di `helipack.json` untuk traffic tinggi:

```json
{
  "run": {
    "port": 5000,
    "command": "gunicorn wsgi:app --bind 0.0.0.0:5000 --workers 4 --threads 2 --worker-class gthread --timeout 120 --keep-alive 5"
  }
}
```

Rumus workers yang direkomendasikan: `(2 × CPU cores) + 1`. Untuk pod 1 vCPU, gunakan 3 workers.

Untuk aplikasi I/O heavy (banyak call ke external API atau database), gunakan `gevent`:

```txt
# requirements.txt
gevent>=24.2.1
```

```json
{
  "run": {
    "command": "gunicorn wsgi:app --bind 0.0.0.0:5000 --worker-class gevent --workers 4"
  }
}
```

## Monitoring Flask di Helipod

Setelah live, pantau performa di tab **Metrics**:
- **CPU:** Flask + gunicorn biasanya 0.1-0.3 vCPU saat idle
- **Memory:** ~100-250MB untuk aplikasi sederhana
- **Restarts:** Jika > 0, cek App logs untuk error

Lihat **Logs real-time** di tab yang terpisah untuk debug request yang masuk.

## Troubleshooting Umum

**"Failed to find application in module 'app'"**
Helipack mencari `app` object di `app.py` atau `wsgi.py`. Pastikan variable aplikasi Flask bernama `app` atau override command di `helipack.json`.

**"FLASK_ENV is deprecated"**
Flask 2.3+ tidak menggunakan `FLASK_ENV`. Gunakan `FLASK_DEBUG=0` untuk production.

**"sqlalchemy.exc.OperationalError: connection refused"**
Pastikan `DATABASE_URL` menggunakan hostname service PostgreSQL di Helipod, bukan `localhost`.

**Static files tidak serve**
Untuk production, gunakan `Flask-Static-Digest` atau serve via nginx. Helipod serve static files Flask secara langsung via Werkzeug, cukup untuk traffic rendah-menengah.

**"gunicorn: error: No module named wsgi"**
Pastikan file `wsgi.py` ada di root repository dan berisi `app = create_app()` atau objek Flask langsung.

## Kesimpulan

Flask adalah framework yang powerful tapi minimalis, dan Helipod membuatnya semudah mungkin untuk di-deploy ke production. Tidak perlu setup nginx, tidak perlu konfigurasi SSL, tidak perlu jadi sysadmin.

Ingin performa lebih tinggi dengan async Python? Coba [FastAPI di Helipod](/blog/cara-deploy-fastapi-ke-helipod) yang menggunakan uvicorn dengan performa jauh lebih tinggi untuk concurrent requests.

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