API FastAPI en prod sur Cloud Run en 10 min

# Se connecter à Google Cloud
gcloud auth login

# Créer un nouveau projet (ou en utiliser un existant)
gcloud projects create mon-api-project --name="Mon API FastAPI"

# Définir le projet par défaut
gcloud config set project mon-api-project

# Activer les APIs nécessaires
gcloud services enable run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

# Configurer la région
gcloud config set run/region europe-west1  # Paris/Belgique

from fastapi import FastAPI
from pydantic import BaseModel
import os

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

# Cloud Run injecte automatiquement 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):
    """Analyse de sentiment simplifiée pour la démonstration."""
    positive_words = {'excellent', 'super', 'génial', 'parfait', 'bien', 'top'}
    negative_words = {'mauvais', 'nul', 'terrible', 'horrible', 'décevant'}

    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="positif",
            confidence=round(0.6 + pos_count * 0.1, 2),
            text=request.text
        )
    elif neg_count > pos_count:
        return PredictionResponse(
            sentiment="négatif",
            confidence=round(0.6 + neg_count * 0.1, 2),
            text=request.text
        )
    return PredictionResponse(sentiment="neutre", 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 utilise la variable PORT injectée automatiquement
# On utilise sh -c pour permettre la substitution de variable
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"

# Créer le registry Artifact Registry
gcloud artifacts repositories create $REPO_NAME \
  --repository-format=docker \
  --location=$REGION \
  --description="Images Docker pour mes APIs"

# Configurer Docker pour s'authentifier à Artifact Registry
gcloud auth configure-docker $REGION-docker.pkg.dev

# Construire l'image avec le tag complet Artifact Registry
IMAGE_TAG=$REGION-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/$IMAGE_NAME:v1

docker build -t $IMAGE_TAG .

# Pousser l'image
docker push $IMAGE_TAG

# Vérifier que l'image est dans le 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 \        # API publique
  --min-instances=0 \              # Scale to zero (économique)
  --max-instances=10 \             # Limite de scaling
  --memory=512Mi \
  --cpu=1 \
  --concurrency=80 \              # Requêtes simultanées par instance
  --set-env-vars="ENVIRONMENT=production" \
  --port=8080

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

# Test endpoint racine
curl $SERVICE_URL

# Test prédiction
curl -X POST $SERVICE_URL/predict \
  -H "Content-Type: application/json" \
  -d '{"text": "Ce produit est excellent et super efficace"}'
# {"sentiment":"positif","confidence":0.8,"text":"Ce produit est excellent et super efficace"}

# Depuis le dossier contenant votre Dockerfile
# Cloud Build construit l'image et déploie automatiquement
gcloud run deploy sentiment-api \
  --source . \
  --region=europe-west1 \
  --allow-unauthenticated

# Créer un secret dans Secret Manager
echo -n "ma-cle-api-secrete" | gcloud secrets create API_KEY \
  --data-file=- \
  --replication-policy=automatic

# Déployer avec le secret monté comme variable d'environnement
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)
✅ APIs et microservices HTTP stateless
✅ Trafic variable / imprévisible
✅ Démarrage rapide sans infra à gérer
✅ Scale to zero = économique pour les petites charges
✅ Facturé à la requête (pas de coût fixe)
❌ Pas de connexions WebSocket longues durée
❌ Limité à 60 min par requête
🎯 IDÉAL POUR : API REST, webhooks, petites apps avec pic de trafic

# Kubernetes (orchestration)
✅ Applications avec état (bases de données, caches)
✅ Workloads complexes (jobs, workers, CronJobs)
✅ Contrôle total sur le réseau, le stockage
✅ Multi-cloud / on-premise
✅ Adapté aux équipes DevOps matures
❌ Complexité d'administration élevée
❌ Toujours des noeuds actifs = coût fixe
🎯 IDÉAL POUR : Applications complexes, services critiques, trafic constant

# VPS / VM dédiée
✅ Contrôle total (SSH, sudo, installer quoi on veut)
✅ Pas de contraintes de temps d'exécution
✅ Moins cher pour trafic constant prévisible
❌ Vous gérez OS, updates, sécurité, scaling manuel
❌ Toujours actif = coût fixe même sans trafic
🎯 IDÉAL POUR : Applications legacy, besoin de contrôle bas niveau, équipes très réduites