2026 में AWS लैम्ब्डा में पायथन ऐप कैसे तैनात करें: सर्वर रहित गाइड

एडब्ल्यूएस लैम्ब्डा सर्वर प्रबंधित किए बिना आपका कोड चलाता है – आप केवल निष्पादन समय के लिए भुगतान करते हैं, और यह स्वचालित रूप से शून्य से हजारों समवर्ती अनुरोधों तक पहुंच जाता है। यह मार्गदर्शिका स्क्रैच से एपीआई गेटवे के साथ लैम्ब्डा में एक पायथन एपीआई तैनात करती है।

लैम्ब्डा का उपयोग कब करें

• अच्छा फिट: वैरिएबल ट्रैफ़िक, शेड्यूल किए गए जॉब, इवेंट प्रोसेसिंग, वेबहुक, हल्के माइक्रोसर्विसेज के साथ एपीआई
• ख़राब फ़िट: लंबे समय तक चलने वाली प्रक्रियाएं (15-मिनट की सीमा), लगातार उच्च ट्रैफ़िक (हमेशा चालू सर्वर पर सस्ता), लगातार कनेक्शन की आवश्यकता वाले ऐप्स (वेबसॉकेट को एपीआई गेटवे v2 की आवश्यकता होती है)

विधि 1: सरल लैम्ब्डा फ़ंक्शन (कंसोल)

# handler.py — the entry point
import json

def lambda_handler(event, context):
    # event contains the request data
    name = event.get('queryStringParameters', {}).get('name', 'World')

    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps({'message': f'Hello, {name}!'})
    }

पैकेजिंग निर्भरताएँ

लैम्ब्डा को आपकी निर्भरताओं को बंडल करने की आवश्यकता है।requests:

# Install dependencies into a package directory
mkdir package
pip install requests -t package/

# Add your handler
cp handler.py package/

# Zip it
cd package
zip -r ../deployment.zip .
cd ..

# Upload deployment.zip to Lambda

जैसे पैकेज के लिए विधि 2: सर्वर रहित फ्रेमवर्क (अनुशंसित)

npm install -g serverless
serverless create --template aws-python3 --path my-api
cd my-api
npm install serverless-python-requirements

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: python3.12
  region: us-east-1
  environment:
    STAGE: ${sls:stage}
    DB_URL: ${env:DB_URL}

functions:
  api:
    handler: handler.lambda_handler
    events:
      - httpApi:
          path: /hello
          method: get
      - httpApi:
          path: /users/{id}
          method: get
    timeout: 29
    memorySize: 256

plugins:
  - serverless-python-requirements

custom:
  pythonRequirements:
    dockerizePip: true   # builds native deps in a Lambda-compatible container

# requirements.txt
requests==2.32.0
boto3==1.34.0

# Deploy
serverless deploy

# Output gives your API Gateway URL:
# endpoint: GET - https://abc123.execute-api.us-east-1.amazonaws.com/hello

एपीआई गेटवे इवेंट को संभालना

import json

def lambda_handler(event, context):
    # httpApi (v2) event structure
    method = event['requestContext']['http']['method']
    path   = event['requestContext']['http']['path']
    params = event.get('pathParameters') or {}
    query  = event.get('queryStringParameters') or {}
    body   = json.loads(event['body']) if event.get('body') else {}

    if path.startswith('/users/'):
        user_id = params.get('id')
        return respond(200, {'userId': user_id})

    return respond(404, {'error': 'Not found'})

def respond(status, data):
    return {
        'statusCode': status,
        'headers': {'Content-Type': 'application/json'},
        'body': json.dumps(data)
    }

कोल्ड स्टार्ट का प्रबंधन

लैम्ब्डा “कोल्ड स्टार्ट” जब एक नया कंटेनर घूमता है (पहला अनुरोध या निष्क्रिय होने के बाद)। प्रभाव न्यूनतम करें:

• पैकेज छोटा रखें: कम निर्भरता = तेज़ ठंडी शुरुआत। केवल वही आयात करें जो आप उपयोग करते हैं।
• हैंडलर के बाहर आरंभ करें: डेटाबेस क्लाइंट और कॉन्फ़िगरेशन प्रति कंटेनर एक बार लोड होता है, गर्म आमंत्रणों में पुन: उपयोग किया जाता है
• प्रावधानित समवर्तीता का उपयोग करें विलंबता-महत्वपूर्ण समापन बिंदुओं के लिए (कंटेनरों को गर्म रखता है, अतिरिक्त लागत)
• याददाश्त बढ़ाएँ: अधिक मेमोरी का मतलब अधिक सीपीयू, इनिट समय को कम करना

