Deploy FastAPI to Production: The Easy Way with Temps

my-fastapi-app/
├── main.py           # or app/main.py
├── requirements.txt  # or pyproject.toml
└── .env             # optional, for local development only

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from FastAPI on Temps"}

@app.get("/health")
def health_check():
    return {"status": "healthy"}

fastapi>=0.109.0
uvicorn[standard]>=0.27.0

# macOS / Linux
curl -fsSL https://temps.sh/install.sh | bash

bunx @temps-sdk/cli login

# Create project and connect your git repository
bunx @temps-sdk/cli projects create \
  -n "My FastAPI App" \
  -d "FastAPI application" \
  --repo your-org/your-fastapi-app \
  --branch main \
  --preset python

bunx @temps-sdk/cli deploy my-fastapi-app -b main -e production -y

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Run with uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# Set CPU/memory limits and replica count
bunx @temps-sdk/cli projects config -p my-fastapi-app \
  --cpu-limit 1 \
  --memory-limit 512 \
  --replicas 2 \
  -y

# Single variable
bunx @temps-sdk/cli environments vars set DATABASE_URL "postgresql://..." -e production
bunx @temps-sdk/cli environments vars set OPENAI_API_KEY "sk-..." -e production

# Import from file
bunx @temps-sdk/cli environments vars import .env.production -e production

# List all (values hidden by default)
bunx @temps-sdk/cli environments vars list -e production

import os
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    openai_api_key: str
    debug: bool = False

settings = Settings()

bunx @temps-sdk/cli environments vars set DATABASE_URL "postgresql://user:pass@host:5432/db" -e production

from sqlalchemy.ext.asyncio import create_async_engine
import os

DATABASE_URL = os.getenv("DATABASE_URL")
engine = create_async_engine(DATABASE_URL)

bunx @temps-sdk/cli environments vars set REDIS_URL "redis://host:6379" -e production

import redis
import os

r = redis.from_url(os.getenv("REDIS_URL"))

bunx @temps-sdk/cli environments vars set MONGODB_URI "mongodb://user:pass@host:27017/db" -e production

from motor.motor_asyncio import AsyncIOMotorClient
import os

client = AsyncIOMotorClient(os.getenv("MONGODB_URI"))

from fastapi import FastAPI
import os

app = FastAPI(
    docs_url="/docs" if os.getenv("ENABLE_DOCS") else None,
    redoc_url="/redoc" if os.getenv("ENABLE_DOCS") else None,
)

@app.get("/health")
async def health():
    # Optionally check DB connectivity here
    return {"status": "healthy"}

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://yourfrontend.com"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

import logging
import json

class JSONFormatter(logging.Formatter):
    def format(self, record):
        return json.dumps({
            "timestamp": self.formatTime(record),
            "level": record.levelname,
            "message": record.getMessage(),
            "module": record.module,
        })

handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logging.getLogger().addHandler(handler)

bunx @temps-sdk/cli environments scale -e production -r 3

bunx @temps-sdk/cli projects config -p my-fastapi-app \
  --cpu-limit 2 \
  --memory-limit 1024 \
  -y
bunx @temps-sdk/cli deploy my-fastapi-app -b main -e production -y

# HTTP-01 challenge (default, works for most domains)
bunx @temps-sdk/cli domains add -d api.yourdomain.com

# DNS-01 challenge (required for wildcard domains)
bunx @temps-sdk/cli domains add -d "*.yourdomain.com" --challenge dns-01

from fastapi import BackgroundTasks

@app.post("/send-email")
async def send_email(
    email: str,
    background_tasks: BackgroundTasks
):
    background_tasks.add_task(send_email_task, email)
    return {"message": "Email queued"}

from fastapi import Depends

async def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users")
async def get_users(db: Session = Depends(get_db)):
    return db.query(User).all()

import time

@app.middleware("http")
async def add_timing(request, call_next):
    start = time.time()
    response = await call_next(request)
    response.headers["X-Process-Time"] = str(time.time() - start)
    return response

bunx @temps-sdk/cli deploy my-fastapi-app -b main -e production

# Stream live logs
bunx @temps-sdk/cli runtime-logs -p my-fastapi-app -f

@app.get("/health")
async def health():
    return {"status": "ok"}  # Keep it fast and dependency-free

# Install CLI
curl -fsSL https://temps.sh/install.sh | bash

# Login
bunx @temps-sdk/cli login

# Create project and connect repo
bunx @temps-sdk/cli projects create \
  -n "My FastAPI API" \
  -d "FastAPI application" \
  --repo myorg/my-fastapi-app \
  --branch main \
  --preset python

# Deploy
bunx @temps-sdk/cli deploy my-fastapi-api -b main -e production -y

# Stream logs
bunx @temps-sdk/cli runtime-logs -p my-fastapi-api -f

# Set environment variable
bunx @temps-sdk/cli environments vars set SECRET_KEY "value" -e production

# Scale replicas
bunx @temps-sdk/cli environments scale -e production -r 3

# Add domain (HTTP-01 by default, DNS-01 for wildcards)
bunx @temps-sdk/cli domains add -d api.example.com

curl -fsSL https://temps.sh/install.sh | bash && bunx @temps-sdk/cli login