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

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/deploy.sh | bash

bunx @temps-sdk/cli login

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

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"]

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .

# Custom entry point and port
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

bunx @temps-sdk/cli projects config -p my-fastapi-app --cpu-limit 1 --memory-limit 512 --replicas 2

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

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

# List all
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 -e production DATABASE_URL "postgresql://user:pass@host:5432/db"

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 -e production REDIS_URL "redis://host:6379"

import redis
import os

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

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

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():
    # Check database connection
    # Check external services
    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 --replicas 3

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

# Uses HTTP challenge by default
bunx @temps-sdk/cli domains add -d api.yourdomain.com

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

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

# Login
bunx @temps-sdk/cli login

# Create project and connect repo
bunx @temps-sdk/cli projects create -n "My API" -d "FastAPI application"
bunx @temps-sdk/cli projects git -p my-api --owner myorg --repo my-api --branch main --preset dockerfile -y

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

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

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

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

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

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