Cloud Run has 5-second cold starts causing timeouts. Optimize for low latency.

Step 1: Analyze Cold Start Components

Cold Start Breakdown:
├── Container scheduling: ~200ms (GCP infrastructure)
├── Image pull: ~500-2000ms (depends on image size)
├── Container start: ~200ms (runtime initialization)
└── Application init: ~1000-5000ms (your code)

Total: 2-8 seconds typical

Step 2: Optimize Container Image

# BEFORE: Large, slow image (1.2GB)
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "server.js"]

# AFTER: Optimized image (150MB)
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM gcr.io/distroless/nodejs18-debian11
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
COPY src/ ./src/
CMD ["src/server.js"]

# Python optimization
# BEFORE: 1GB image
FROM python:3.11

# AFTER: 200MB image
FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]

Step 3: Optimize Application Startup

// BEFORE: Blocking initialization
const express = require('express');
const { BigQuery } = require('@google-cloud/bigquery');
const { Storage } = require('@google-cloud/storage');

const app = express();
const bigquery = new BigQuery();  // Connects immediately
const storage = new Storage();    // Connects immediately

// Load all configs at startup
const config = loadAllConfigs();  // Blocks for 2s
const cache = warmCache();        // Blocks for 1s

app.listen(8080);

// AFTER: Lazy initialization
const express = require('express');
const app = express();

// Lazy-loaded clients
let bigquery, storage;

const getBigQuery = () => {
  if (!bigquery) {
    const { BigQuery } = require('@google-cloud/bigquery');
    bigquery = new BigQuery();
  }
  return bigquery;
};

const getStorage = () => {
  if (!storage) {
    const { Storage } = require('@google-cloud/storage');
    storage = new Storage();
  }
  return storage;
};

// Start listening immediately
const server = app.listen(process.env.PORT || 8080, () => {
  console.log('Server ready');  // Log this ASAP for Cloud Run
});

// Background initialization (non-blocking)
setImmediate(async () => {
  await warmCache();
  console.log('Cache warmed');
});

Step 4: Configure Minimum Instances

# Set minimum instances for production
gcloud run services update payment-webhook \
  --min-instances=2 \
  --region=us-central1

# Use different settings per environment
# Dev: 0 (save costs)
# Staging: 1
# Prod: 2-5

# Cloud Run service YAML
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: payment-webhook
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: "2"
        autoscaling.knative.dev/maxScale: "100"
    spec:
      containerConcurrency: 80
      timeoutSeconds: 30
      containers:
      - image: gcr.io/project/payment-webhook:latest
        resources:
          limits:
            cpu: "2"
            memory: "1Gi"

Step 5: Enable Startup CPU Boost

# Startup CPU boost gives 2x CPU during startup
gcloud run services update payment-webhook \
  --cpu-boost \
  --region=us-central1

# Or in Terraform
resource "google_cloud_run_service" "webhook" {
  template {
    metadata {
      annotations = {
        "run.googleapis.com/startup-cpu-boost" = "true"
      }
    }
  }
}

Step 6: Use Second Generation Execution Environment

# Gen2 has faster cold starts and better CPU
gcloud run services update payment-webhook \
  --execution-environment=gen2 \
  --region=us-central1

Step 7: Optimize Resource Allocation

# More CPU = faster startup
spec:
  containers:
  - resources:
      limits:
        cpu: "2"      # More CPU for faster init
        memory: "1Gi" # Enough for your app

# CPU allocation setting
metadata:
  annotations:
    # CPU always allocated (not just during requests)
    run.googleapis.com/cpu-throttling: "false"

Step 8: Implement Health Checks

// Fast health check endpoint
app.get('/_health', (req, res) => {
  res.status(200).send('OK');
});

// Separate readiness check (after initialization)
let isReady = false;

app.get('/_ready', (req, res) => {
  if (isReady) {
    res.status(200).send('Ready');
  } else {
    res.status(503).send('Not ready');
  }
});

// Mark ready after init completes
setImmediate(async () => {
  await initializeApp();
  isReady = true;
});

Step 9: Monitor Cold Start Metrics

# View cold start metrics in Cloud Monitoring
gcloud logging read \
  'resource.type="cloud_run_revision" AND
   textPayload:"Cold start"' \
  --format="table(timestamp,textPayload)"

# Create alert for high cold start ratio

resource "google_monitoring_alert_policy" "cold_start_alert" {
  display_name = "High Cold Start Ratio"

  conditions {
    display_name = "Cold starts > 10%"

    condition_threshold {
      filter = <<-EOT
        resource.type = "cloud_run_revision" AND
        metric.type = "run.googleapis.com/request_latencies" AND
        metric.labels.response_code_class = "2xx"
      EOT

      comparison      = "COMPARISON_GT"
      threshold_value = 5000  # 5 seconds
      duration        = "300s"

      aggregations {
        alignment_period     = "300s"
        per_series_aligner   = "ALIGN_PERCENTILE_99"
        cross_series_reducer = "REDUCE_MEAN"
      }
    }
  }
}

Cold Start Optimization Summary