0Pricing
AWS for Backend Developers (EC2, S3, RDS, Lambda) · 课时

Lambda 触发器与集成

将 Lambda 函数连接到 S3、DynamoDB 和 API Gateway 等 AWS 服务，创建强大的事件驱动工作流。

Lambda 触发器与集成 是 CoddyKit 上的免费 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 AWS for Backend Developers (EC2, S3, RDS, Lambda) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Events Bring Lambda to Life

Welcome to the heart of serverless architecture: Lambda Triggers! These are the events that tell your Lambda function when to run. Instead of constantly running a server, your function springs into action only when needed.

Think of it like a doorbell for your code. Someone presses the button (an event occurs), and your function responds.

How Triggers Work: Push vs. Pull

Lambda triggers come in two main flavors:

  • Push-based: The event source (like S3 or SNS) directly invokes your Lambda function when an event happens. Lambda receives the event and runs your code.
  • Pull-based: Lambda itself polls an event source (like SQS queues or DynamoDB Streams) for new items. When new data is found, Lambda retrieves it and invokes your function.

Understanding this helps you design efficient event-driven workflows.

S3 Event Triggers: React to Storage

One of the most common and powerful triggers is Amazon S3. You can configure an S3 bucket to automatically invoke a Lambda function whenever specific events occur, such as:

  • New object created (e.g., an image upload)
  • Object deleted
  • Object restored

This is perfect for tasks like image resizing, data validation, or generating thumbnails as soon as a file is uploaded.

S3 Trigger Demo: Logging Uploads

Here's a basic Python Lambda function that would be triggered by an S3 object creation event. It simply logs the bucket and object key from the event data.

Try running the simulated event:

import json

def lambda_handler(event, context):
    """
    Simulated Lambda handler for S3 events.
    Logs the details of the S3 event.
    """
    print("--- S3 Event Received ---")
    for record in event.get('Records', []):
        bucket_name = record['s3']['bucket']['name']
        object_key = record['s3']['object']['key']
        event_name = record['eventName']
        print(f"Bucket: {bucket_name}")
        print(f"Object: {object_key}")
        print(f"Event: {event_name}")
    print("-------------------------")
    return {
        'statusCode': 200,
        'body': json.dumps('S3 event logged!')
    }

if __name__ == "__main__":
    # Simulate an S3 PUT event
    mock_event = {
        "Records": [
            {
                "eventSource": "aws:s3",
                "eventName": "ObjectCreated:Put",
                "s3": {
                    "bucket": {"name": "my-cool-bucket"},
                    "object": {"key": "my-new-file.txt"}
                }
            }
        ]
    }
    lambda_handler(mock_event, None)

DynamoDB Streams: Database Changes

Amazon DynamoDB Streams provide a time-ordered sequence of item-level modifications in a DynamoDB table. When you enable a stream, every create, update, or delete operation is captured.

Lambda can be configured to read from these streams, allowing you to react to database changes in real-time. Use cases include:

  • Data replication across tables
  • Auditing changes
  • Triggering downstream workflows

DynamoDB Stream Demo: Processing Updates

This Python Lambda function simulates processing events from a DynamoDB Stream. It logs the event type (INSERT, MODIFY, REMOVE) and the keys/new image of the affected item.

Run it to see how a database change event looks:

import json

def lambda_handler(event, context):
    """
    Simulated Lambda handler for DynamoDB Stream events.
    Logs the details of the changed records.
    """
    print("--- DynamoDB Stream Event Received ---")
    for record in event.get('Records', []):
        event_name = record['eventName']
        keys = record['dynamodb']['Keys']
        new_image = record['dynamodb'].get('NewImage', {})
        print(f"Event: {event_name}")
        print(f"Keys: {json.dumps(keys)}")
        print(f"New Image: {json.dumps(new_image)}")
    print("------------------------------------")
    return {
        'statusCode': 200,
        'body': json.dumps('DynamoDB stream processed!')
    }

