बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) · पाठ

अतुल्यकालिक Lambda आह्वान

Lambda फ़ंक्शन के लिए अतुल्यकालिक पैटर्न लागू करें तथा पुनः प्रयास, डेड-लेटर कतार और समवर्तीता नियंत्रण संभालें।

पाठ 1, कुल 4 में से12 चरण

अतुल्यकालिक Lambda आह्वान, CoddyKit पर बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

अतुल्यकालिक आह्वान क्या है

जब आप AWS Lambda फ़ंक्शन को अतुल्यकालिक रूप से चलाते हैं, तो आप फ़ंक्शन के उत्तर की प्रतीक्षा नहीं करते। यह "भेजो और भूल जाओ" मॉडल है।

कॉलर इवेंट भेजता है और परिणाम की प्रतीक्षा नहीं करता।
Lambda पृष्ठभूमि में कतार और निष्पादन का प्रबंधन करता है।
यह पैटर्न इवेंट-आधारित आर्किटेक्चर के लिए उपयुक्त है, जहाँ तत्काल प्रतिक्रिया आवश्यक नहीं होती।

अतुल्यकालिक आह्वान कैसे काम करता है

अतुल्यकालिक Lambda आह्वान का सामान्य प्रवाह इस प्रकार है:

कोई इवेंट स्रोत (जैसे S3, SNS या प्रत्यक्ष आह्वान) एक इवेंट भेजता है।
Lambda इस इवेंट को एक आंतरिक कतार में रखता है।
इसके बाद Lambda इस कतार से आपके फ़ंक्शन को चलाता है।
इवेंट स्रोत को तुरंत सफलता की प्रतिक्रिया मिलती है, भले ही फ़ंक्शन ने अभी प्रोसेसिंग शुरू न की हो।

विफलता पर स्वचालित पुनःप्रयास

अतुल्यकालिक आह्वान के प्रमुख लाभों में से एक अंतर्निहित त्रुटि-सहनशीलता है। यदि आपके फ़ंक्शन को प्रोसेसिंग के दौरान ऐसी त्रुटि मिलती है जिसे संभाला नहीं गया है या उसका समय समाप्त हो जाता है:

Lambda आह्वान का अपने-आप पुनःप्रयास करता है।
डिफ़ॉल्ट रूप से, यह दो और पुनःप्रयास करता है (कुल तीन प्रयास)।
ये पुनःप्रयास घातीय बैकऑफ़ के साथ होते हैं, अर्थात प्रत्येक प्रयास के बीच बढ़ता हुआ विलंब होता है।

पुनःप्रयास सेटिंग को अनुकूलित करना

अतुल्यकालिक आह्वान की विफलताओं को Lambda कैसे संभाले, इस पर आपका नियंत्रण होता है:

आप पुनःप्रयासों की संख्या (0 से 2 तक) कॉन्फ़िगर कर सकते हैं।
आप अधिकतम इवेंट आयु भी निर्धारित कर सकते हैं, यानी वह सबसे लंबा समय जिसके दौरान Lambda प्रोसेसिंग के लिए किसी इवेंट को अपनी आंतरिक कतार में रखता है।
इन सेटिंग को Lambda कंसोल में या Infrastructure as Code (जैसे AWS SAM, CloudFormation) के माध्यम से बदला जा सकता है।

DLQ से विफल इवेंट पकड़ना

यदि सभी पुनःप्रयासों के बाद भी आपका फ़ंक्शन विफल हो जाए तो क्या होगा? डिफ़ॉल्ट रूप से, इवेंट हटा दिया जाता है। इससे डेटा की हानि हो सकती है।

डेड-लेटर कतार (DLQ) एक शक्तिशाली सुविधा है, जो सभी पुनःप्रयासों के बाद सफलतापूर्वक प्रोसेस न किए जा सकने वाले इवेंट को सुरक्षित रखती है। इससे आप:

विफल इवेंट की जाँच और डिबग कर सकते हैं।
समस्या हल होने के बाद उन्हें फिर से प्रोसेस कर सकते हैं।
महत्वपूर्ण डेटा को खोने से रोक सकते हैं।

डेड-लेटर कतार को कॉन्फ़िगर करना

आप Amazon SQS कतार या Amazon SNS विषय को अपने Lambda फ़ंक्शन की DLQ के रूप में कॉन्फ़िगर कर सकते हैं:

SQS कतार: अलग-अलग विफल इवेंट को बाद में बैच प्रोसेसिंग या मैन्युअल जाँच के लिए संग्रहीत करने हेतु आदर्श।
SNS विषय: विफल इवेंट की सूचनाएँ कई सब्सक्राइबर को भेजने के लिए उपयोगी (जैसे ईमेल या अन्य Lambda फ़ंक्शन)।

आप अपने चुने हुए DLQ संसाधन का ARN (Amazon Resource Name) Lambda फ़ंक्शन के कॉन्फ़िगरेशन में निर्दिष्ट करते हैं।

समवर्ती निष्पादनों का प्रबंधन

समवर्तीता से तात्पर्य किसी भी समय आपके Lambda फ़ंक्शन द्वारा प्रोसेस किए जा रहे अनुरोधों की संख्या से है। आने वाले इवेंट को संभालने के लिए Lambda अपने-आप स्केल करता है।

हालाँकि, अनियंत्रित स्केलिंग कभी-कभी समस्या उत्पन्न कर सकती है:

डाउनस्ट्रीम सेवाओं (जैसे डेटाबेस और API) पर अत्यधिक भार पड़ना।
अनपेक्षित लागत आना।

