Serverless Backend with AWS Lambda & API Gateway · レッスン

エラー処理とリトライ

回復力の高いサーバーレスアプリケーションに必要な、堅牢なエラー処理、デッドレターキュー、リトライ機構を実装します。

「エラー処理とリトライ」はCoddyKit上の無料Serverless Backend with AWS Lambda & API Gatewayレッスンです。これはレッスン3/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはServerless Backend with AWS Lambda & API Gateway学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Serverless Backend with AWS Lambda & API Gatewayコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Build Resilient Serverless Apps

In serverless architectures, things can go wrong. Network issues, service outages, or bugs in your code can all lead to failures.

Building resilient applications means they can recover gracefully from these issues, minimizing impact on users and preventing data loss. Error handling and retries are key to this.

Lambda Invocation Types

How Lambda handles errors and retries depends on how your function is invoked. There are two main types:

Synchronous: The caller waits for a response (e.g., API Gateway, ALB).
Asynchronous: The caller doesn't wait; Lambda queues the event (e.g., S3, SNS, SQS, EventBridge).

Each type has different retry behaviors by default.

Synchronous Invocation Retries

When a Lambda function is invoked synchronously and returns an error (or times out), Lambda does NOT automatically retry the function.

It's up to the service or client that invoked Lambda (e.g., API Gateway, your mobile app) to implement its own retry logic. Lambda simply passes the error back to the caller.

Asynchronous Invocation Retries

For asynchronous invocations, Lambda has built-in retry mechanisms. If your function fails due to an unhandled error or times out, Lambda will automatically retry the invocation twice.

This means a total of three attempts (initial + two retries) are made, with an exponential backoff between retries. This helps overcome transient issues.

Handling Errors in Code

Beyond Lambda's automatic retries, you should always implement error handling *within* your function code. This allows you to:

Gracefully manage expected errors (e.g., missing input).
Log specific details for debugging.
Return custom error messages to callers.

In Python, the try-except block is your best friend for this.

Python Error Handling Example

This Python Lambda function uses try-except to handle potential KeyError if an expected key is missing, or ZeroDivisionError if a value is zero. Try running it with different inputs!

import json

def lambda_handler(event, context):
    try:
        # Expecting 'value' key in the event
        num = event['value']
        result = 100 / num
        return {
            'statusCode': 200,
            'body': json.dumps(f'Result: {result}')
        }
    except KeyError:
        print("Error: 'value' key missing in event.")
        return {
            'statusCode': 400,
            'body': json.dumps('Input Error: Missing \'value\' in event.')
        }
    except ZeroDivisionError:
        print("Error: Cannot divide by zero.")
        return {
            'statusCode': 400,
            'body': json.dumps('Input Error: Cannot divide by zero.')
        }
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return {
            'statusCode': 500,
            'body': json.dumps(f'Server Error: {str(e)}')
        }

# Example of how to run locally for testing
if __name__ == "__main__":
    # Test case 1: Missing key
    print("\n--- Test Case 1 (Missing Key) ---")
    print(lambda_handler({}, None))

    # Test case 2: Zero division
    print("\n--- Test Case 2 (Zero Division) ---")
    print(lambda_handler({'value': 0}, None))

    # Test case 3: Success
    print("\n--- Test Case 3 (Success) ---")
    print(lambda_handler({'value': 25}, None))

    # Test case 4: Non-numeric value (unhandled, falls to generic exception)
    print("\n--- Test Case 4 (Type Error) ---")
    print(lambda_handler({'value': 'abc'}, None))

Dead-Letter Queues (DLQs)

What happens if an asynchronous Lambda invocation fails even after all retries? This is where Dead-Letter Queues (DLQs) come in!

A DLQ is an Amazon SQS queue or SNS topic where Lambda sends events it couldn't process successfully after all retry attempts. It's a crucial mechanism for:

Preventing data loss.
Debugging persistent issues.
Manual reprocessing of failed events.

Configuring a DLQ

To set up a DLQ for your Lambda function:

Create an SQS queue or SNS topic: This will be your DLQ.
Grant Permissions: Ensure your Lambda function has permission to publish messages to the chosen SQS queue or SNS topic.
Configure Lambda: In your Lambda function's configuration (under 'Asynchronous invocation'), specify the ARN of your SQS queue or SNS topic as the DLQ.

This ensures failed events have a safe landing spot.

DLQ Behavior in Action

It's important to understand *when* an event is sent to a DLQ:

Only for asynchronous invocations.
After all automatic retry attempts (initial + two retries) have failed.
If the event's maximum age is exceeded, or the maximum retry attempts are exhausted.

The original event payload, along with some metadata, is sent to the DLQ.

DLQ Understanding

Let's check your understanding of Dead-Letter Queues!

Recap: Error Handling & Retries

You've learned how to make your serverless applications more robust!

Synchronous vs. Asynchronous: Different invocation types have different default retry behaviors.
In-code Error Handling: Use try-except to catch and manage errors within your Lambda code.
Dead-Letter Queues (DLQs): A critical mechanism for capturing and inspecting events that fail after all automatic retries, preventing data loss for async invocations.

These practices are essential for building reliable serverless systems!

よくある質問

「エラー処理とリトライ」レッスンは無料ですか？

はい。「エラー処理とリトライ」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Serverless Backend with AWS Lambda & API Gatewayコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Serverless Backend with AWS Lambda & API Gatewayコースには全4レッスンが含まれています。

「エラー処理とリトライ」で何を学びますか？

回復力の高いサーバーレスアプリケーションに必要な、堅牢なエラー処理、デッドレターキュー、リトライ機構を実装します。ブラウザで直接実行するハンズオンコードでServerless Backend with AWS Lambda & API Gatewayを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Serverless Backend with AWS Lambda & API Gatewayを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのServerless Backend with AWS Lambda & API Gatewayは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン3/4です。

「エラー処理とリトライ」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このServerless Backend with AWS Lambda & API Gatewayレッスンでコードを書いて実行できますか？

はい。すべてのServerless Backend with AWS Lambda & API Gatewayレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Serverless Backend with AWS Lambda & API Gatewayに戻る