AWS Lambda Memory Allocation ve Performance Tuning: Kapsamlı Rehber

// Memory allocation doğrudan CPU gücünü etkiler
const memoryToCpuMapping = {
  '128MB':   '~0.083 vCPU',  // En yavaş execution
  '512MB':   '~0.333 vCPU',  // Yaygın baseline
  '1024MB':  '~0.667 vCPU',  // Çoğu workload için sweet spot
  '1769MB':  '~1.0 vCPU',    // Tam vCPU ayrıldı
  '3008MB':  '~1.79 vCPU',   // Multi-core bölgesi
  '10240MB': '~6.0 vCPU'     // Maksimum allocation
};

# Image resize function benchmark (2MB resimler işliyor)
Memory: 128MB  → Execution: 8.2s   → Cost: $0.000017
Memory: 512MB  → Execution: 2.1s   → Cost: $0.000017  
Memory: 1024MB → Execution: 1.3s   → Cost: $0.000022
Memory: 1769MB → Execution: 0.9s   → Cost: $0.000027
Memory: 3008MB → Execution: 0.8s   → Cost: $0.000041

// comprehensive-benchmark.ts
import { performance } from 'perf_hooks';

interface BenchmarkResult {
  memoryUsed: number;
  executionTime: number;
  coldStart: boolean;
  gcEvents: number;
  cpuIntensive: boolean;
}

export class LambdaBenchmark {
  private results: BenchmarkResult[] = [];
  private coldStart: boolean = !global.isWarm;

  constructor() {
    global.isWarm = true;
    // Garbage collection monitoring aktifleştir
    if (global.gc) {
      this.monitorGC();
    }
  }

  private monitorGC() {
    const originalGC = global.gc;
    let gcCount = 0;
    
    global.gc = (...args) => {
      gcCount++;
      console.log(`GC Event ${gcCount} at ${Date.now()}`);
      return originalGC.apply(this, args);
    };
  }

  async benchmark<T>(
    operation: () => Promise<T>,
    label: string
  ): Promise<{ result: T; metrics: BenchmarkResult }> {
    const startTime = performance.now();
    const startMemory = process.memoryUsage();

    // Test öncesi garbage collection zorla
    if (global.gc) global.gc();

    const result = await operation();

    const endTime = performance.now();
    const endMemory = process.memoryUsage();

    const metrics: BenchmarkResult = {
      memoryUsed: endMemory.heapUsed - startMemory.heapUsed,
      executionTime: endTime - startTime,
      coldStart: this.coldStart,
      gcEvents: this.getGCEvents(),
      cpuIntensive: this.detectCPUIntensiveOperation(endTime - startTime)
    };

    console.log(`Benchmark [${label}]:`, metrics);
    this.results.push(metrics);

    return { result, metrics };
  }

  private detectCPUIntensiveOperation(duration: number): boolean {
    // >100ms süren operasyonlar muhtemelen CPU-bound
    return duration > 100;
  }

  private getGCEvents(): number {
    // Implementation GC monitoring kurulumunuza bağlı
    return 0; // Örnek için basitleştirildi
  }
}

// Lambda'nızda kullanım
export const handler = async (event: any) => {
  const benchmark = new LambdaBenchmark();
  
  const { result } = await benchmark.benchmark(async () => {
    return await processLargeDataset(event.data);
  }, 'data-processing');

  return result;
};

# Birden fazla memory konfigürasyonu deploy et ve test et
aws lambda create-function --memory-size 512 --function-name test-512
aws lambda create-function --memory-size 1024 --function-name test-1024
aws lambda create-function --memory-size 1769 --function-name test-1769

# Otomatik benchmark script
for memory in 512 1024 1536 1769 3008; do
  echo "${memory}MB konfigürasyonunu test ediliyor..."
  aws lambda invoke \
    --function-name "test-${memory}" \
    --payload file://test-payload.json \
    --log-type Tail \
    response-${memory}.json