AWS समवर्तीता प्रबंधित करने के लिए आरक्षित समवर्तीता और प्रावधानित समवर्तीता जैसे उपकरण उपलब्ध कराता है।

फ़ंक्शन निष्पादन सीमित करना: आरक्षित समवर्तीता

आरक्षित समवर्तीता आपको किसी विशिष्ट Lambda फ़ंक्शन के लिए समवर्ती निष्पादनों की अधिकतम संख्या निर्धारित करने देती है।

यह सुनिश्चित करती है कि आपके फ़ंक्शन के लिए हमेशा उतनी क्षमता उपलब्ध रहे।
यह किसी एक फ़ंक्शन को आपके AWS खाते में उपलब्ध पूरी समवर्तीता का उपयोग करने से रोकती है।
यदि आह्वानों की संख्या आरक्षित सीमा से अधिक हो जाती है, तो उन्हें सीमित कर दिया जाता है (अस्वीकार कर दिया जाता है)।

फ़ंक्शन को सक्रिय रखना: प्रावधानित समवर्तीता

प्रावधानित समवर्तीता आपके फ़ंक्शन के लिए निष्पादन परिवेशों की निर्दिष्ट संख्या को पहले से आरंभ करती है।

यह कोल्ड स्टार्ट को काफी कम करती है। कोल्ड स्टार्ट तब होता है जब Lambda को नया निष्पादन परिवेश तैयार करना पड़ता है।
यह API जैसे विलंबता-संवेदी अनुप्रयोगों के लिए उपयुक्त है, जहाँ लगातार कम-विलंबता वाली प्रतिक्रियाएँ महत्वपूर्ण होती हैं।
फ़ंक्शन का सक्रिय रूप से आह्वान न होने पर भी आपको प्रावधानित समवर्तीता के लिए भुगतान करना पड़ता है।

DLQ के उदाहरण के साथ अतुल्यकालिक फ़ंक्शन

यह एक सरल Python Lambda फ़ंक्शन है, जो इवेंट डेटा के आधार पर विफलता का अनुकरण करता है। यदि इसे DLQ के साथ कॉन्फ़िगर किया गया हो, तो विफल इवेंट वहाँ भेजे जाएँगे।

if __name__ == "__main__": ब्लॉक यह दिखाता है कि इसे स्थानीय रूप से कैसे परीक्षण किया जा सकता है।

import json

def lambda_handler(event, context):
    print(f"Received event: {json.dumps(event)}")

    # Simulate a processing error based on event data
    if event.get('fail_me', False):
        print("Simulating a failure!")
        raise Exception("Simulated processing error for event")

    # If processing is successful
    response_message = "Event processed successfully!"
    print(response_message)

    return {
        'statusCode': 200,
        'body': json.dumps(response_message)
    }

# Example invocation for local testing/runnable context
if __name__ == "__main__":
    # Simulate an event that should succeed
    success_event = {"message": "Hello CoddyKit!"}
    print("\n--- Running with success event ---")
    lambda_handler(success_event, None)

    # Simulate an event that should fail
    failure_event = {"message": "Trigger failure", "fail_me": True}
    print("\n--- Running with failure event ---")
    try:
        lambda_handler(failure_event, None)
    except Exception as e:
        print(f"Caught expected error: {e}")

अतुल्यकालिक आह्वान की जाँच

एक ऐसे अतुल्यकालिक Lambda फ़ंक्शन पर विचार कीजिए, जिसे Dead-Letter Queue (DLQ) के साथ कॉन्फ़िगर किया गया है। यदि फ़ंक्शन अपने शुरुआती आह्वान में विफल हो जाए और पहली पुनःप्रयास में भी विफल हो जाए, तो डिफ़ॉल्ट व्यवहार क्या होगा?

इंटरैक्टिव पाठ में इसका उत्तर दें

अतुल्यकालिक Lambda का पुनरावलोकन

हमने अतुल्यकालिक Lambda आह्वान का अध्ययन किया, जो इवेंट-आधारित संरचनाओं के लिए उपयुक्त "चलाएँ और भूल जाएँ" मॉडल है।

हमने डिफ़ॉल्ट पुनःप्रयास व्यवहार और उसे अनुकूलित करने का तरीका सीखा।
हमने विफल इवेंट को पकड़ने और प्रबंधित करने के लिए Dead-Letter Queues (DLQs) को समझा, जिससे डेटा की हानि रोकी जा सकती है।
अंत में, हमने समवर्तीता नियंत्रण को समझा: अधिकतम निष्पादनों को सीमित करने के लिए आरक्षित समवर्तीता और कोल्ड स्टार्ट कम करने के लिए प्रावधानित समवर्तीता।

शुरुआत निःशुल्क

एआई शिक्षक के साथ बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

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

क्या “अतुल्यकालिक Lambda आह्वान” पाठ निःशुल्क है?

हाँ — बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “अतुल्यकालिक Lambda आह्वान” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“अतुल्यकालिक Lambda आह्वान” में मैं क्या सीखूँगा?

Lambda फ़ंक्शन के लिए अतुल्यकालिक पैटर्न लागू करें तथा पुनः प्रयास, डेड-लेटर कतार और समवर्तीता नियंत्रण संभालें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“अतुल्यकालिक Lambda आह्वान” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

अतुल्यकालिक Lambda आह्वान
Lambda लेयर और पर्यावरण वेरिएबल
Lambda एंडपॉइंट के लिए API Gateway
Lambda ऑर्केस्ट्रेशन के लिए Step Functions

← बैकएंड डेवलपरों के लिए AWS (EC2, S3, RDS, Lambda) पर वापस जाएँ