AWS Lambda Cold Start Sorunu Nasıl Çözülür? 6 Optimizasyon Tekniği (2026)

? Lambda Initialization Aşamaları

❄️ Cold Start Senaryoları

1. İlk İstek: Lambda fonksiyonu deploy edildikten sonra ilk kez çağrılıyor
2. Ölçeklendirme: Mevcut instance'lar yetersiz, yeni instance gerekiyor
3. Idle Timeout: Fonksiyon 5-15 dakika kullanılmadı, AWS container'ı kapattı
4. Code Güncellemesi: Yeni deployment, tüm instance'lar yeniden başlatılıyor
5. Memory/Timeout Değişikliği: Konfigürasyon değişti, yeni container gerekiyor

CloudWatch Logs Insights Query

-- AWS Lambda Cold Start analizi
fields @timestamp, @duration, @initDuration, @memorySize
| filter @type = "REPORT"
| stats
    count(@initDuration) as coldStarts,
    avg(@initDuration) as avgColdStart,
    max(@initDuration) as maxColdStart,
    pct(@initDuration, 95) as p95ColdStart
    by bin(5m)

Python Fonksiyonda Init Duration Loglama

# lambda_function.py
import time
import os

# Global scope - sadece cold start'ta çalışır
init_start = time.time()
import boto3
import requests
from my_heavy_module import HeavyClass

init_duration = (time.time() - init_start) * 1000
print(f"[COLD START] Init duration: {init_duration:.2f}ms")

# Lambda handler
def lambda_handler(event, context):
    handler_start = time.time()

    # İş mantığı
    result = process_request(event)

    handler_duration = (time.time() - handler_start) * 1000
    print(f"[HANDLER] Execution duration: {handler_duration:.2f}ms")

    return {
        'statusCode': 200,
        'body': result
    }

AWS CLI ile Provisioned Concurrency

# Lambda fonksiyonuna provisioned concurrency ekle
aws lambda put-provisioned-concurrency-config \\
    --function-name my-api-function \\
    --provisioned-concurrent-executions 5 \\
    --qualifier PROD

# Mevcut ayarları kontrol et
aws lambda get-provisioned-concurrency-config \\
    --function-name my-api-function \\
    --qualifier PROD

Terraform ile Provisioned Concurrency

# main.tf
resource "aws_lambda_function" "api" {
  function_name = "my-api-function"
  runtime       = "python3.12"
  handler       = "lambda_function.lambda_handler"
  filename      = "deployment.zip"
  role          = aws_iam_role.lambda_role.arn
  memory_size   = 512
  timeout       = 30

  publish = true  # Versioning gerekli
}

resource "aws_lambda_alias" "prod" {
  name             = "PROD"
  function_name    = aws_lambda_function.api.function_name
  function_version = aws_lambda_function.api.version
}

resource "aws_lambda_provisioned_concurrency_config" "prod" {
  function_name                     = aws_lambda_function.api.function_name
  qualifier                         = aws_lambda_alias.prod.name
  provisioned_concurrent_executions = 5
}

Runtime Cold Start Karşılaştırması (512MB)

❌ Kötü Örnek: 50MB Package (Python)

# requirements.txt - Gereksiz bağımlılıklar
boto3==1.34.10      # Lambda'da zaten var!
botocore==1.34.10   # Lambda'da zaten var!
pandas==2.1.4       # 40MB+ (kullanılmıyor bile)
numpy==1.26.2       # 20MB+ (kullanılmıyor)
requests==2.31.0    # Gerekli
pydantic==2.5.3     # Gerekli

# Sonuç: 85MB zip → Cold start 650ms

✅ İyi Örnek: 5MB Package

# requirements.txt - Sadece gerekliler
requests==2.31.0    # Gerekli
pydantic==2.5.3     # Gerekli
# boto3 yok (AWS runtime'da mevcut)
# pandas/numpy yok (kullanılmıyor)

# Deployment script
pip install -r requirements.txt -t package/
cd package && zip -r ../deployment.zip . && cd ..
zip -g deployment.zip lambda_function.py

# Sonuç: 3.2MB zip → Cold start 220ms (%66 iyileşme)

Node.js Tree Shaking (Webpack/esbuild)

// esbuild.config.js - Lambda için optimize build
const esbuild = require('esbuild');

esbuild.build({
  entryPoints: ['src/index.js'],
  bundle: true,
  minify: true,
  platform: 'node',
  target: 'node20',
  outfile: 'dist/index.js',
  external: ['aws-sdk'],  // Lambda runtime'da mevcut
  treeShaking: true,      // Kullanılmayan kod sil
}).catch(() => process.exit(1));

// package.json
{
  "scripts": {
    "build": "node esbuild.config.js",
    "package": "cd dist && zip -r ../deployment.zip ."
  }
}

// Sonuç: 800KB bundle (önceden 15MB) → %85 küçülme

✅ VPC Configuration Best Practices