done

// Workload tipine göre memory allocation
const workloadOptimization = {
  // API Gateway proxy function'ları
  simpleAPI: {
    memoryMB: 512,
    reason: "Düşük CPU, hızlı response time önceliği"
  },
  
  // Database operasyonları
  databaseIntensive: {
    memoryMB: 1024, 
    reason: "Query processing + connection overhead için balanced CPU"
  },
  
  // Image/file processing
  fileProcessing: {
    memoryMB: 1769,
    reason: "CPU-intensive, tam vCPU'dan faydalanır"
  },
  
  // ML inference
  machineLearning: {
    memoryMB: 3008,
    reason: "Model için memory + inference için multi-core"
  },
  
  // Data transformation
  dataETL: {
    memoryMB: 1769,
    reason: "CPU-bound operasyonlar, optimal maliyet/performans"
  }
};

// Memory leak detection ve prevention
export class MemoryManager {
  private memoryThreshold = 0.8; // Ayrılan memory'nin %80'i
  private checkInterval: NodeJS.Timeout;

  constructor() {
    this.startMemoryMonitoring();
  }

  private startMemoryMonitoring() {
    this.checkInterval = setInterval(() => {
      const usage = process.memoryUsage();
      const allocatedMemory = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || '512') * 1024 * 1024;
      const memoryUsageRatio = usage.heapUsed / allocatedMemory;

      if (memoryUsageRatio > this.memoryThreshold) {
        console.warn('Yüksek memory kullanımı tespit edildi:', {
          heapUsed: Math.round(usage.heapUsed / 1024 / 1024) + 'MB',
          heapTotal: Math.round(usage.heapTotal / 1024 / 1024) + 'MB',
          external: Math.round(usage.external / 1024 / 1024) + 'MB',
          usage: Math.round(memoryUsageRatio * 100) + '%'
        });

        // Garbage collection zorla
        if (global.gc) {
          global.gc();
        }
      }
    }, 5000); // Her 5 saniyede kontrol et
  }

  cleanup() {
    if (this.checkInterval) {
      clearInterval(this.checkInterval);
    }
  }
}

// Kullanım pattern'i
const memoryManager = new MemoryManager();

export const handler = async (event: any) => {
  try {
    return await processEvent(event);
  } finally {
    // Her invocation sonrası temizle
    memoryManager.cleanup();
  }
};

// Garbage collection optimizasyonu
// Bunları environment variable olarak veya deployment'ta ayarla
const gcOptimizations = {
  NODE_OPTIONS: [
    '--max-old-space-size=1024',    // Lambda memory allocation'a match et
    '--max-semi-space-size=128',    // Young generation optimize et
    '--gc-interval=100',            // Daha sık GC cycle'ları
    '--optimize-for-size'           // Speed yerine memory için optimize et
  ].join(' ')
};

// Memory-intensive operasyonlar için manual GC triggering
const processLargeDataset = async (data: any[]) => {
  const chunks = chunkArray(data, 1000);
  const results = [];

  for (const chunk of chunks) {
    const processed = await processChunk(chunk);
    results.push(processed);
    
    // Memory buildup'ı önlemek için chunk'lar arası GC zorla
    if (global.gc && results.length % 10 === 0) {
      global.gc();
    }
  }

  return results;
};

// cost-calculator.ts
interface LambdaCostParams {
  memoryMB: number;
  avgExecutionMs: number;
  invocationsPerMonth: number;
  region: 'us-east-1' | 'us-west-2' | 'eu-west-1';
}

interface CostBreakdown {
  computeCost: number;
  requestCost: number;
  totalMonthlyCost: number;
  costPerInvocation: number;
  performanceRating: number;
}

export class LambdaCostCalculator {
  // 2025 AWS fiyatları (fiyatlar region'a göre değişir)
  private pricing = {
    'us-east-1': {
      computePerGBSecond: 0.0000166667,
      requestPer1M: 0.20
    }
  };

