import json
from datetime import datetime

def lambda_handler(event, context):
    # event: 호출자가 보낸 데이터 (dict)
    # context: 실행 환경 정보 (남은 시간, 함수 이름 등)

    name = event.get('name', 'World')

    result = {
        'message': f'Hello, {name}!',
        'timestamp': datetime.now().isoformat(),
        'received_event': event
    }

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

import boto3, json, time

iam = boto3.client('iam', region_name='us-east-2')

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

role_name = "lambda-basic-execution-role"

try:
    response = iam.create_role(
        RoleName=role_name,
        AssumeRolePolicyDocument=json.dumps(trust_policy),
    )
    role_arn = response['Role']['Arn']
    print(f"Role 생성 완료: {role_arn}")
except iam.exceptions.EntityAlreadyExistsException:
    role_arn = iam.get_role(RoleName=role_name)['Role']['Arn']
    print(f"이미 존재하는 Role 사용: {role_arn}")

iam.attach_role_policy(
    RoleName=role_name,
    PolicyArn="arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
)
print("권한 추가 완료")

print("대기 중 (10초)...")
time.sleep(10)

import boto3, zipfile, io, json

lambda_client = boto3.client('lambda', region_name='us-east-2')

lambda_code = """
import json
from datetime import datetime

def lambda_handler(event, context):
    name = event.get('name', 'World')
    return {
        'statusCode': 200,
        'body': json.dumps({
            'message': f'Hello, {name}!',
            'timestamp': datetime.now().isoformat()
        }, ensure_ascii=False)
    }
"""

zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
    zf.writestr('lambda_function.py', lambda_code)
zip_buffer.seek(0)

function_name = "my-first-lambda"

try:
    response = lambda_client.create_function(
        FunctionName=function_name,
        Runtime='python3.12',
        Role=role_arn,
        Handler='lambda_function.lambda_handler',
        Code={'ZipFile': zip_buffer.read()},
        Timeout=30,
        MemorySize=128,
    )
    print(f"Lambda 생성 완료: {response['FunctionArn']}")
except lambda_client.exceptions.ResourceConflictException:
    print("이미 존재합니다.")

import json

response = lambda_client.invoke(
    FunctionName=function_name,
    InvocationType='RequestResponse',   # 동기 호출
    Payload=json.dumps({"name": "Lambda 초보자"})
)

result = json.loads(response['Payload'].read())
print(json.dumps(result, indent=2, ensure_ascii=False))

%%bash
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
REGION="us-east-2"
REPO_NAME="my-lambda-container"
ECR_URI="${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com"

# 이미지 빌드
cd ~/lambda-container
docker build -t ${REPO_NAME}:latest .

# ECR 로그인 + 푸시
aws ecr get-login-password --region ${REGION} | \
  docker login --username AWS --password-stdin ${ECR_URI}

docker tag ${REPO_NAME}:latest ${ECR_URI}/${REPO_NAME}:latest
docker push ${ECR_URI}/${REPO_NAME}:latest

echo "Push 완료: ${ECR_URI}/${REPO_NAME}:latest"

# 컨테이너 이미지로 Lambda 등록
account_id = boto3.client('sts', region_name='us-east-2').get_caller_identity()['Account']
image_uri  = f"{account_id}.dkr.ecr.us-east-2.amazonaws.com/my-lambda-container:latest"

lambda_client.create_function(
    FunctionName="my-container-lambda",
    Role=role_arn,
    Code={'ImageUri': image_uri},
    PackageType='Image',    # ← 컨테이너 이미지
    Timeout=60,
    MemorySize=256,
)
print("컨테이너 Lambda 등록 완료")

# 📓 노트북에서 실행하는 방식
from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput
import sagemaker

REGION      = "ap-northeast-2"
ACCOUNT_ID  = boto3.client("sts").get_caller_identity()["Account"]
BUCKET      = f"gs-cdp-mllab-{ctx.model['env_nm']}"
IMAGE_URI   = f"{ACCOUNT_ID}.dkr.ecr.{REGION}.amazonaws.com/gs-automl-base-containers/boilerplate312:latest"
ROLE_ARN    = sagemaker.get_execution_role()

estimator = Estimator(
    image_uri=IMAGE_URI,
    role=ROLE_ARN,
    instance_count=1,
    instance_type="ml.m5.xlarge",
    volume_size=30,
    max_run=3600,
    output_path=f"s3://{BUCKET}/sm-output/",
    hyperparameters={
        "run_id":    ctx.run_id,
        "env_nm":    ctx.model["env_nm"],
        "worker_id": ctx.model["worker_id"],
    },
    environment={"AWS_DEFAULT_REGION": REGION},
)

estimator.fit(
    inputs={
        "train": TrainingInput(
            s3_data=f"s3://{BUCKET}/{ctx.model['env_nm']}/{ctx.project['project_nm']}/data/",
            content_type="text/csv",
        )
    },
    job_name=f"cdp-train-{ctx.run_id}",
    wait=False,
)

import boto3, json
from datetime import datetime

