AlestaSoft

Serverless mimarilerde en kritik performans sorunu AWS Lambda Cold Start (soğuk başlatma) gecikmeleridir. Lambda Cold Start Optimization teknikleriyle bu gecikmeleri %80'e kadar azaltabilirsiniz. Alesta Web olarak 2026'da geçerli en etkili optimizasyon stratejilerini paylaşıyoruz.
AWS Lambda Cold Start Nedir?
AWS Lambda Cold Start, bir Lambda fonksiyonunun ilk çağrıldığında veya uzun süre atıl kaldıktan sonra yeniden başlatıldığında yaşanan başlatma gecikmeleridir. Bu süre boyunca AWS şu işlemleri yapar:
? Lambda Initialization Aşamaları
| Aşama | Açıklama | Tipik Süre |
|---|---|---|
| 1. Download Code | Deployment package S3'ten indirilir | 50-200ms |
| 2. Start Runtime | Container ve runtime başlatılır | 100-400ms |
| 3. Init Code | Global scope ve import'lar çalıştırılır | 50-500ms |
| 4. Invoke Handler | Asıl fonksiyon kodu çalışır | Kodunuza bağlı |
Alesta Web müşteri projelerinde gözlemlediğimiz ortalama AWS Lambda Cold Start süreleri:
- Node.js 20: 150-300ms
- Python 3.12: 200-350ms
- Java 21 (normal): 800-2000ms
- Java 21 (SnapStart): 200-400ms
- .NET 8: 400-700ms
Lambda Cold Start Optimization yapmazsanız, özellikle düşük trafikli API'lerde kullanıcılar her istekte 1-3 saniye gecikme yaşayabilir.
Cold Start Neden Oluşur?
AWS Lambda Cold Start aşağıdaki durumlarda tetiklenir:
❄️ Cold Start Senaryoları
- İlk İstek: Lambda fonksiyonu deploy edildikten sonra ilk kez çağrılıyor
- Ölçeklendirme: Mevcut instance'lar yetersiz, yeni instance gerekiyor
- Idle Timeout: Fonksiyon 5-15 dakika kullanılmadı, AWS container'ı kapattı
- Code Güncellemesi: Yeni deployment, tüm instance'lar yeniden başlatılıyor
- Memory/Timeout Değişikliği: Konfigürasyon değişti, yeni container gerekiyor
Warm Start: Mevcut container yeniden kullanılır → 1-5ms gecikme
Cold Start: Yeni container başlatılır → 200-3000ms gecikme
Alesta Web projelerinde hedefimiz cold start oranını %5'in altında tutmak.
Cold Start Süresini Ölçme
Lambda Cold Start Optimization yapmadan önce mevcut durumu ölçün:
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
}Alesta Web e-commerce API'si (Python 3.12, 512MB):
- Optimizasyon öncesi: Cold start 780ms, warm start 45ms
- Optimizasyon sonrası: Cold start 180ms, warm start 12ms
- İyileşme: %77 cold start azalması
Optimizasyon 1: Provisioned Concurrency
En etkili Lambda Cold Start Optimization yöntemi, Provisioned Concurrency özelliğidir:
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 PRODTerraform 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
}Provisioned Concurrency maliyeti normal Lambda'dan 2-3x daha yüksek. Sadece kritik endpoint'lerde kullanın:
- API Gateway endpoints: Low-latency gerektiren REST/GraphQL API'ler
- Payment processing: Ödeme işlemleri (cold start kabul edilemez)
- Real-time webhooks: Stripe webhook'ları
Batch processing, scheduled jobs: Provisioned Concurrency gereksiz, maliyeti artırır.
Optimizasyon 2: Hafif Runtime Seçimi (Node.js, Python)
AWS Lambda Cold Start süresi runtime'a göre büyük fark gösterir:
Runtime Cold Start Karşılaştırması (512MB)
| Runtime | Ortalama Cold Start | Önerilen Kullanım |
|---|---|---|
| Node.js 20 | 150-300ms ✅ | REST API, microservices |
| Python 3.12 | 200-350ms ✅ | Data processing, ML inference |
| Go 1.x | 100-250ms ✅✅ | Ultra low-latency API |
| Java 21 (SnapStart) | 200-400ms ✅ | Enterprise Java apps |
| Java 21 (normal) | 800-2000ms ❌ | SnapStart kullanılmalı |
| .NET 8 | 400-700ms ⚠️ | C# zorunluysa, AOT compilation |
Alesta Web yeni projeler için Node.js 20 veya Python 3.12 öneriyoruz. En iyi Lambda Cold Start Optimization dengesini sağlıyorlar.
Optimizasyon 3: Deployment Package Boyutu Küçültme
Deployment package boyutu doğrudan AWS Lambda Cold Start süresini etkiler:
❌ 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üçülmeAlesta Web müşteri projesi (Node.js REST API):
- Öncesi: 22MB deployment → Cold start 480ms
- Sonrası: 1.8MB deployment → Cold start 140ms
- İyileşme: %71 cold start azalması
Optimizasyon 4: VPC Optimizasyonu (Hyperplane ENI)
VPC içindeki Lambda fonksiyonları 2019 öncesi 10+ saniye cold start yaşıyordu. AWS Hyperplane ENI ile bu sorun çözüldü ama hala optimizasyon gerekiyor:
✅ 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]
}Lambda Cold Start Optimization için VPC'den kaçının (gerekli değilse):
- Kullanma: Public API, S3/DynamoDB erişimi → VPC gereksiz
- Kullan: RDS/ElastiCache erişimi → VPC zorunlu
- Kullan: On-premise network (VPN/Direct Connect) → VPC zorunlu
Optimizasyon 5: Lazy Loading ve Import Optimization
Global scope'ta gereksiz import'lar AWS Lambda Cold Start süresini artırır:
❌ 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 startNode.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' };
}
};Optimizasyon 6: SnapStart (Java 11+)
Java uygulamaları için en etkili Lambda Cold Start Optimization özelliği SnapStart:
AWS Console'da SnapStart Aktifleştirme
- Lambda Console → Functions → Seçiminizi yapın
- Configuration → General configuration → Edit
- SnapStart: "Published versions" seçin
- 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
}Alesta Web Spring Boot API (Java 21, 1GB memory):
- SnapStart öncesi: Cold start 1850ms
- SnapStart sonrası: Cold start 320ms
- İyileşme: %83 cold start azalması
- Sadece Java 11, Java 17, Java 21 runtime'larında çalışır
- Provisioned Concurrency ile birlikte kullanılamaz
- Random değerler, timestamp'ler snapshot'tan sonra yeniden generate edilmeli
Monitoring ve CloudWatch Metrics
Lambda Cold Start Optimization sonuçlarını sürekli izleyin:
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
}
}✅ Özet: Lambda Cold Start Optimization
AWS Lambda Cold Start optimizasyonu ile 200ms altı başlatma süreleri mümkün. Alesta Web olarak en etkili bulduğumuz yöntemler: Provisioned Concurrency (kritik API'ler), hafif runtime seçimi (Node.js/Python), deployment package küçültme (%70+ iyileşme).
Hızlı Kontrol Listesi:
- ✅ Runtime: Node.js 20 veya Python 3.12 mi?
- ✅ Deployment package: 10MB altında mı?
- ✅ Lazy loading: Ağır import'lar conditional mı?
- ✅ VPC: Gereksiz VPC config var mı?
- ✅ Provisioned Concurrency: Kritik endpoint'lerde aktif mi?
- ✅ Monitoring: CloudWatch cold start metrikleri izleniyor mu?
Faydalı Kaynaklar:
- AWS Lambda Docs: docs.aws.amazon.com/lambda
- Lambda Power Tuning: github.com/aws-lambda-power-tuning
- Alesta Web Serverless Hosting: alestaweb.com
© 2026 Alesta Web - AWS serverless mimarisi uzmanınız. Tüm hakları saklıdır.

