学习

Lab 09: Serverless Architecture in AWS · Jimmy Huang's Blog

对比点	Lambda	EC2
管理方式	AWS 管理运行环境	用户自己管理虚拟机
运行模式	被事件触发才运行	通常长期运行
扩展方式	AWS 自动扩展	需要配置 ASG 或手动扩展
适合场景	短任务、API、事件处理	长时间运行服务、复杂环境
本周用途	Todo API 逻辑、CSV 导入	本周不需要直接使用

对比点	API Gateway	Lambda
主要作用	接收 HTTP 请求	执行业务逻辑
是否写代码	通常主要配置	需要写函数代码
用户直接访问	是	通常不是
本周例子	`/api/tasks` URL	`todo_handler`

操作	作用	适合场景
scan	扫描表中数据	查询所有 tasks
get	根据主键查询一条记录	根据 `id` 查具体 task

概念	作用
S3 Upload	把 CSV 文件上传到 bucket
S3 Trigger	上传事件发生后自动调用 Lambda

plain text

Template source: AWS Quick Start Templates
Template: 7
Runtime: nodejs20.x
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]:N
Would you like to enable monitoring using CloudWatch Application Insights? [y/N]:N
Would you like to set Structured Logging in JSON format on your Lambda functions? [y/N]:N
Project name: 自己输入一个项目名，例如 hello-world-serverless

plain text

Stack Name: 回车
AWS Region: 回车
Confirm changes before deploy:Y
Allow SAM CLI IAM role creation:Y
Disable rollback:N
getAllItemsFunction has no authentication. Is this okay? [y/N]:y
getByIdFunction has no authentication. Is this okay? [y/N]:y
putItemFunction has no authentication. Is this okay?:y
Save arguments to configuration file [Y/n]:Y
SAM configuration file [samconfig.toml]:回车
SAM configuration environment [default]:回车

plain text

1. API Gateway: 删除 todo-api
2. Lambda: 删除 todo_handler 和 todo_import_handler
3. DynamoDB: 删除 todos 表
4. S3: 先清空 bucket，再删除 bucket
5. Cloud9: 如果创建了 environment，可以删除
6. CloudFormation: 如果用 SAM 部署了应用，删除对应 stack

javascript

import { DynamoDB } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';

const dynamo = DynamoDBDocument.from(new DynamoDB());
const tableName = 'todos';

export const handler = async (event, context) => {
  let body;
  let statusCode = 200;

  const headers = {
    'Content-Type': 'application/json',
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Headers': 'Content-Type',
    'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS'
  };

  try {
    const taskId = event.pathParameters?.taskId;
    const requestBody = event.body ? JSON.parse(event.body.trim()) : {};

    switch (event.httpMethod) {
      case 'GET': {
        if (taskId) {
          body = await dynamo.get({
            TableName: tableName,
            Key: {
              id: taskId
            }
          });

          if (!body.Item) {
            statusCode = 404;
            body = {
              message: 'Task not found'
            };
          }
        } else {
          body = await dynamo.scan({
            TableName: tableName
          });
        }

        break;
      }

      case 'POST': {
        const data = {
          id: context.awsRequestId,
          title: requestBody.title || '',
          desc: requestBody.desc || '',
          done: requestBody.done ?? false,
          updatedAt: new Date().getTime()
        };

        await dynamo.put({
          TableName: tableName,
          Item: data
        });

        statusCode = 201;
        body = {
          message: data
        };

        break;
      }

      case 'PUT': {
        const idToUpdate = taskId || requestBody.id;

        if (!idToUpdate) {
          throw new Error('Missing task id for PUT request');
        }

        const allowedFields = ['title', 'desc', 'done'];
        const updateExpressions = [];
        const expressionAttributeNames = {};
        const expressionAttributeValues = {};

        for (const field of allowedFields) {
          if (requestBody[field] !== undefined) {
            updateExpressions.push(`#${field} = :${field}`);
            expressionAttributeNames[`#${field}`] = field;
            expressionAttributeValues[`:${field}`] = requestBody[field];
          }
        }

        if (updateExpressions.length === 0) {
          throw new Error('No valid fields provided for update');
        }

        updateExpressions.push('#updatedAt = :updatedAt');
        expressionAttributeNames['#updatedAt'] = 'updatedAt';
        expressionAttributeValues[':updatedAt'] = new Date().getTime();

        body = await dynamo.update({
          TableName: tableName,
          Key: {
            id: idToUpdate
          },
          UpdateExpression: `SET${updateExpressions.join(', ')}`,
          ExpressionAttributeNames: expressionAttributeNames,
          ExpressionAttributeValues: expressionAttributeValues,
          ReturnValues: 'ALL_NEW'
        });

        body = {
          message: 'Task updated successfully',
          updatedTask: body.Attributes
        };

        break;
      }

      case 'DELETE': {
        const idToDelete = taskId || requestBody.id;

        if (!idToDelete) {
          throw new Error('Missing task id for DELETE request');
        }

        body = await dynamo.delete({
          TableName: tableName,
          Key: {
            id: idToDelete
          },
          ReturnValues: 'ALL_OLD'
        });

        if (!body.Attributes) {
          statusCode = 404;
          body = {
            message: 'Task not found'
          };
        } else {
          body = {
            message: 'Task deleted successfully',
            deletedTask: body.Attributes
          };
        }

        break;
      }

      default:
        throw new Error(`Unsupported method "${event.httpMethod}"`);
    }
  } catch (err) {
    statusCode = 400;
    body = {
      error: err.message
    };
  }

  return {
    statusCode,
    body: JSON.stringify(body),
    headers
  };
};

json

