# Lambda実行フロー
execution_flow = {
    "1. コールドスタート": {
        "処理": "実行環境の初期化",
        "時間": "100ms - 数秒",
        "発生条件": "新しいコンテナが必要な場合"
    },
    "2. 初期化": {
        "処理": "関数コードの読み込み・初期化",
        "時間": "数十ms - 数百ms",
        "最適化ポイント": "import文、グローバル変数"
    },
    "3. 実行": {
        "処理": "ハンドラー関数の実行",
        "時間": "実装による",
        "最適化ポイント": "アルゴリズム、外部API呼び出し"
    }
}

# メモリ設定とCPU性能の関係
memory_cpu_mapping = {
    "128MB": "0.083 vCPU相当",
    "512MB": "0.33 vCPU相当", 
    "1024MB": "0.67 vCPU相当",
    "1792MB": "1 vCPU相当",
    "3008MB": "1.77 vCPU相当",
    "10240MB": "6 vCPU相当"
}

import json
import time
import psutil

def lambda_handler(event, context):
    start_time = time.time()

    # メモリ使用量監視
    process = psutil.Process()
    memory_info = process.memory_info()

    # 実際の処理
    result = perform_heavy_computation()

    end_time = time.time()

    # パフォーマンス情報をログ出力
    performance_data = {
        "execution_time": end_time - start_time,
        "memory_used_mb": memory_info.rss / 1024 / 1024,
        "memory_allocated_mb": context.memory_limit_in_mb,
        "remaining_time_ms": context.get_remaining_time_in_millis()
    }

    print(f"Performance: {json.dumps(performance_data)}")

    return {
        'statusCode': 200,
        'body': json.dumps(result)
    }

def perform_heavy_computation():
    # CPU集約的な処理の例
    result = []
    for i in range(1000000):
        result.append(i ** 2)
    return len(result)

# Terraformでのメモリ設定例
resource "aws_lambda_function" "optimized_function" {
  filename         = "function.zip"
  function_name    = "optimized-lambda"
  role            = aws_iam_role.lambda_role.arn
  handler         = "index.lambda_handler"
  runtime         = "python3.11"

  # パフォーマンステスト結果に基づく最適値
  memory_size     = 1024  # 512MBから1024MBに変更で30%高速化
  timeout         = 30

  environment {
    variables = {
      MEMORY_SIZE = "1024"
    }
  }
}

# Provisioned Concurrency設定（Terraform）
resource "aws_lambda_provisioned_concurrency_config" "lambda_pc" {
  function_name                     = aws_lambda_function.optimized_function.function_name
  provisioned_concurrent_executions = 10
  qualifier                        = aws_lambda_function.optimized_function.version
}

# CloudWatch Scheduledイベントでウォームアップ
resource "aws_cloudwatch_event_rule" "lambda_warmup" {
  name                = "lambda-warmup"
  description         = "Keep Lambda warm"
  schedule_expression = "rate(5 minutes)"
}

resource "aws_cloudwatch_event_target" "lambda_target" {
  rule      = aws_cloudwatch_event_rule.lambda_warmup.name
  target_id = "LambdaTarget"
  arn       = aws_lambda_function.optimized_function.arn

  input = jsonencode({
    "warmup": true
  })
}

import json
import boto3
import redis
from functools import lru_cache

# グローバル変数での接続オブジェクト初期化
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('my-table')

# Redis接続プール（再利用）
redis_client = redis.Redis(
    host='elasticache-endpoint',
    port=6379,
    connection_pool_max_connections=10
)

@lru_cache(maxsize=128)
def get_config_value(key):
    """設定値のキャッシュ"""
    response = table.get_item(Key={'config_key': key})
    return response.get('Item', {}).get('value')

def lambda_handler(event, context):
    # ウォームアップリクエストの処理
    if event.get('warmup'):
        return {
            'statusCode': 200,
            'body': json.dumps({'message': 'Warmed up'})
        }

    # 実際のビジネスロジック
    config_value = get_config_value('api_endpoint')

    # Redis キャッシュの活用
    cache_key = f"user:{event.get('user_id')}"
    cached_data = redis_client.get(cache_key)

    if cached_data:
        user_data = json.loads(cached_data)
    else:
        user_data = fetch_user_data(event.get('user_id'))
        redis_client.setex(cache_key, 300, json.dumps(user_data))

    return {
        'statusCode': 200,
        'body': json.dumps(user_data)
    }

def fetch_user_data(user_id):
    """ユーザーデータ取得"""
    response = table.get_item(Key={'user_id': user_id})
    return response.get('Item', {})

import asyncio
import aiohttp
import concurrent.futures
from typing import List, Dict

async def fetch_data_async(session: aiohttp.ClientSession, url: str) -> Dict:
    """非同期でのデータ取得"""
    async with session.get(url) as response:
        return await response.json()

