Cold Start

Einfach erklärt

Cold Start ist die Verzögerung beim ersten Request, wenn ein Service erst hochgefahren oder initialisiert werden muss. Bei Serverless und Scale-to-Zero kann das nach Inaktivität auftreten.

Der Ablauf:

Warm Start (Instanz läuft bereits):
Request ──► Handler ──► Response
           kurze Latenz

Cold Start (Instanz muss starten):
Request ──► Container Start ──► Runtime Init ──► Code Load ──► Handler ──► Response
           zusätzliche Initialisierungsschritte vor der eigentlichen Verarbeitung

Cold Start Unterschiede nach Runtime:

Runtime-Typ	Typische Einordnung	Anmerkung
Kompilierte, kleine Binaries	oft schneller	geringe Initialisierung, kleine Artefakte
Interpreter-Runtimes	abhängig von Dependencies	Imports und Paketgröße wichtig
VM-basierte Runtimes	oft stärker initialisierungsabhängig	VM/JIT und Framework-Start können dominieren
Containerisierte Workloads	stark image- und plattformabhängig	Image-Größe, Cache und Netzwerk relevant
ML-Inference	oft durch Modell-Ladezeit geprägt	Modellgröße und Speicherpfad entscheidend

Technischer Deep Dive

Was passiert beim Cold Start?

1. Container/MicroVM starten
   └── Image pullen (wenn nicht gecached)
   └── Netzwerk konfigurieren
   └── Filesystem mounten

2. Runtime initialisieren
   └── Interpreter/VM starten
   └── Dependencies laden

3. Anwendungscode laden
   └── Handler-Funktion importieren
   └── Globale Initialisierung

4. Request verarbeiten
   └── Eigentliche Logik

Optimierungsstrategien

1. Provisioned Concurrency (AWS Lambda):

# serverless.yml
functions:
  api:
    handler: handler.main
    provisionedConcurrency: desired_warm_instances

2. Warmup-Requests:

# Regelmäßiger Warmup-Trigger, falls zur Plattform passend
import json

def handler(event, context):
    # Warmup-Request erkennen
    if event.get("source") == "warmup":
        return {"statusCode": 200, "body": "warm"}
    
    # Normale Logik
    return process_request(event)

3. Kleinere Deployments:

# ❌ Schlecht: Alles importieren
import pandas as pd
import numpy as np
import tensorflow as tf
import boto3
# ... große Dependencies erhöhen Start- und Ladezeit

# ✅ Besser: Lazy Loading
def handler(event, context):
    if event["type"] == "ml":
        import tensorflow as tf  # Nur wenn nötig
        return ml_inference(event)
    else:
        return simple_response(event)

4. Schnellere Runtimes:

VM-basierte Runtime → Native Image prüfen
Interpreter-Runtime → kritische Pfade ggf. kompiliert umsetzen
Große Frameworks → schlankere Runtime oder Lazy Loading prüfen

ML-Modell Cold Start

# Problem: Modell bei jedem Cold Start laden
def handler(event, context):
    model = load_model("model-uri")  # kann Cold Start dominieren
    return model.predict(event["data"])

# Lösung: Globale Initialisierung
model = None

def handler(event, context):
    global model
    if model is None:
        model = load_model("s3://bucket/model.pkl")
    return model.predict(event["data"])

# Noch besser: Model in Container-Image einbetten

Messung

import time

def handler(event, context):
    # Cold Start erkennen
    is_cold = not hasattr(handler, "_initialized")
    
    if is_cold:
        handler._initialized = True
        handler._start_time = time.time()
    
    # Metriken loggen
    print(json.dumps({
        "cold_start": is_cold,
        "init_duration_ms": context.get("initDuration", 0)
    }))
    
    return process(event)