Loading
Loading
Lambda is a Serverless service that runs code without managing servers โ you pay only on execution.
The first invocation takes longer to initialize the Container. Solution: Provisioned Concurrency for latency-sensitive apps.
1 million invocations/month free โ enough for all learning projects.
import json
import time
# โโโ ู
ุญุงูุงุฉ Lambda Context โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class LambdaContext:
function_name = "ai-chat-lambda"
memory_limit_mb = 512
timeout_ms = 30_000
aws_request_id = "req-abc123-def456"
log_group = "/aws/lambda/ai-chat-lambda"
# โโโ Bedrock Client (ู
ุญุงูุงุฉ) โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class BedrockClient:
def invoke(self, message: str) -> str:
return f"[Claude ุนูู Bedrock] ุฑุฏ ุนูู: {message[:55]}..."
# โโโ Lambda Handler โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
def lambda_handler(event: dict, context: LambdaContext) -> dict:
"""
Lambda Function ููู AI Chatbot
ููุณุชุฏุนู ู
ู API Gateway (HTTP POST /chat)
"""
print(f"๐ฅ RequestId: {context.aws_request_id}")
start = time.time()
# โโ ุชุญููู ุงูุทูุจ โโ
try:
raw_body = event.get("body", "{}")
body = json.loads(raw_body) if isinstance(raw_body, str) else raw_body
message = body.get("message", "").strip()
lang = body.get("lang", "ar")
if not message:
return _resp(400, {"error": "ุญูู 'message' ู
ุทููุจ"})
if len(message) > 2000:
return _resp(400, {"error": "ุงูุฑุณุงูุฉ ุทูููุฉ ุฌุฏุงู (ุงูุญุฏ 2000 ุญุฑู)"})
except (json.JSONDecodeError, AttributeError) as e:
return _resp(400, {"error": f"JSON ุบูุฑ ุตุงูุญ: {e}"})
# โโ ุงุณุชุฏุนุงุก Bedrock โโ
bedrock = BedrockClient()
answer = bedrock.invoke(message)
duration = round((time.time() - start) * 1000, 1)
remaining = context.timeout_ms - duration
print(f"โก ููุช ุงูู
ุนุงูุฌุฉ: {duration}ms | ุงูู
ุชุจูู: {remaining}ms")
return _resp(200, {
"answer": answer,
"lang": lang,
"duration_ms": duration,
"model": "claude-3-haiku",
"request_id": context.aws_request_id,
})
def _resp(status: int, data: dict) -> dict:
return {
"statusCode": status,
"headers": {
"Content-Type": "application/json",
"Access-Control-Allow-Origin": "*",
},
"body": json.dumps(data, ensure_ascii=False),
}
# โโโ ุงุฎุชุจุงุฑ ู
ุญูู โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
ctx = LambdaContext()
print("๐งช ุงุฎุชุจุงุฑ Lambda Function ู
ุญููุงู:")
print("=" * 55)
tests = [
{"message": "ุงุดุฑุญ AWS Lambda ุจุงุฎุชุตุงุฑ", "lang": "ar"},
{"message": "What is serverless computing?", "lang": "en"},
]
for body in tests:
event = {"body": json.dumps(body, ensure_ascii=False)}
res = lambda_handler(event, ctx)
data = json.loads(res["body"])
print(f"\n๐จ {body['message']}")
print(f"๐ข Status : {res['statusCode']}")
print(f"๐ฌ Answer : {data['answer']}")
print(f"โฑ๏ธ Time : {data['duration_ms']}ms")
# ุทูุจ ุฎุงุทุฆ
print(f"\n\n๐ด ุงุฎุชุจุงุฑ ุญุงูุฉ ุฎุทุฃ (ุฑุณุงูุฉ ูุงุฑุบุฉ):")
err_ev = {"body": json.dumps({"message": ""})}
err_res = lambda_handler(err_ev, ctx)
err_data = json.loads(err_res["body"])
print(f"Status: {err_res['statusCode']} โ {err_data['error']}")
# ู
ุนููู
ุงุช ุงูุฏุงูุฉ
print(f"\n\n๐ ู
ุนููู
ุงุช Lambda Function:")
mem_str = str(ctx.memory_limit_mb) + " MB"
print(f" ุงูุงุณู
: {ctx.function_name}")
print(f" ุงูุฐุงูุฑุฉ : {mem_str}")
print(f" Timeout : {ctx.timeout_ms} ms")
print(f" Log Group : {ctx.log_group}")