Seed Stage (unter 10k MAU):    Heroku/Railway/Render
Series A (10k-100k MAU):        Kubernetes evaluieren
Series B+ (über 100k MAU):       Kubernetes wahrscheinlich sinnvoll

┌─────────────────────────────────────┐
│              Vercel/Railway         │
│  (Frontend + API in einem Service)  │
└──────────────────┬──────────────────┘
                   │
         ┌─────────▼─────────┐
         │   Managed DB      │
         │   (Supabase/      │
         │    PlanetScale)   │
         └───────────────────┘

┌─────────────────────────────────────────────────┐
│              Managed Kubernetes                  │
│         (GKE Autopilot / EKS / AKS)             │
├─────────────────────────────────────────────────┤
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │   API    │  │  Worker  │  │  Admin   │      │
│  │ Gateway  │  │  Service │  │   UI     │      │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘      │
│       │             │             │             │
│       └─────────────┴─────────────┘             │
│                     │                           │
│           ┌─────────▼─────────┐                │
│           │   Managed DB      │                │
│           │   (RDS/Cloud SQL) │                │
│           └───────────────────┘                │
│                                                  │
└─────────────────────────────────────────────────┘

# GKE Autopilot (einfachster Einstieg)
gcloud container clusters create-auto startup-cluster \
  --region=europe-west1

# EKS mit eksctl
eksctl create cluster \
  --name startup-cluster \
  --region eu-central-1 \
  --fargate

# namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted

---
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: production
spec:
  replicas: 2
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: api
        image: myapp:1.0.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 100m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url

# HPA für automatische Skalierung
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

---
# Nachts runterskalieren (für nicht-kritische Umgebungen)
apiVersion: batch/v1
kind: CronJob
metadata:
  name: scale-down-staging
spec:
  schedule: "0 20 * * 1-5"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: kubectl
            image: bitnami/kubectl
            command:
            - kubectl
            - scale
            - deployment
            ---all
            ---replicas=0
            - -n
            - staging
          restartPolicy: OnFailure

┌─────────────────────────────────────────────────────────────┐
│                      CDN (CloudFlare)                        │
└───────────────────────────┬─────────────────────────────────┘
                            │
┌───────────────────────────▼─────────────────────────────────┐
│                    Ingress Controller                        │
│                   (nginx / Traefik)                          │
└───────────────────────────┬─────────────────────────────────┘
                            │
         ┌──────────────────┼──────────────────┐
         │                  │                  │
    ┌────▼────┐       ┌─────▼────┐       ┌────▼────┐
    │   Web   │       │   API    │       │  Admin  │
    │ (SSR)   │       │ Gateway  │       │   UI    │
    └────┬────┘       └────┬─────┘       └────┬────┘
         │                 │                  │
         │    ┌────────────┼────────────┐    │
         │    │            │            │    │
         │  ┌─▼──┐   ┌─────▼────┐  ┌───▼──┐ │
         │  │User│   │  Order   │  │Search│ │
         │  │Svc │   │  Service │  │ Svc  │ │
         │  └─┬──┘   └────┬─────┘  └───┬──┘ │
         │    │           │            │    │
         │    └───────────┼────────────┘    │
         │                │                 │
         │         ┌──────▼──────┐         │
         │         │   Message   │         │
         │         │   Queue     │         │
         │         │ (RabbitMQ)  │         │
         │         └──────┬──────┘         │
         │                │                │
┌────────┴────────────────┼────────────────┴────────┐
│                         │                         │
│  ┌──────────┐    ┌──────▼──────┐    ┌─────────┐ │
│  │PostgreSQL│    │    Redis    │    │ Elastic │ │
│  │ (Primary │    │   (Cache)   │    │ Search  │ │
│  │  + Read  │    └─────────────┘    └─────────┘ │
│  │ Replicas)│                                    │
│  └──────────┘                                    │
└──────────────────────────────────────────────────┘

# Deployment mit Anti-Affinity für Hochverfügbarkeit
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 6
  template:
    spec:
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: topology.kubernetes.io/zone
        whenUnsatisfiable: DoNotSchedule
        labelSelector:
          matchLabels:
            app: api
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchLabels:
                  app: api
              topologyKey: kubernetes.io/hostname

# .github/workflows/deploy.yaml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build and Push Image
        uses: docker/build-push-action@v5
        with:
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}

      - name: Deploy to Kubernetes
        uses: azure/k8s-deploy@v5
        with:
          manifests: k8s/
          images: ghcr.io/${{ github.repository }}:${{ github.sha }}

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: api
spec:
  replicas: 5
  strategy:
    canary:
      steps:
      - setWeight: 10
      - pause: {duration: 5m}
      - setWeight: 30
      - pause: {duration: 5m}
      - setWeight: 50
      - pause: {duration: 5m}
      analysis:
        templates:
        - templateName: success-rate
        startingStep: 2

resources:
  requests:
    cpu: 100m
    memory: 256Mi
  limits:
    cpu: 500m
    memory: 512Mi

MAU < 10k:      PaaS (Railway, Render, Fly.io)
MAU 10k-50k:    Kubernetes evaluieren
MAU > 50k:      Kubernetes wahrscheinlich die richtige Wahl