Lambda

// handler.js - SQS 메시지 처리 핸들러
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { DynamoDBDocumentClient, PutCommand, GetCommand } = require('@aws-sdk/lib-dynamodb');

// Cold Start 최적화: 클라이언트 재사용
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);

/**
 * SQS 메시지 배치 처리 핸들러
 * 부분 실패 시 실패한 메시지만 재처리되도록 설정
 */
exports.sqsHandler = async (event) => {
    console.log(`Processing ${event.Records.length} messages`);

    const failedMessageIds = [];

    for (const record of event.Records) {
        try {
            const body = JSON.parse(record.body);
            await processMessage(body);
            console.log(`Successfully processed: ${record.messageId}`);
        } catch (error) {
            console.error(`Failed to process: ${record.messageId}`, error);
            failedMessageIds.push(record.messageId);
        }
    }

    // 부분 배치 실패 응답 (ReportBatchItemFailures 활성화 필요)
    return {
        batchItemFailures: failedMessageIds.map(id => ({
            itemIdentifier: id
        }))
    };
};

async function processMessage(message) {
    // 비즈니스 로직
    await docClient.send(new PutCommand({
        TableName: process.env.TABLE_NAME,
        Item: {
            id: message.id,
            data: message.data,
            processedAt: new Date().toISOString()
        }
    }));
}

/**
 * API Gateway 핸들러 (ES Module 스타일)
 */
export const apiHandler = async (event, context) => {
    // 컨텍스트 재사용 설정
    context.callbackWaitsForEmptyEventLoop = false;

    const { httpMethod, path, body, queryStringParameters } = event;

    try {
        switch (httpMethod) {
            case 'GET':
                const id = event.pathParameters?.id;
                if (id) {
                    const result = await docClient.send(new GetCommand({
                        TableName: process.env.TABLE_NAME,
                        Key: { id }
                    }));

                    if (!result.Item) {
                        return formatResponse(404, { error: 'Not found' });
                    }
                    return formatResponse(200, result.Item);
                }
                // 목록 조회
                // ...
                break;

            case 'POST':
                const data = JSON.parse(body);
                // 생성 로직
                return formatResponse(201, { message: 'Created', id: data.id });

            default:
                return formatResponse(405, { error: 'Method not allowed' });
        }
    } catch (error) {
        console.error('Handler error:', error);
        return formatResponse(500, { error: 'Internal server error' });
    }
};

function formatResponse(statusCode, body) {
    return {
        statusCode,
        headers: {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        body: JSON.stringify(body)
    };
}

/**
 * EventBridge 스케줄 핸들러 (Cron Job)
 */
exports.scheduledHandler = async (event) => {
    console.log('Scheduled event:', JSON.stringify(event));

    // 정기 작업 실행
    // 예: 만료된 데이터 정리, 리포트 생성 등

    return { status: 'completed' };
};

# Terraform으로 Lambda 함수 배포
# main.tf

# Lambda 실행 역할
resource "aws_iam_role" "lambda_role" {
  name = "api-lambda-role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = {
        Service = "lambda.amazonaws.com"
      }
    }]
  })
}

# DynamoDB 접근 정책
resource "aws_iam_role_policy" "lambda_policy" {
  name = "api-lambda-policy"
  role = aws_iam_role.lambda_role.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = [
          "dynamodb:GetItem",
          "dynamodb:PutItem",
          "dynamodb:UpdateItem",
          "dynamodb:DeleteItem",
          "dynamodb:Scan",
          "dynamodb:Query"
        ]
        Resource = aws_dynamodb_table.main.arn
      },
      {
        Effect = "Allow"
        Action = [
          "logs:CreateLogGroup",
          "logs:CreateLogStream",
          "logs:PutLogEvents"
        ]
        Resource = "arn:aws:logs:*:*:*"
      }
    ]
  })
}

# Lambda 함수
resource "aws_lambda_function" "api" {
  function_name = "api-handler"
  role          = aws_iam_role.lambda_role.arn
  handler       = "handler.lambda_handler"
  runtime       = "python3.11"

  filename         = "lambda.zip"
  source_code_hash = filebase64sha256("lambda.zip")

  memory_size = 256
  timeout     = 30

  environment {
    variables = {
      TABLE_NAME  = aws_dynamodb_table.main.name
      ENVIRONMENT = "production"
    }
  }

  # VPC 설정 (필요시)
  vpc_config {
    subnet_ids         = var.private_subnet_ids
    security_group_ids = [aws_security_group.lambda.id]
  }

  # X-Ray 추적 활성화
  tracing_config {
    mode = "Active"
  }

  # Provisioned Concurrency (Cold Start 제거)
  # aws_lambda_provisioned_concurrency_config 리소스로 별도 설정
}

# Lambda 함수 URL (API Gateway 대안)
resource "aws_lambda_function_url" "api" {
  function_name      = aws_lambda_function.api.function_name
  authorization_type = "NONE"  # 또는 "AWS_IAM"

  cors {
    allow_origins = ["https://example.com"]
    allow_methods = ["GET", "POST", "PUT", "DELETE"]
    allow_headers = ["Content-Type", "Authorization"]
    max_age       = 86400
  }
}

# API Gateway 연동
resource "aws_apigatewayv2_api" "api" {
  name          = "api"
  protocol_type = "HTTP"

  cors_configuration {
    allow_origins = ["*"]
    allow_methods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"]
    allow_headers = ["Content-Type", "Authorization"]
  }
}

resource "aws_apigatewayv2_integration" "lambda" {
  api_id             = aws_apigatewayv2_api.api.id
  integration_type   = "AWS_PROXY"
  integration_method = "POST"
  integration_uri    = aws_lambda_function.api.invoke_arn
}

resource "aws_apigatewayv2_route" "api" {
  api_id    = aws_apigatewayv2_api.api.id
  route_key = "ANY /{proxy+}"
  target    = "integrations/${aws_apigatewayv2_integration.lambda.id}"
}

# Lambda 권한 (API Gateway에서 호출 허용)
resource "aws_lambda_permission" "api_gw" {
  statement_id  = "AllowAPIGatewayInvoke"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.api.function_name
  principal     = "apigateway.amazonaws.com"
  source_arn    = "${aws_apigatewayv2_api.api.execution_arn}/*/*"
}

# CloudWatch 로그 그룹 (보존 기간 설정)
resource "aws_cloudwatch_log_group" "lambda" {
  name              = "/aws/lambda/${aws_lambda_function.api.function_name}"
  retention_in_days = 14
}

# --- SAM template.yaml 예시 ---
# AWSTemplateFormatVersion: '2010-09-09'
# Transform: AWS::Serverless-2016-10-31
#
# Globals:
#   Function:
#     Timeout: 30
#     MemorySize: 256
#     Runtime: python3.11
#
# Resources:
#   ApiFunction:
#     Type: AWS::Serverless::Function
#     Properties:
#       Handler: handler.lambda_handler
#       CodeUri: src/
#       Events:
#         Api:
#           Type: HttpApi
#           Properties:
#             Path: /{proxy+}
#             Method: ANY