FastAPI adalah framework Python tercepat untuk membangun REST API — dengan type hints, auto-generated docs (Swagger UI), dan performa async yang mendekati Node.js. Tidak heran FastAPI jadi pilihan utama untuk backend API, ML model serving, dan microservice modern.

Deploy FastAPI ke production dengan Helipod semudah push kode ke GitHub. Helipack mendeteksi FastAPI dari requirements.txt atau pyproject.toml, install dependencies, dan jalankan dengan uvicorn — server async yang paling cocok untuk FastAPI.

Yang Kamu Butuhkan

Akun Helipod (daftar gratis di helipod.io)
Repository FastAPI di GitHub atau GitLab
Python 3.10+

Persiapan Project FastAPI

1. Struktur Project Minimal

myproject/
├── main.py          # atau app/main.py
├── requirements.txt
└── .env.example

2. File main.py

from fastapi import FastAPI
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: koneksi ke database, dll
    yield
    # Shutdown: cleanup

app = FastAPI(
    title="My API",
    description="API keren dengan FastAPI",
    version="1.0.0",
    lifespan=lifespan,
)

@app.get("/")
async def root():
    return {"message": "Hello from Helipod!"}

@app.get("/health")
async def health():
    return {"status": "ok"}

3. requirements.txt

fastapi>=0.110.0
uvicorn[standard]>=0.29.0
pydantic>=2.0
pydantic-settings>=2.0

# Database
sqlalchemy>=2.0
asyncpg>=0.29.0     # untuk async PostgreSQL
alembic>=1.13.0     # untuk migrasi

# Opsional
python-dotenv>=1.0
httpx>=0.27.0       # untuk HTTP client async

Penting: Gunakan uvicorn[standard] (bukan uvicorn biasa) untuk mendapat uvloop dan httptools yang jauh lebih cepat.

4. Konfigurasi Settings dengan Pydantic

Praktik terbaik untuk FastAPI adalah menggunakan pydantic-settings untuk konfigurasi:

# config.py
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str = "sqlite+aiosqlite:///./test.db"
    secret_key: str = "your-secret-key"
    debug: bool = False
    port: int = 8000
    
    class Config:
        env_file = ".env"

settings = Settings()

Langkah 1: Tambahkan Database Service (Opsional)

Jika butuh PostgreSQL, tambahkan service PostgreSQL dulu di canvas Helipod sebelum deploy FastAPI. Catat nama service-nya.

Langkah 2: Connect Repository

Login ke dashboard Helipod, klik New Project, pilih repository FastAPI. Helipack mendeteksi Python + FastAPI dari requirements.txt.

Langkah 3: Set Environment Variables

Buka tab Variables:

DEBUG=false
SECRET_KEY=your-super-secret-key-ganti-ini

# Database async PostgreSQL
DATABASE_URL=postgresql+asyncpg://postgres:password@nama-service-postgres:5432/mydb

# Atau sync (tanpa async):
DATABASE_URL=postgresql://postgres:password@nama-service-postgres:5432/mydb

# CORS
ALLOWED_ORIGINS=https://yourdomain.com,https://app.yourdomain.com

# Opsional
API_KEY=your-api-key
ENVIRONMENT=production

asyncpg vs psycopg2: Untuk FastAPI async, gunakan asyncpg dengan prefix postgresql+asyncpg://. Untuk sync (lebih simpel), gunakan psycopg2-binary dengan postgresql://.

Langkah 4: Deploy

Klik Deploy. Helipack akan:

Detect Python + FastAPI
Install dependencies dari requirements.txt
Build Docker image
Deploy dengan uvicorn main:app --host 0.0.0.0 --port 8000

Dockerfile yang Dihasilkan Helipack

# 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 \
    && 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 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Menggunakan uv untuk Install Lebih Cepat

uv adalah package manager Python ultra-cepat (10-100x lebih cepat dari pip). Helipack mendukungnya otomatis jika ada uv.lock:

# pyproject.toml
[project]
name = "myapi"
requires-python = ">=3.12"
dependencies = [
    "fastapi>=0.110.0",
    "uvicorn[standard]>=0.29.0",
    "pydantic>=2.0",
    "asyncpg>=0.29.0",
    "sqlalchemy>=2.0",
    "alembic>=1.13.0",
]