def lambda_handler(event, context):
    """
    EventBridge 또는 직접 호출로 SageMaker Training Job을 시작합니다.
    event 예시:
      {"run_id": "20260526_143012_a3f9bc", "env_nm": "dev", "worker_id": "hjsong"}
    """
    run_id    = event.get("run_id",    datetime.now().strftime("%Y%m%d_%H%M%S"))
    env_nm    = event.get("env_nm",    "dev")
    worker_id = event.get("worker_id", "unknown")

    REGION     = "ap-northeast-2"
    ACCOUNT_ID = boto3.client("sts").get_caller_identity()["Account"]
    BUCKET     = f"gs-cdp-mllab-{env_nm}"
    IMAGE_URI  = f"{ACCOUNT_ID}.dkr.ecr.{REGION}.amazonaws.com/gs-automl-base-containers/boilerplate312:latest"
    ROLE_ARN   = f"arn:aws:iam::{ACCOUNT_ID}:role/gs-cdp-sagemaker-role"

    sm = boto3.client("sagemaker", region_name=REGION)

    response = sm.create_training_job(
        TrainingJobName=f"cdp-train-{run_id}",

        # estimator(image_uri=...) 에 해당
        AlgorithmSpecification={
            "TrainingImage":     IMAGE_URI,
            "TrainingInputMode": "File",
        },

        # estimator(role=...) 에 해당
        RoleArn=ROLE_ARN,

        # estimator.fit(inputs={...}) 에 해당
        InputDataConfig=[{
            "ChannelName": "train",
            "DataSource": {
                "S3DataSource": {
                    "S3DataType":             "S3Prefix",
                    "S3Uri":                  f"s3://{BUCKET}/{env_nm}/data/",
                    "S3DataDistributionType": "FullyReplicated",
                }
            },
            "ContentType": "text/csv",
            "InputMode":   "File",
        }],

        # estimator(output_path=...) 에 해당
        OutputDataConfig={
            "S3OutputPath": f"s3://{BUCKET}/sm-output/",
        },

        # estimator(instance_type=..., instance_count=..., volume_size=...) 에 해당
        ResourceConfig={
            "InstanceType":   "ml.m5.xlarge",
            "InstanceCount":  1,
            "VolumeSizeInGB": 30,
        },

        # estimator(max_run=...) 에 해당
        StoppingCondition={
            "MaxRuntimeInSeconds": 3600,
        },

        # estimator(hyperparameters={...}) 에 해당
        # ⚠️ 값은 반드시 문자열이어야 합니다
        HyperParameters={
            "run_id":    run_id,
            "env_nm":    env_nm,
            "worker_id": worker_id,
        },

        # estimator(environment={...}) 에 해당
        Environment={
            "AWS_DEFAULT_REGION": REGION,
        },
    )

    job_arn = response["TrainingJobArn"]
    print(f"Training Job 시작: {job_arn}")

    return {
        "statusCode": 200,
        "body": json.dumps({
            "training_job_name": f"cdp-train-{run_id}",
            "training_job_arn":  job_arn,
            "run_id":            run_id,
        })
    }

import time

def wait_for_training_job(job_name, region="ap-northeast-2", poll_sec=30):
    sm     = boto3.client("sagemaker", region_name=region)
    status = "InProgress"

    while status in ("InProgress", "Stopping"):
        resp   = sm.describe_training_job(TrainingJobName=job_name)
        status = resp["TrainingJobStatus"]
        secs   = resp.get("TrainingTimeInSeconds", 0)
        print(f"[{status}] {secs}s elapsed")
        if status in ("InProgress", "Stopping"):
            time.sleep(poll_sec)

    if status == "Completed":
        s3_model = resp["ModelArtifacts"]["S3ModelArtifacts"]
        print(f"완료: {s3_model}")
    else:
        reason = resp.get("FailureReason", "unknown")
        raise RuntimeError(f"Training Job 실패: {status} — {reason}")

    return status, resp

# 사용 예시
status, info = wait_for_training_job(f"cdp-train-{run_id}")

events = boto3.client('events', region_name='us-east-2')
account_id = boto3.client('sts', region_name='us-east-2').get_caller_identity()['Account']
REGION = 'us-east-2'

# 규칙 생성 (매일 오전 9시 UTC = 한국시간 오후 6시)
rule_response = events.put_rule(
    Name='daily-ml-training',
    ScheduleExpression='cron(0 9 * * ? *)',     # UTC 기준
    State='ENABLED',
    Description='매일 오전 9시 (UTC) ML 모델 학습 자동 실행',
)
rule_arn = rule_response['RuleArn']
print(f"EventBridge Rule: {rule_arn}")

# Lambda에 EventBridge 호출 권한 부여
lambda_client.add_permission(
    FunctionName="my-container-lambda",
    StatementId='eventbridge-invoke',
    Action='lambda:InvokeFunction',
    Principal='events.amazonaws.com',
    SourceArn=rule_arn,
)

# Lambda를 트리거 타겟으로 등록
events.put_targets(
    Rule='daily-ml-training',
    Targets=[{
        'Id': 'ml-training-target',
        'Arn': f'arn:aws:lambda:{REGION}:{account_id}:function:my-container-lambda',
        'Input': json.dumps({
            "task": "daily-training",
            "user_id": "YOUR_ID",
            "project": "titanic-survival-prediction"
        })
    }]
)
print("EventBridge 트리거 등록 완료")

logs = boto3.client('logs', region_name='us-east-2')

log_group = '/aws/lambda/my-container-lambda'

streams = logs.describe_log_streams(
    logGroupName=log_group,
    orderBy='LastEventTime',
    descending=True,
    limit=1
)

if streams['logStreams']:
    stream_name = streams['logStreams'][0]['logStreamName']
    events_resp = logs.get_log_events(
        logGroupName=log_group,
        logStreamName=stream_name,
        limit=20
    )
    for e in events_resp['events']:
        print(e['message'])