  calculateCost(params: LambdaCostParams): CostBreakdown {
    const { memoryMB, avgExecutionMs, invocationsPerMonth, region } = params;
    const pricing = this.pricing[region];

    // Memory'yi GB'ye ve execution time'ı saniyeye çevir
    const memoryGB = memoryMB / 1024;
    const executionSeconds = avgExecutionMs / 1000;

    // Compute cost hesapla
    const gbSeconds = memoryGB * executionSeconds * invocationsPerMonth;
    const computeCost = gbSeconds * pricing.computePerGBSecond;

    // Request cost hesapla
    const requestCost = (invocationsPerMonth / 1000000) * pricing.requestPer1M;

    const totalMonthlyCost = computeCost + requestCost;
    const costPerInvocation = totalMonthlyCost / invocationsPerMonth;

    // Performance rating (düşük execution time = yüksek rating)
    const performanceRating = Math.max(1, 10 - (avgExecutionMs / 100));

    return {
      computeCost,
      requestCost,
      totalMonthlyCost,
      costPerInvocation,
      performanceRating
    };
  }

  findOptimalMemory(
    baseParams: Omit<LambdaCostParams, 'memoryMB'>,
    performanceProfile: { memory: number; executionMs: number }[]
  ): { memory: number; cost: number; savings: number } {
    const scenarios = performanceProfile.map(profile => ({
      ...profile,
      cost: this.calculateCost({
        ...baseParams,
        memoryMB: profile.memory,
        avgExecutionMs: profile.executionMs
      })
    }));

    // En iyi cost-performance oranına sahip konfigürasyonu bul
    const optimal = scenarios.reduce((best, current) => 
      (current.cost.totalMonthlyCost / current.cost.performanceRating) <
      (best.cost.totalMonthlyCost / best.cost.performanceRating) 
        ? current : best
    );

    const baseline = scenarios[0]; // İlkinin baseline olduğunu varsayıyor
    const savings = baseline.cost.totalMonthlyCost - optimal.cost.totalMonthlyCost;

    return {
      memory: optimal.memory,
      cost: optimal.cost.totalMonthlyCost,
      savings
    };
  }
}

// Kullanım örneği
const calculator = new LambdaCostCalculator();

const performanceData = [
  { memory: 512, executionMs: 2100 },
  { memory: 1024, executionMs: 1300 },
  { memory: 1769, executionMs: 900 },
  { memory: 3008, executionMs: 800 }
];

const optimal = calculator.findOptimalMemory({
  avgExecutionMs: 0, // Override edilecek
  invocationsPerMonth: 1000000,
  region: 'us-east-1'
}, performanceData);

console.log(`Optimal konfigürasyon: ${optimal.memory}MB`);
console.log(`Aylık tasarruf: $${optimal.savings.toFixed(2)}`);

// adaptive-processing.ts
export class AdaptiveProcessor {
  private availableMemoryMB: number;
  private processingStrategy: 'small' | 'medium' | 'large';