{
  "httpMethod": "PUT",
  "pathParameters": {
    "taskId": "替换成你自己的 task id"
  },
  "body": "{\n\"title\":\"Updated Task Title\",\n\"desc\":\"updated description\",\n\"done\": true\n}"
}

python

import json
import boto3
import uuid
from urllib.parse import unquote_plus

s3_client = boto3.client('s3')
dynamodb = boto3.client('dynamodb')

TABLE_NAME = 'todos'

def lambda_handler(event, context):
    inserted_count = 0

    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = unquote_plus(record['s3']['object']['key'])

        print(f"File{key} uploaded to{bucket} bucket")

        csvfile = s3_client.get_object(Bucket=bucket, Key=key)
        csvcontent = csvfile['Body'].read().decode('utf8').splitlines()

        for index, line in enumerate(csvcontent):
            if not line.strip():
                continue

            tokens = line.strip().split(",")

            if len(tokens) < 3:
                print(f"Skipping invalid row:{line}")
                continue

            title = tokens[0].strip()
            desc = tokens[1].strip()
            done_raw = tokens[2].strip().lower()

            if index == 0 and title.lower() == "title" and desc.lower() == "desc":
                print("Skipping CSV header row")
                continue

            data = {
                'id': {
                    'S': str(uuid.uuid4())
                },
                'title': {
                    'S': title
                },
                'desc': {
                    'S': desc
                },
                'done': {
                    'BOOL': done_raw == 'true'
                }
            }

            dynamodb.put_item(
                TableName=TABLE_NAME,
                Item=data
            )

            inserted_count += 1

    return {
        'statusCode': 200,
        'body': json.dumps(f'{inserted_count} records successfully inserted into database.')
    }

bash

sudo dnf install -y nodejs20
sudo alternatives --set node /usr/bin/node-20
node -v
docker pull public.ecr.aws/sam/build-nodejs20.x:latest
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs20.x:latest
df -h
docker system df
rm -rf .aws-sam
rm -rf ~/.npm/_cacache
sudo dnf clean all
docker container prune -f
docker builder prune -af
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs20.x:latest

Lab 09: Serverless Architecture in AWS

Overview

Goal

Lab 09: Serverless Architecture in AWS

Overview

Goal

Task 0: 准备 AWS Academy 环境

Step 0.1：登录 AWS Academy

Step 0.2：确认 Region

Task 1: Data Persistence - 创建 DynamoDB 表

Step 1.1：进入 DynamoDB Dashboard

Step 1.2：创建 todos 表

Step 1.3：理解 DynamoDB 表结构

Task 2: Implement Business Logic Using Lambda

Step 2.1：创建 Lambda Function

Step 2.2：粘贴并部署 Lambda 代码

Step 2.3：创建 POST 测试事件

Step 2.4：创建 GET 全部任务测试事件

Step 2.5：创建 GET 指定任务测试事件

Step 2.6：测试 PUT 更新任务

Step 2.7：测试 DELETE 删除任务

Task 3: Implement RESTful API Using API Gateway

Step 3.1：创建 REST API

Step 3.2：创建 /api Resource

Step 3.3：创建 /api/tasks Resource 并启用 CORS

Step 3.4：给 /api/tasks 创建 GET Method

Step 3.5：给 /api/tasks 创建 POST Method

Step 3.6：创建 /api/tasks/{taskId} Resource

Step 3.7：给 /api/tasks/{taskId} 创建 GET Method

Step 3.8：可选创建 PUT 和 DELETE Method

Step 3.9：Deploy API

Step 3.10：用 curl 测试 GET /api/tasks

Step 3.11：用 curl 测试 POST /api/tasks

Step 3.12：用 curl 测试 GET /api/tasks/{taskId}

Step 3.13：可选测试 PUT 和 DELETE

Task 4: Import Todo Tasks from CSV Files

Step 4.1：创建 S3 Bucket

Step 4.2：创建 todo_import_handler Lambda

Step 4.3：添加 S3 Trigger

Step 4.4：粘贴 CSV 导入 Lambda 代码

Step 4.5：创建 CSV 文件

Step 4.6：上传 CSV 到 S3

Step 4.7：检查 Lambda Invocation

Step 4.8：验证 DynamoDB 是否插入数据

Task 5: Setup Development Environment with Cloud9（Optional）

Step 5.1：创建 Cloud9 Environment

Step 5.2：验证 AWS CLI

Task 6: Create Hello World Serverless Application with SAM（Optional）

Step 6.1：初始化 SAM 项目

Step 6.2：进入项目目录

Step 6.3：构建 SAM 项目

Step 6.4：部署 SAM 项目

Step 6.5：测试 HelloWorldApi

Step 6.6：删除 SAM 创建的资源

Summary

本周必须理解的知识点

1. Serverless 是什么

2. Lambda 是什么

3. API Gateway 是什么

4. DynamoDB 是什么

5. S3 Trigger 是什么

6. SAM 是什么

关键概念对比

Lambda vs EC2

API Gateway vs Lambda

DynamoDB scan vs get

S3 Upload vs S3 Trigger

最后清理资源

Step 1.2：创建 `todos` 表

Step 3.2：创建 `/api` Resource

Step 3.3：创建 `/api/tasks` Resource 并启用 CORS

Step 3.4：给 `/api/tasks` 创建 GET Method

Step 3.5：给 `/api/tasks` 创建 POST Method

Step 3.6：创建 `/api/tasks/{taskId}` Resource

Step 3.7：给 `/api/tasks/{taskId}` 创建 GET Method

Step 3.10：用 curl 测试 GET `/api/tasks`

Step 3.11：用 curl 测试 POST `/api/tasks`

Step 3.12：用 curl 测试 GET `/api/tasks/{taskId}`

Step 4.2：创建 `todo_import_handler` Lambda