if __name__ == "__main__":
    # Simulate a DynamoDB INSERT event
    mock_event = {
        "Records": [
            {
                "eventID": "1",
                "eventName": "INSERT",
                "dynamodb": {
                    "Keys": {"id": {"S": "123"}},
                    "NewImage": {"id": {"S": "123"}, "name": {"S": "Alice"}},
                    "StreamViewType": "NEW_AND_OLD_IMAGES"
                }
            }
        ]
    }
    lambda_handler(mock_event, None)

API Gateway: Serverless API Endpoints

Amazon API Gateway acts as a 'front door' for applications to access backend services, including Lambda functions. It handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls.

By integrating API Gateway with Lambda, you can build powerful, scalable, and secure RESTful APIs without managing any servers. Users make an HTTP request, API Gateway routes it to your Lambda, and your Lambda returns a response.

API Gateway Demo: Your Serverless API

This Lambda function shows how to respond to an API Gateway request. It receives event data about the HTTP request and returns a JSON response, which API Gateway then sends back to the client.

Run the simulation to see the expected output:

import json

def lambda_handler(event, context):
    """
    Simulated Lambda handler for API Gateway events.
    Returns a simple JSON response.
    """
    print("--- API Gateway Event Received ---")
    print(f"HTTP Method: {event.get('httpMethod')}")
    print(f"Path: {event.get('path')}")
    print("----------------------------------")

    response_body = {
        "message": "Hello from your serverless API!",
        "input": event
    }
    return {
        'statusCode': 200,
        'headers': {
            'Content-Type': 'application/json'
        },
        'body': json.dumps(response_body)
    }

if __name__ == "__main__":
    # Simulate an API Gateway GET request event
    mock_event = {
        "resource": "/",
        "path": "/",
        "httpMethod": "GET",
        "headers": {
            "Accept": "text/html"
        },
        "queryStringParameters": None,
        "pathParameters": None,
        "body": None,
        "isBase64Encoded": False
    }
    response = lambda_handler(mock_event, None)
    print("\n--- API Response ---")
    print(json.dumps(response, indent=2))

More Powerful Integrations

Lambda can integrate with many other AWS services to build incredibly flexible architectures:

  • Amazon SQS: Process messages from a queue for asynchronous tasks.
  • Amazon SNS: Respond to notifications (e.g., sending emails or SMS).
  • CloudWatch Events/EventBridge: Trigger Lambda functions on a schedule, or in response to AWS service events (e.g., an EC2 instance state change).
  • Kinesis: Process real-time streaming data.

These integrations form the backbone of modern, event-driven applications.

Quick Check

Test your knowledge of Lambda triggers!

Recap: The Heart of Serverless Workflows

You've learned that Lambda functions are powerful, but they need triggers to come to life! These triggers are events from other AWS services that automatically invoke your function.

We explored how S3, DynamoDB Streams, and API Gateway can act as direct event sources, enabling you to build responsive, event-driven applications without managing servers. Understanding triggers is key to unlocking the full potential of serverless architecture!

常见问题解答

「Lambda 触发器与集成」课时是免费的吗？

是的 — 「Lambda 触发器与集成」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课程的其余内容，请升级到 CoddyKit PRO。 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课程共包含 4 节课。

「Lambda 触发器与集成」这节课中我会学到什么？

将 Lambda 函数连接到 S3、DynamoDB 和 API Gateway 等 AWS 服务，创建强大的事件驱动工作流。 你通过在浏览器中直接运行的动手代码来练习 AWS for Backend Developers (EC2, S3, RDS, Lambda)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 AWS for Backend Developers (EC2, S3, RDS, Lambda) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「Lambda 触发器与集成」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课中编写并运行代码吗？

能。每节 AWS for Backend Developers (EC2, S3, RDS, Lambda) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 什么是 AWS Lambda？
  2. 构建您的第一个 Lambda 函数
  3. Lambda 触发器与集成
  4. 监控与调试 Lambda 函数
← 返回 AWS for Backend Developers (EC2, S3, RDS, Lambda)