# Generate lock file
uv lock
git add uv.lock pyproject.toml

Helipack akan detect uv.lock dan menggunakan uv sync --frozen --no-dev — jauh lebih cepat.

Konfigurasi Lanjutan

Custom Start Command

Override start command di helipack.json untuk production-grade setup:

{
  "run": {
    "port": 8000,
    "command": "uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 --loop uvloop"
  },
  "health": {
    "path": "/health",
    "duration": 15
  }
}

Workers: Untuk FastAPI async dengan --workers > 1, pastikan kamu tidak menggunakan shared in-memory state antar workers. Gunakan Redis atau database untuk state sharing.

Jalankan Alembic Migrasi Otomatis

{
  "run": {
    "port": 8000,
    "before": "alembic upgrade head",
    "command": "uvicorn main:app --host 0.0.0.0 --port 8000 --workers 2"
  }
}

Multi-file Project (App sebagai Package)

Jika menggunakan struktur app/main.py:

{
  "run": {
    "command": "uvicorn app.main:app --host 0.0.0.0 --port 8000"
  }
}

FastAPI dengan SQLAlchemy Async

Setup database async yang proper untuk production:

# database.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from sqlalchemy.orm import DeclarativeBase
import os

engine = create_async_engine(
    os.environ["DATABASE_URL"],
    echo=False,
    pool_size=10,
    max_overflow=20,
)

AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)

class Base(DeclarativeBase):
    pass

# Dependency
async def get_db():
    async with AsyncSessionLocal() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise

Akses Swagger UI

Setelah deploy, FastAPI otomatis menyediakan dokumentasi interaktif di:

Swagger UI: https://nama-project.helipod.app/docs
ReDoc: https://nama-project.helipod.app/redoc

Matikan di production jika tidak diperlukan:

app = FastAPI(
    docs_url=None if os.environ.get("ENVIRONMENT") == "production" else "/docs",
    redoc_url=None if os.environ.get("ENVIRONMENT") == "production" else "/redoc",
)

Deploy FastAPI untuk ML Model Serving

FastAPI sangat populer untuk serving machine learning models. Contoh dengan scikit-learn:

# requirements.txt tambahan
scikit-learn>=1.4.0
numpy>=1.26.0
joblib>=1.3.0

from fastapi import FastAPI
import joblib
import numpy as np
import os

app = FastAPI()

# Load model saat startup
model = None

@app.on_event("startup")
async def load_model():
    global model
    model = joblib.load("model.pkl")

@app.post("/predict")
async def predict(features: list[float]):
    prediction = model.predict([features])
    return {"prediction": prediction.tolist()}

Untuk model yang besar, simpan model di Secret Files atau mount via persistent volume.

Troubleshooting Umum

"ModuleNotFoundError: No module named 'main'" Pastikan file entry point bernama main.py dan ada di root repository. Atau override di helipack.json dengan path yang benar: "command": "uvicorn app.main:app ...".

"Connection refused" ke PostgreSQL Pastikan DB_HOST menggunakan nama service PostgreSQL di canvas Helipod.

"asyncpg: cannot create a connection" Periksa format DATABASE_URL — untuk asyncpg harus menggunakan postgresql+asyncpg://, bukan postgresql://.

Swagger UI tidak bisa diakses Default FastAPI serve docs di /docs. Jika tidak muncul, cek apakah docs_url di-set ke None di kode kamu.

Kesimpulan

Deploy FastAPI ke Helipod sangat mudah — Helipack mendeteksi framework secara otomatis dan mengurus semua setup server. Kamu tinggal fokus ke business logic API-mu.

Butuh deploy Starlette atau Flask? Baca Deploy Flask ke Helipod. Ingin tahu detail cara Helipack bekerja? Baca Helipack: Dockerfile Otomatis.

Punya pertanyaan? Hubungi kami di support@helipod.id atau bergabung ke komunitas di hangar.helipod.io.

Cara Deploy FastAPI ke Helipod — Python API Production-Ready dalam Menit