Deploy a FastAPI API to Cloud Run in 10 minutes

# Log in to Google Cloud
gcloud auth login

# Create a new project (or use an existing one)
gcloud projects create mon-api-project --name="My FastAPI"

# Set the project as default
gcloud config set project mon-api-project

# Enable necessary APIs
gcloud services enable run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

# Configure the region
gcloud config set run/region europe-west1  # Paris/Belgium

from fastapi import FastAPI
from pydantic import BaseModel
import os

app = FastAPI(
    title="My Cloud Run API",
    version="1.0.0",
    docs_url="/docs"
)

# Cloud Run automatically injects PORT
PORT = int(os.getenv("PORT", "8080"))

class PredictionRequest(BaseModel):
    text: str

class PredictionResponse(BaseModel):
    sentiment: str
    confidence: float
    text: str

@app.get("/")
def root():
    return {
        "service": "Sentiment Analysis API",
        "version": "1.0.0",
        "environment": os.getenv("ENVIRONMENT", "production")
    }

@app.post("/predict", response_model=PredictionResponse)
def predict(request: PredictionRequest):
    """Simplified sentiment analysis for demonstration."""
    positive_words = {'excellent', 'amazing', 'great', 'perfect', 'good', 'awesome'}
    negative_words = {'bad', 'terrible', 'horrible', 'awful', 'disappointing'}

    words = set(request.text.lower().split())
    pos_count = len(words & positive_words)
    neg_count = len(words & negative_words)

    if pos_count > neg_count:
        return PredictionResponse(
            sentiment="positive",
            confidence=round(0.6 + pos_count * 0.1, 2),
            text=request.text
        )
    elif neg_count > pos_count:
        return PredictionResponse(
            sentiment="negative",
            confidence=round(0.6 + neg_count * 0.1, 2),
            text=request.text
        )
    return PredictionResponse(sentiment="neutral", confidence=0.55, text=request.text)

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

fastapi==0.111.0
uvicorn[standard]==0.29.0
pydantic==2.7.0

FROM python:3.11-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1

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

COPY . .

# Cloud Run uses the automatically injected PORT variable
# Use sh -c to allow variable substitution
CMD exec uvicorn main:app --host 0.0.0.0 --port $PORT

# Variables
PROJECT_ID="mon-api-project"
REGION="europe-west1"
REPO_NAME="mon-repo"
IMAGE_NAME="sentiment-api"

# Create the Artifact Registry
gcloud artifacts repositories create $REPO_NAME \
  --repository-format=docker \
  --location=$REGION \
  --description="Docker images for my APIs"

# Configure Docker to authenticate to Artifact Registry
gcloud auth configure-docker $REGION-docker.pkg.dev

# Build the image with the full Artifact Registry tag
IMAGE_TAG=$REGION-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/$IMAGE_NAME:v1

docker build -t $IMAGE_TAG .

# Push the image
docker push $IMAGE_TAG

# Verify the image is in the registry
gcloud artifacts docker images list $REGION-docker.pkg.dev/$PROJECT_ID/$REPO_NAME

gcloud run deploy sentiment-api \
  --image=$IMAGE_TAG \
  --platform=managed \
  --region=$REGION \
  --allow-unauthenticated \        # Public API
  --min-instances=0 \              # Scale to zero (economical)
  --max-instances=10 \             # Scaling limit
  --memory=512Mi \
  --cpu=1 \
  --concurrency=80 \              # Concurrent requests per instance
  --set-env-vars="ENVIRONMENT=production" \
  --port=8080

SERVICE_URL=$(gcloud run services describe sentiment-api \
  --region=$REGION \
  --format='value(status.url)')

# Test root endpoint
curl $SERVICE_URL

# Test prediction
curl -X POST $SERVICE_URL/predict \
  -H "Content-Type: application/json" \
  -d '{"text": "This product is excellent and very efficient"}'
# {"sentiment":"positive","confidence":0.8,"text":"This product is excellent and very efficient"}

# From the folder containing your Dockerfile
# Cloud Build builds the image and deploys automatically
gcloud run deploy sentiment-api \
  --source . \
  --region=europe-west1 \
  --allow-unauthenticated

# Create a secret in Secret Manager
echo -n "my-secret-api-key" | gcloud secrets create API_KEY \
  --data-file=- \
  --replication-policy=automatic

# Deploy with the secret mounted as an environment variable
gcloud run deploy sentiment-api \
  --image=$IMAGE_TAG \
  --region=$REGION \
  --set-secrets="API_KEY=API_KEY:latest" \
  --set-env-vars="ENVIRONMENT=production"

# Cloud Run (serverless)
✅ HTTP stateless APIs and microservices
✅ Variable / unpredictable traffic
✅ Fast startup without infrastructure management
✅ Scale to zero = economical for small loads
✅ Billed per request (no fixed cost)
❌ No long-running WebSocket connections
❌ Limited to 60 min per request
🎯 IDEAL FOR: REST APIs, webhooks, small apps with traffic spikes

# Kubernetes (orchestration)
✅ Stateful applications (databases, caches)
✅ Complex workloads (jobs, workers, CronJobs)
✅ Full control over networking, storage
✅ Multi-cloud / on-premise
✅ Suited for mature DevOps teams
❌ High administration complexity
❌ Always-on nodes = fixed cost
🎯 IDEAL FOR: Complex applications, critical services, constant traffic

# VPS / Dedicated VM
✅ Full control (SSH, sudo, install whatever)
✅ No execution time constraints
✅ Cheaper for predictable constant traffic
❌ You manage OS, updates, security, manual scaling
❌ Always active = fixed cost even idle
🎯 IDEAL FOR: Legacy applications, need for low-level control, minimal teams