AWS for Backend Developers (EC2, S3, RDS, Lambda) · Lekcja

Asynchroniczne wywoływanie Lambda

Zaimplementuj wzorce asynchroniczne dla funkcji Lambda, obsługując ponowienia, kolejki komunikatów bez możliwości dostarczenia oraz kontrolę współbieżności.

Asynchroniczne wywoływanie Lambda to bezpłatna lekcja AWS for Backend Developers (EC2, S3, RDS, Lambda) na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AWS for Backend Developers (EC2, S3, RDS, Lambda), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AWS for Backend Developers (EC2, S3, RDS, Lambda) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

What is Asynchronous Invocation?

When you invoke an AWS Lambda function asynchronously, you don't wait for the function's response. It's a "fire and forget" model.

The caller sends the event and doesn't wait for the result.
Lambda handles the queuing and execution in the background.
This pattern is perfect for event-driven architectures where immediate feedback isn't required.

How Asynchronous Invocation Works

Here's the typical flow for an asynchronous Lambda invocation:

An event source (like S3, SNS, or a direct invocation) sends an event.
Lambda places this event into an internal queue.
Lambda then invokes your function from this queue.
The event source receives an immediate success response, even if the function hasn't started processing yet.

Automatic Retries on Failure

One of the key benefits of asynchronous invocation is built-in fault tolerance. If your function encounters an unhandled error or times out during processing:

Lambda automatically retries the invocation.
By default, it attempts up to two more retries (total of three attempts).
These retries occur with exponential backoff, meaning increasing delays between attempts.

Customizing Retry Settings

You have control over how Lambda handles failures for asynchronous invocations:

You can configure the number of retry attempts (from 0 to 2).
You can also set a Maximum Event Age, which is the longest time Lambda retains an event in its internal queue for processing.
These settings can be adjusted in the Lambda console or through Infrastructure as Code (e.g., AWS SAM, CloudFormation).

Catching Failed Events with DLQs

What if your function fails after all retry attempts? By default, the event is dropped. This can lead to data loss.

A Dead-Letter Queue (DLQ) is a powerful feature that captures events that couldn't be processed successfully after all retries. It allows you to:

Inspect and debug the failed events.
Reprocess them later once the issue is resolved.
Prevent critical data from being lost.

Configuring a Dead-Letter Queue

You can configure an Amazon SQS queue or an Amazon SNS topic as your Lambda function's DLQ:

SQS Queue: Ideal for storing individual failed events for later batch processing or manual inspection.
SNS Topic: Useful for sending notifications about failed events to multiple subscribers (e.g., email, other Lambda functions).

You specify the ARN (Amazon Resource Name) of your chosen DLQ resource in your Lambda function's configuration.

Managing Concurrent Executions

Concurrency refers to the number of requests your Lambda function is processing at any given time. Lambda automatically scales up to handle incoming events.

However, uncontrolled scaling can sometimes be problematic:

Overloading downstream services (e.g., databases, APIs).
Incurring unexpected costs.

AWS provides tools to manage concurrency: Reserved Concurrency and Provisioned Concurrency.

Limiting Function Execution: Reserved Concurrency

Reserved concurrency allows you to set a maximum number of concurrent executions for a specific Lambda function.

It guarantees that your function always has that amount of capacity available.
It prevents a single function from consuming all the available concurrency in your AWS account.
If invocations exceed the reserved limit, they are throttled (rejected).

Keeping Functions Warm: Provisioned Concurrency

Provisioned concurrency pre-initializes a specified number of execution environments for your function.

This significantly reduces cold starts, which are delays that occur when Lambda needs to set up a new execution environment.
It's ideal for latency-sensitive applications like APIs where consistent, low-latency responses are crucial.
You pay for provisioned concurrency even when the function isn't actively invoked.

Async Function with DLQ Example

Here's a simple Python Lambda function that simulates a failure based on event data. If configured with a DLQ, failed events would be sent there.

The if __name__ == "__main__": block demonstrates how to test it locally.

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}")

Async Invocation Check

Consider an asynchronous Lambda function configured with a Dead-Letter Queue (DLQ). If the function fails on its initial invocation and then again on its first retry, what is the default behavior?

Async Lambda Recap

We explored asynchronous Lambda invocation, a "fire and forget" model ideal for event-driven architectures.

Learned about default retry behavior and how to customize it.
Understood Dead-Letter Queues (DLQs) for capturing and managing failed events, preventing data loss.
Finally, we covered concurrency controls: Reserved Concurrency to limit max executions and Provisioned Concurrency to reduce cold starts.

Często zadawane pytania

Czy lekcja „Asynchroniczne wywoływanie Lambda” jest bezpłatna?

Tak — pełny tekst „Asynchroniczne wywoływanie Lambda” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AWS for Backend Developers (EC2, S3, RDS, Lambda), przejdź na CoddyKit PRO. Kurs AWS for Backend Developers (EC2, S3, RDS, Lambda) zawiera 4 lekcji w sumie.

Co nauczysz się w „Asynchroniczne wywoływanie Lambda”?

Zaimplementuj wzorce asynchroniczne dla funkcji Lambda, obsługując ponowienia, kolejki komunikatów bez możliwości dostarczenia oraz kontrolę współbieżności. Ćwiczysz AWS for Backend Developers (EC2, S3, RDS, Lambda) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AWS for Backend Developers (EC2, S3, RDS, Lambda)?

Nie wymagamy żadnego doświadczenia. AWS for Backend Developers (EC2, S3, RDS, Lambda) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Asynchroniczne wywoływanie Lambda”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AWS for Backend Developers (EC2, S3, RDS, Lambda)?

Tak. Każda lekcja AWS for Backend Developers (EC2, S3, RDS, Lambda) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do AWS for Backend Developers (EC2, S3, RDS, Lambda)