  constructor() {
    this.availableMemoryMB = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || '512');
    this.processingStrategy = this.determineStrategy();
  }

  private determineStrategy(): 'small' | 'medium' | 'large' {
    if (this.availableMemoryMB >= 3008) return 'large';
    if (this.availableMemoryMB >= 1024) return 'medium';
    return 'small';
  }

  async processData(data: any[]): Promise<any[]> {
    switch (this.processingStrategy) {
      case 'large':
        // Paralel operasyonlarla her şeyi memory'de işle
        return await this.parallelProcessing(data);
      
      case 'medium':
        // Orta memory kullanımıyla batch processing
        return await this.batchProcessing(data, 1000);
      
      case 'small':
        // Memory kullanımını minimize etmek için stream processing
        return await this.streamProcessing(data, 100);
    }
  }

  private async parallelProcessing(data: any[]): Promise<any[]> {
    // Tüm mevcut CPU core'ları kullan
    const chunks = this.chunkArray(data, Math.ceil(data.length / 4));
    const promises = chunks.map(chunk => this.processChunk(chunk));
    const results = await Promise.all(promises);
    return results.flat();
  }

  private async batchProcessing(data: any[], batchSize: number): Promise<any[]> {
    const results = [];
    for (let i = 0; i < data.length; i += batchSize) {
      const batch = data.slice(i, i + batchSize);
      const processed = await this.processChunk(batch);
      results.push(...processed);
      
      // Batch'lar arası GC'ye izin ver
      if (global.gc && i % (batchSize * 5) === 0) {
        global.gc();
      }
    }
    return results;
  }

  private async streamProcessing(data: any[], chunkSize: number): Promise<any[]> {
    const results = [];
    for (let i = 0; i < data.length; i += chunkSize) {
      const chunk = data.slice(i, i + chunkSize);
      const processed = await this.processChunk(chunk);
      results.push(...processed);
    }
    return results;
  }

  private chunkArray<T>(array: T[], size: number): T[][] {
    return Array.from({ length: Math.ceil(array.length / size) }, (_, i) =>
      array.slice(i * size, i * size + size)
    );
  }

  private async processChunk(chunk: any[]): Promise<any[]> {
    // Gerçek processing mantığınız buraya
    return chunk.map(item => ({ ...item, processed: true }));
  }
}

// memory-aware-cache.ts
export class MemoryAwareCache {
  private cache = new Map<string, any>();
  private maxMemoryUsage = 0.6; // Cache için mevcut memory'nin maksimum %60'ını kullan
  private availableMemoryBytes: number;

  constructor() {
    this.availableMemoryBytes = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || '512') * 1024 * 1024;
  }

  set(key: string, value: any): void {
    const currentUsage = process.memoryUsage().heapUsed;
    const maxCacheMemory = this.availableMemoryBytes * this.maxMemoryUsage;

    if (currentUsage < maxCacheMemory) {
      this.cache.set(key, {
        value,
        timestamp: Date.now(),
        size: this.estimateObjectSize(value)
      });
    } else {
      // Cache dolu, LRU eviction implement et
      this.evictLeastRecentlyUsed();
      this.cache.set(key, {
        value,
        timestamp: Date.now(),
        size: this.estimateObjectSize(value)
      });
    }
  }

  get(key: string): any {
    const entry = this.cache.get(key);
    if (entry) {
      // LRU için timestamp güncelle
      entry.timestamp = Date.now();
      return entry.value;
    }
    return null;
  }

  private evictLeastRecentlyUsed(): void {
    let oldestKey = '';
    let oldestTime = Date.now();

    for (const [key, entry] of this.cache.entries()) {
      if (entry.timestamp < oldestTime) {
        oldestTime = entry.timestamp;
        oldestKey = key;
      }
    }

    if (oldestKey) {
      this.cache.delete(oldestKey);
    }
  }

  private estimateObjectSize(obj: any): number {
    // Memory'deki object boyutunun kaba tahmini
    return JSON.stringify(obj).length * 2; // Kaba yaklaşım
  }

  getCacheStats(): {
    entries: number;
    estimatedMemoryMB: number;
    memoryUsagePercent: number;
  } {
    let totalSize = 0;
    for (const entry of this.cache.values()) {
      totalSize += entry.size;
    }

    return {
      entries: this.cache.size,
      estimatedMemoryMB: totalSize / 1024 / 1024,
      memoryUsagePercent: (totalSize / this.availableMemoryBytes) * 100
    };
  }
}

// performance-monitor.ts
import { CloudWatch } from '@aws-sdk/client-cloudwatch';

export class PerformanceMonitor {
  private cloudWatch: CloudWatch;
  private functionName: string;

  constructor() {
    this.cloudWatch = new CloudWatch({});
    this.functionName = process.env.AWS_LAMBDA_FUNCTION_NAME || 'unknown';
  }

