Pemanggilan Lambda Asinkron

Welcome! In serverless, functions can be invoked in different ways. An asynchronous invocation means the caller doesn't wait for the function to finish executing.

Think of it like sending a letter: you drop it in the mailbox, and you don't wait for the recipient to read it. You trust it will be delivered and processed later.

When you invoke a Lambda function synchronously, you wait for a response immediately. Your application pauses until Lambda returns a result or an error.

With asynchronous invocation, Lambda places the event in an internal queue and immediately returns a success message to the caller. The actual function execution happens in the background.

When an event triggers an asynchronous Lambda invocation:

• Lambda receives the event from the caller (e.g., S3, SNS).
• It places the event in an internal queue.
• Lambda sends an immediate success response to the caller.
• Later, Lambda retrieves the event from the queue and invokes your function.
• The function processes the event, and any output is discarded.

When you invoke a Lambda function directly via the AWS SDK or CLI, you specify an InvocationType parameter:

• RequestResponse: For synchronous invocations (you wait for a response).
• Event: For asynchronous invocations (fire-and-forget).
• DryRun: To validate parameters without invoking.

Many AWS services (like S3, SNS, EventBridge) inherently invoke Lambda asynchronously when configured as triggers.

Asynchronous invocations offer significant advantages:

• Decoupling: The caller doesn't depend on the function's immediate response. It can continue its work without waiting.
• Scalability: Lambda can buffer events in its internal queue during traffic spikes, preventing your function from being overwhelmed and ensuring events are eventually processed.
• Resilience: If your function fails, Lambda can automatically retry the invocation.

Asynchronous invocation is perfect for tasks that might take a while to complete, like:

• Processing large files uploaded to S3.
• Sending email notifications.
• Transcoding videos.
• Updating multiple databases.

The client doesn't need to wait for these operations, improving user experience and application responsiveness.

By default, if an asynchronously invoked Lambda function fails, Lambda automatically retries the invocation twice, with an exponential backoff between attempts.

This built-in retry mechanism enhances the reliability of your serverless applications by handling transient errors without manual intervention.

You can customize the retry behavior for asynchronous invocations:

• Maximum event age: How long Lambda should keep an event in the queue before discarding it (default: 6 hours).
• Maximum retry attempts: How many times Lambda should retry the function (0 to 2 attempts).

These settings help control how long your system tries to process a failed event.

Imagine a user uploads an image to an S3 bucket. You want to resize it and add a watermark.

You can configure the S3 bucket to trigger a Lambda function whenever a new image is uploaded. S3 will asynchronously invoke your Lambda, which then processes the image. The user doesn't wait for the resizing to complete.

Here's a simple Python Lambda function that could be invoked asynchronously. It simulates a long-running task.

When invoked asynchronously, the caller won't wait for the time.sleep() to finish.

You've learned about the core concepts of asynchronous Lambda invocations.

Which of the following is a primary benefit of using asynchronous Lambda invocations?

Great job! You've mastered the basics of asynchronous Lambda invocations.

• They allow callers to "fire-and-forget" events.
• Lambda uses an internal queue for processing.
• Benefits include decoupling, scalability, and handling long-running tasks.
• Built-in retry mechanisms enhance reliability.

This pattern is fundamental for building robust and scalable event-driven serverless applications. Next, we'll look at handling failures effectively with Dead Letter Queues!