async def process_multiple_apis(urls: List[str]) -> List[Dict]:
    """複数APIの並列処理"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_data_async(session, url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return [r for r in results if not isinstance(r, Exception)]

def lambda_handler(event, context):
    # 複数のAPIエンドポイントを並列処理
    api_urls = [
        'https://api1.example.com/data',
        'https://api2.example.com/data', 
        'https://api3.example.com/data'
    ]

    # 非同期処理の実行
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    try:
        results = loop.run_until_complete(process_multiple_apis(api_urls))
        return {
            'statusCode': 200,
            'body': json.dumps({
                'results': results,
                'count': len(results)
            })
        }
    finally:
        loop.close()

import boto3
from boto3.dynamodb.conditions import Key, Attr

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('user-data')

def optimized_query_example(user_id: str, start_date: str, end_date: str):
    """最適化されたDynamoDBクエリ"""

    # 1. 適切なインデックスの使用
    response = table.query(
        IndexName='user-date-index',  # GSIを使用
        KeyConditionExpression=Key('user_id').eq(user_id) & 
                              Key('created_date').between(start_date, end_date),
        # 2. 必要な属性のみ取得
        ProjectionExpression='user_id, created_date, #data',
        ExpressionAttributeNames={'#data': 'data'},
        # 3. 結果数制限
        Limit=100
    )

    return response['Items']

def batch_get_optimization(user_ids: List[str]):
    """バッチ取得の最適化"""

    # 25件ずつのバッチに分割（DynamoDBの制限）
    batch_size = 25
    all_items = []

    for i in range(0, len(user_ids), batch_size):
        batch_keys = user_ids[i:i + batch_size]

        response = dynamodb.batch_get_item(
            RequestItems={
                'user-data': {
                    'Keys': [{'user_id': uid} for uid in batch_keys],
                    'ProjectionExpression': 'user_id, #name, email',
                    'ExpressionAttributeNames': {'#name': 'name'}
                }
            }
        )

        all_items.extend(response['Responses']['user-data'])

    return all_items

# requirements.txt（レイヤー用）
requests==2.31.0
boto3==1.28.0
redis==4.6.0
numpy==1.24.0

# Lambda関数のコード（レイヤー使用）
import json
import requests  # レイヤーから読み込み
import numpy as np  # レイヤーから読み込み

def lambda_handler(event, context):
    # 外部ライブラリを使用した処理
    data = np.array(event.get('numbers', []))
    result = np.mean(data)

    return {
        'statusCode': 200,
        'body': json.dumps({
            'mean': float(result),
            'count': len(data)
        })
    }

# レイヤー作成スクリプト
#!/bin/bash

# レイヤー用ディレクトリ作成
mkdir -p layer/python

# 依存関係インストール
pip install -r requirements.txt -t layer/python/

# レイヤーZIPファイル作成
cd layer
zip -r ../lambda-layer.zip .
cd ..

# AWS CLIでレイヤー作成
aws lambda publish-layer-version \
    --layer-name my-python-layer \
    --zip-file fileb://lambda-layer.zip \
    --compatible-runtimes python3.11 \
    --description "Common Python libraries"

import urllib3
from urllib3.util.retry import Retry

# グローバルレベルでの接続プール設定
http = urllib3.PoolManager(
    num_pools=10,
    maxsize=10,
    retries=Retry(
        total=3,
        backoff_factor=0.3,
        status_forcelist=[500, 502, 503, 504]
    )
)

def lambda_handler(event, context):
    # 最適化された HTTP リクエスト
    response = http.request(
        'GET',
        'https://api.example.com/data',
        headers={'User-Agent': 'Lambda-Function/1.0'},
        timeout=5.0
    )

    if response.status == 200:
        return {
            'statusCode': 200,
            'body': response.data.decode('utf-8')
        }
    else:
        return {
            'statusCode': response.status,
            'body': json.dumps({'error': 'API request failed'})
        }

from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
import boto3
import json

# AWS SDKの自動トレーシング
patch_all()

@xray_recorder.capture('lambda_handler')
def lambda_handler(event, context):

    # サブセグメントでの詳細トレーシング
    with xray_recorder.in_subsegment('data_processing'):
        processed_data = process_data(event.get('data', []))

    with xray_recorder.in_subsegment('database_query'):
        result = query_database(processed_data)

    return {
        'statusCode': 200,
        'body': json.dumps(result)
    }

@xray_recorder.capture('process_data')
def process_data(data):
    # データ処理ロジック
    return [item * 2 for item in data]

@xray_recorder.capture('query_database')
def query_database(data):
    # データベースクエリ
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('processed-data')

    # バッチ書き込み
    with table.batch_writer() as batch:
        for item in data:
            batch.put_item(Item={'id': str(item), 'value': item})

    return {'processed_count': len(data)}

import boto3
import time
from datetime import datetime

cloudwatch = boto3.client('cloudwatch')

def lambda_handler(event, context):
    start_time = time.time()

    try:
        # ビジネスロジック実行
        result = execute_business_logic(event)

        # 成功メトリクス送信
        send_custom_metric('BusinessLogic.Success', 1)

        return {
            'statusCode': 200,
            'body': json.dumps(result)
        }

    except Exception as e:
        # エラーメトリクス送信
        send_custom_metric('BusinessLogic.Error', 1)
        raise

    finally:
        # 実行時間メトリクス送信
        execution_time = (time.time() - start_time) * 1000
        send_custom_metric('BusinessLogic.ExecutionTime', execution_time, 'Milliseconds')

def send_custom_metric(metric_name: str, value: float, unit: str = 'Count'):
    """カスタムメトリクスをCloudWatchに送信"""
    try:
        cloudwatch.put_metric_data(
            Namespace='Lambda/CustomMetrics',
            MetricData=[
                {
                    'MetricName': metric_name,
                    'Value': value,
                    'Unit': unit,
                    'Timestamp': datetime.utcnow()
                }
            ]
        )
    except Exception as e:
        print(f"Failed to send metric {metric_name}: {e}")

def execute_business_logic(event):
    # 実際のビジネスロジック
    return {'processed': True, 'timestamp': datetime.utcnow().isoformat()}

import boto3
import json
import time
import concurrent.futures
from typing import List, Dict

def invoke_lambda_function(function_name: str, payload: Dict) -> Dict:
    """Lambda関数を呼び出し"""
    lambda_client = boto3.client('lambda')

    start_time = time.time()

    try:
        response = lambda_client.invoke(
            FunctionName=function_name,
            InvocationType='RequestResponse',
            Payload=json.dumps(payload)
        )

        end_time = time.time()

        return {
            'success': True,
            'duration': end_time - start_time,
            'status_code': response['StatusCode'],
            'payload_size': len(response['Payload'].read())
        }

    except Exception as e:
        return {
            'success': False,
            'error': str(e),
            'duration': time.time() - start_time
        }

def run_load_test(function_name: str, concurrent_requests: int = 10, 
                  total_requests: int = 100) -> Dict:
    """負荷テスト実行"""

    test_payload = {
        'test_data': list(range(1000)),
        'timestamp': time.time()
    }

    results = []

    # 並列実行
    with concurrent.futures.ThreadPoolExecutor(max_workers=concurrent_requests) as executor:
        futures = [
            executor.submit(invoke_lambda_function, function_name, test_payload)
            for _ in range(total_requests)
        ]

        for future in concurrent.futures.as_completed(futures):
            results.append(future.result())

    # 結果分析
    successful_requests = [r for r in results if r['success']]
    failed_requests = [r for r in results if not r['success']]

    if successful_requests:
        durations = [r['duration'] for r in successful_requests]
        avg_duration = sum(durations) / len(durations)
        min_duration = min(durations)
        max_duration = max(durations)
    else:
        avg_duration = min_duration = max_duration = 0

    return {
        'total_requests': total_requests,
        'successful_requests': len(successful_requests),
        'failed_requests': len(failed_requests),
        'success_rate': len(successful_requests) / total_requests * 100,
        'avg_duration': avg_duration,
        'min_duration': min_duration,
        'max_duration': max_duration
    }

# 使用例
if __name__ == "__main__":
    test_results = run_load_test(
        function_name='my-optimized-lambda',
        concurrent_requests=20,
        total_requests=200
    )

    print(json.dumps(test_results, indent=2))

# コスト計算関数
def calculate_lambda_cost(memory_mb: int, duration_ms: int, requests: int) -> Dict:
    """Lambda実行コストを計算"""

    # 2025年の料金（東京リージョン）
    REQUEST_COST = 0.0000002  # $0.20 per 1M requests
    GB_SECOND_COST = 0.0000166667  # $16.67 per 1M GB-seconds

    # GB-seconds計算
    gb_seconds = (memory_mb / 1024) * (duration_ms / 1000) * requests

    # コスト計算
    request_cost = requests * REQUEST_COST
    compute_cost = gb_seconds * GB_SECOND_COST
    total_cost = request_cost + compute_cost

    return {
        'requests': requests,
        'memory_mb': memory_mb,
        'duration_ms': duration_ms,
        'gb_seconds': gb_seconds,
        'request_cost_usd': request_cost,
        'compute_cost_usd': compute_cost,
        'total_cost_usd': total_cost,
        'cost_per_request_usd': total_cost / requests if requests > 0 else 0
    }

# 最適化前後の比較
optimization_comparison = {
    "before": calculate_lambda_cost(512, 2000, 1000000),  # 512MB, 2秒, 100万リクエスト
    "after": calculate_lambda_cost(1024, 800, 1000000)   # 1024MB, 0.8秒, 100万リクエスト
}

print("最適化効果:")
print(f"コスト削減: ${optimization_comparison['before']['total_cost_usd'] - optimization_comparison['after']['total_cost_usd']:.2f}")
print(f"削減率: {(1 - optimization_comparison['after']['total_cost_usd'] / optimization_comparison['before']['total_cost_usd']) * 100:.1f}%")