  async trackPerformanceMetrics(
    executionTime: number,
    memoryUsed: number,
    cpuIntensive: boolean
  ): Promise<void> {
    const metrics = [
      {
        MetricName: 'ExecutionTime',
        Value: executionTime,
        Unit: 'Milliseconds',
        Dimensions: [
          { Name: 'FunctionName', Value: this.functionName },
          { Name: 'MemorySize', Value: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || '512' }
        ]
      },
      {
        MetricName: 'MemoryUtilization',
        Value: memoryUsed,
        Unit: 'Bytes',
        Dimensions: [
          { Name: 'FunctionName', Value: this.functionName }
        ]
      },
      {
        MetricName: 'CPUIntensiveOperations',
        Value: cpuIntensive ? 1 : 0,
        Unit: 'Count',
        Dimensions: [
          { Name: 'FunctionName', Value: this.functionName }
        ]
      }
    ];

    await this.cloudWatch.putMetricData({
      Namespace: 'Lambda/Performance',
      MetricData: metrics
    });
  }

  async trackCostMetrics(estimatedCost: number): Promise<void> {
    await this.cloudWatch.putMetricData({
      Namespace: 'Lambda/Cost',
      MetricData: [
        {
          MetricName: 'EstimatedCost',
          Value: estimatedCost,
          Unit: 'None',
          Dimensions: [
            { Name: 'FunctionName', Value: this.functionName }
          ]
        }
      ]
    });
  }
}

// x-ray-profiling.ts
import * as AWSXRay from 'aws-xray-sdk-core';

export const handler = AWSXRay.captureAsyncFunc('handler', async (event: any) => {
  const segment = AWSXRay.getSegment();
  
  // Memory allocation tracking
  const memorySubsegment = segment?.addNewSubsegment('memory-tracking');
  const initialMemory = process.memoryUsage();
  memorySubsegment?.addAnnotation('initial_memory_mb', Math.round(initialMemory.heapUsed / 1024 / 1024));
  
  try {
    // Subsegment'lerle business logic
    const processingSegment = segment?.addNewSubsegment('data-processing');
    const result = await processData(event.data);
    processingSegment?.close();

    // Processing sonrası memory kullanımı
    const finalMemory = process.memoryUsage();
    memorySubsegment?.addAnnotation('final_memory_mb', Math.round(finalMemory.heapUsed / 1024 / 1024));
    memorySubsegment?.addAnnotation('memory_delta_mb', Math.round((finalMemory.heapUsed - initialMemory.heapUsed) / 1024 / 1024));
    
    return result;
  } finally {
    memorySubsegment?.close();
  }
});

const processData = async (data: any) => {
  const segment = AWSXRay.getSegment();
  const subsegment = segment?.addNewSubsegment('data-transformation');
  
  try {
    // Performance analizi için metadata ekle
    subsegment?.addMetadata('input_size', JSON.stringify(data).length);
    subsegment?.addAnnotation('cpu_intensive', true);
    
    const result = await heavyProcessingOperation(data);
    
    subsegment?.addMetadata('output_size', JSON.stringify(result).length);
    return result;
  } finally {
    subsegment?.close();
  }
};

// Çözüm: Memory circuit breaker implement et
class MemoryCircuitBreaker {
  private errorCount = 0;
  private lastError = 0;
  private threshold = 5;
  private timeout = 60000; // 1 dakika

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.isCircuitOpen()) {
      throw new Error('Circuit breaker açık - memory sorunları tespit edildi');
    }

    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      if (error instanceof Error && error.message.includes('out of memory')) {
        this.onError();
      }
      throw error;
    }
  }

  private isCircuitOpen(): boolean {
    return this.errorCount >= this.threshold && 
           (Date.now() - this.lastError) < this.timeout;
  }

  private onSuccess(): void {
    this.errorCount = 0;
  }

  private onError(): void {
    this.errorCount++;
    this.lastError = Date.now();
  }
}