Lambda के execution मॉडल को समझना

AWS Lambda के साथ Serverless Applications

Claudio Canales

Senior DevOps Engineer

ऑटोमैटिक execution

इवेंट-ड्रिवन AWS

इवेंट होने पर Lambda कोड चलाता है।
उदाहरण: S3 अपलोड -> इमेज resize।
ट्रिगर अलग, पैटर्न समान।

ट्रिगर होने तक idle

Idle -> event -> run -> stop

Idle: कुछ नहीं चलता।
Event: हैंडलर चलता है, फिर रुकता है।

Lambda के लिए मोशन-लाइट उपमा

मोशन लाइट जैसा: ट्रिगर तक idle।
ट्रिगर "off" से "on" कर देता है।

AWS Lambda क्या है?

AWS Lambda एक नज़र में

इवेंट-ड्रिवन compute सर्विस।
डिमांड के साथ ऑटो-स्केल।
सिर्फ runtime के लिए भुगतान।

Lambda आपका कोड कैसे चलाता है

Lambda execution फ्लो

कोई event source Lambda को ट्रिगर करता है।
Lambda आपका हैंडलर को event payload देता है।
आपका हैंडलर outcome लौटाता है।

डिमांड अनुसार स्केलिंग

स्केलिंग से और environment बनते हैं

ज्यादा events: ज्यादा parallel invocations।
Lambda और environments spin-up करता है।
हर नए environment पर cold start हो सकता है।

हैंडलर फंक्शन

def lambda_handler(event, context):
    # Your code here
    return {
        'statusCode': 200,
        'body': 'Hello from Lambda!'
    }

event: इनपुट payload (JSON)।
context: runtime मेटाडेटा।
return: आउटपुट (या success/fail)।

हैंडलर event और context लेता है

event ऑब्जेक्ट

ऑब्जेक्ट स्टोरेज event payload

S3 event: bucket + object key।

# event["Records"][0]["s3"]
{
  "bucket": {"name": "my-bucket"},
  "object": {"key": "data.csv"}
}

वही काम: जो चाहिए, निकालें।

HTTP रिक्वेस्ट event payload

API event: method, path, body।

# API request event
{
  "httpMethod": "POST",
  "path": "/users",
  "body": "{\"name\": \"John\"}"
}

ट्रिगर अलग, JSON अलग।

context ऑब्जेक्ट

def lambda_handler(event, context):
    time_left = (
        context.get_remaining_time_in_millis()
    )
    request_id = context.aws_request_id

get_remaining_time_in_millis टाइमआउट से पहले बचा समय।
aws_request_id लॉग ट्रेसिंग के लिए request ID।

Stateless execution

वार्म स्टार्ट reuse बनाम reset

हर invocation स्वतंत्र है।
Reuse संभव है, गारंटी नहीं।
स्टेट Lambda के बाहर रखें।

counter = 0

def lambda_handler(event, context):
    global counter
    counter += 1  # may reset
    return counter

Cold starts

कोल्ड स्टार्ट टाइमलाइन

नया execution environment।
कोड और dependencies लोड हों।
Initialization, फिर हैंडलर चले।

Warm starts

वार्म स्टार्ट टाइमलाइन

मौजूदा environment reuse।
अधिकतर initialization skip।
हैंडलर जल्दी चलता है।

Init, invoke, freeze

execution environment लाइफसाइकल

Init प्रति environment एक बार चलता है।
हैंडलर हर invocation पर चलता है।
रन के बीच env freeze हो सकता है।

Cold starts के लिए optimization

# init (once per env)
import boto3
s3 = boto3.client('s3')

# handler (every invocation)
def lambda_handler(event, context):
    return {"statusCode": 200}

Init एक बार बनाम हैंडलर हर invocation

imports और SDK क्लाइंट्स हैंडलर के बाहर रखें।

अभ्यास करते हैं!

AWS Lambda के साथ Serverless Applications