# terraform - Optimize VPC configuration
resource "aws_lambda_function" "vpc_function" {
  function_name = "vpc-optimized-function"
  runtime       = "python3.12"

  vpc_config {
    subnet_ids         = [
      aws_subnet.private_a.id,
      aws_subnet.private_b.id,
      aws_subnet.private_c.id  # Multi-AZ for resilience
    ]
    security_group_ids = [aws_security_group.lambda_sg.id]
  }

  # VPC içinde bile hızlı cold start için
  memory_size = 1024  # Daha fazla memory → daha hızlı network

  environment {
    variables = {
      USE_VPC_ENDPOINTS = "true"  # S3, DynamoDB için VPC endpoint kullan
    }
  }
}

# VPC Endpoints (NAT Gateway yerine)
resource "aws_vpc_endpoint" "s3" {
  vpc_id       = aws_vpc.main.id
  service_name = "com.amazonaws.${var.region}.s3"
  route_table_ids = [aws_route_table.private.id]
}

resource "aws_vpc_endpoint" "dynamodb" {
  vpc_id       = aws_vpc.main.id
  service_name = "com.amazonaws.${var.region}.dynamodb"
  route_table_ids = [aws_route_table.private.id]
}

❌ Kötü Örnek: Eager Loading (Python)

# lambda_function.py - TÜM import'lar global scope'ta
import json
import boto3
import pandas as pd  # 300ms+ yükleme süresi
import numpy as np   # 200ms+ yükleme süresi
from my_ml_model import load_model  # 500ms+ model yükleme

# Her cold start'ta toplam 1000ms+ sadece import'lardan!
s3 = boto3.client('s3')
model = load_model()  # Her cold start'ta model yüklenir

def lambda_handler(event, context):
    # Fonksiyon %90 durumda ML kullanmıyor ama yine de yükleniyor!
    if event.get('action') == 'predict':
        return predict_with_model(event['data'])
    else:
        return simple_response(event)

✅ İyi Örnek: Lazy Loading

# lambda_function.py - Conditional imports
import json
import boto3

# Sadece gerekli olanlar global scope'ta
s3 = boto3.client('s3')

# Ağır import'lar lazy-load
_model = None
def get_model():
    global _model
    if _model is None:
        import pandas as pd
        import numpy as np
        from my_ml_model import load_model
        _model = load_model()
    return _model

def lambda_handler(event, context):
    if event.get('action') == 'predict':
        model = get_model()  # Sadece gerektiğinde yükle
        return predict_with_model(event['data'], model)
    else:
        # ML import'ları hiç yüklenmedi → Cold start 180ms
        return simple_response(event)

# Sonuç: Normal isteklerde %85 daha hızlı cold start

Node.js Dynamic Import

// lambda_function.js - ES modules dynamic import
import { S3Client } from '@aws-sdk/client-s3';

const s3 = new S3Client({});

export const handler = async (event) => {
  if (event.action === 'process-image') {
    // Ağır image processing kütüphanesi sadece gerektiğinde yükle
    const sharp = await import('sharp');  // 150ms lazy load
    return processImage(event.imageKey, sharp);
  } else {
    // sharp hiç yüklenmedi → Cold start 120ms
    return { statusCode: 200, body: 'OK' };
  }
};

AWS Console'da SnapStart Aktifleştirme

1. Lambda Console → Functions → Seçiminizi yapın
2. Configuration → General configuration → Edit
3. SnapStart: "Published versions" seçin
4. Save → Publish new version

Terraform ile SnapStart

# main.tf
resource "aws_lambda_function" "java_api" {
  function_name = "spring-boot-api"
  runtime       = "java21"
  handler       = "com.example.Handler"
  filename      = "application.jar"
  role          = aws_iam_role.lambda_role.arn
  memory_size   = 1024
  timeout       = 30

  snap_start {
    apply_on = "PublishedVersions"
  }

  publish = true  # Versioning zorunlu
}

resource "aws_lambda_alias" "prod" {
  name             = "PROD"
  function_name    = aws_lambda_function.java_api.function_name
  function_version = aws_lambda_function.java_api.version
}

CloudWatch Dashboard (Terraform)

# cloudwatch_dashboard.tf
resource "aws_cloudwatch_dashboard" "lambda_performance" {
  dashboard_name = "lambda-cold-start-monitoring"

  dashboard_body = jsonencode({
    widgets = [
      {
        type = "metric"
        properties = {
          metrics = [
            ["AWS/Lambda", "Duration", { stat = "Average", label = "Avg Duration" }],
            ["...", { stat = "p95", label = "P95 Duration" }],
            [".", "InitDuration", { stat = "Average", label = "Avg Cold Start" }],
            ["...", { stat = "p99", label = "P99 Cold Start" }]
          ]
          period = 300
          region = "us-east-1"
          title  = "Lambda Performance Metrics"
        }
      }
    ]
  })
}

CloudWatch Alarm (Cold Start > 500ms)

# alarms.tf
resource "aws_cloudwatch_metric_alarm" "high_cold_start" {
  alarm_name          = "lambda-high-cold-start"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2
  metric_name         = "Duration"
  namespace           = "AWS/Lambda"
  period              = 300
  statistic           = "Average"
  threshold           = 500  # 500ms üzeri alarm
  alarm_description   = "Lambda cold start exceeds 500ms"
  alarm_actions       = [aws_sns_topic.alerts.arn]

  dimensions = {
    FunctionName = aws_lambda_function.api.function_name
  }
}