# ✅ Initialize clients OUTSIDE the handler (reused across invocations)
import boto3
dynamodb = boto3.resource('dynamodb')  # created once per container
table = dynamodb.Table('users')

def lambda_handler(event, context):
    # table is already initialized — no per-request setup cost
    return table.get_item(Key={'id': '1'})

है पर्यावरण चर और रहस्य

# Non-sensitive config: environment variables (serverless.yml)
environment:
  LOG_LEVEL: info

# Sensitive secrets: use AWS Secrets Manager or SSM Parameter Store
import boto3
ssm = boto3.client('ssm')

def get_secret(name):
    resp = ssm.get_parameter(Name=name, WithDecryption=True)
    return resp['Parameter']['Value']

DB_PASSWORD = get_secret('/myapp/db_password')  # loaded once per container

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: लैम्ब्डा की लागत कितनी है?
उत्तर: मुफ़्त टियर में 1M अनुरोध और 400,000 GB-सेकंड मासिक शामिल हैं। इसके अलावा, आप प्रति अनुरोध और प्रति जीबी-सेकंड निष्पादन के लिए भुगतान करते हैं। वैरिएबल-ट्रैफ़िक एपीआई के लिए, यह अक्सर हमेशा चालू रहने वाले सर्वर से कहीं अधिक सस्ता होता है।

प्रश्न: अधिकतम निष्पादन समय क्या है?
उत्तर: 15 मिनट. लंबे कार्यों के लिए, एकाधिक लैम्ब्डा को व्यवस्थित करने के लिए AWS स्टेप फ़ंक्शंस का उपयोग करें, या लंबे समय तक चलने वाली प्रक्रियाओं के लिए ECS/Fargate पर जाएँ।

प्रश्न: मैं लैम्ब्डा को डेटाबेस से कैसे जोड़ूँ?
उत्तर: सर्वर रहित-अनुकूल डेटाबेस के लिए, DynamoDB या Aurora Serverless का उपयोग करें। पारंपरिक पोस्टग्रेज/MySQL के लिए, कनेक्शन पूलिंग को प्रबंधित करने के लिए आरडीएस प्रॉक्सी का उपयोग करें (लैम्ब्डा की स्केलिंग अन्यथा डीबी कनेक्शन को समाप्त कर सकती है)।

प्रश्न: क्या मैं लैम्ब्डा पर पूर्ण वेब फ्रेमवर्क चला सकता हूँ?
उत्तर: हाँ – WSGI/ASGI ऐप्स को लैम्ब्डा में अनुकूलित करने के लिए मैंगम (FastAPI/Starlette के लिए) या Zappa (फ्लास्क/Django के लिए) का उपयोग करें। मौजूदा ऐप्स को माइग्रेट करने के लिए अच्छा है, हालांकि देशी हैंडलर हल्के होते हैं।

प्रश्न: मैं लैम्ब्डा को स्थानीय स्तर पर कैसे डिबग करूं?
ए:serverless invoke localका प्रयोग करें या एडब्ल्यूएस सैम सीएलआईsam local start-api कार्यों को स्थानीय रूप से चलाने के लिए। क्लाउडवॉच लॉग सभी उत्पादन निष्पादन लॉग कैप्चर करते हैं।

निष्कर्ष

AWS Lambda आपको Python API को तैनात करने की सुविधा देता है जो स्वचालित रूप से स्केल करता है और निष्क्रिय होने पर कोई लागत नहीं आती है। सर्वर रहित फ्रेमवर्क दृष्टिकोण –serverless.yml प्लसserverless-python-requirements – एक कमांड में पैकेजिंग, एपीआई गेटवे और तैनाती को संभालता है। कोल्ड-स्टार्ट लागत को कम करने के लिए हैंडलर के बाहर क्लाइंट्स को इनिशियलाइज़ करें, क्रेडेंशियल्स के लिए एसएसएम/सीक्रेट्स मैनेजर का उपयोग करें, और प्रोविज़न्ड कॉनकरेंसी तक तभी पहुंचें जब विलंबता वास्तव में मायने रखती है। यह वैरिएबल-ट्रैफ़िक एपीआई और इवेंट-संचालित वर्कलोड के लिए बिल्कुल उपयुक्त है।