学习

Task	内容	是否必做	练习的能力
Task 1	创建 DynamoDB 表 `todos`	必做	数据持久化 / NoSQL 表设计
Task 2	创建 Lambda 函数 `todo_handler`

Task	内容	是否必做	练习的能力
Task 1	创建 DynamoDB 表 `todos`	必做	数据持久化 / NoSQL 表设计
Task 2	创建 Lambda 函数 `todo_handler`

ChatGPT 说 · Jimmy Huang's Blog

打开 DynamoDB dashboard
点击 Create table
Table name 填：
plain text
```
todos
```
Primary key 填：
plain text
```
id
```
Primary key type 选择：
plain text
```
String
```
创建表
等表状态变成 Active
老师可能会演示：
- 手动创建 item
- filter table
- query table

打开 Lambda dashboard
点击 Create function
Runtime 选择：
plain text
```
Node.js 20.x
```
Function name 填：
plain text
```
todo_handler
```
Execution role 选择：
plain text
```
Use existing role
```
Role 选择：
plain text
```
LabRole / labRole
```
创建 Lambda function
把官方给的 JavaScript 代码复制到 Lambda editor
点击 Deploy
创建 Test Event
用 POST 测试插入一条 Todo
Exercise 1:
- 测试 GET 全部任务
- 测试 GET 指定任务
Exercise 2:
- 找出 DELETE 和 PUT 代码问题
- 修改成能正常工作的版本

打开 API Gateway
选择 REST API
点击 Build
选择 New API
API name 填：
plain text
```
todo-api
```
创建 API
创建 resource：
plain text
```
/api
```
在 /api 下创建 resource：
plain text
```
/tasks
```
对 /api/tasks 启用 CORS
在 /api/tasks 下创建 GET method
GET method 连接到 Lambda todo_handler
在 /api/tasks 下创建 POST method
POST method 连接到 Lambda todo_handler
测试 POST：

创建一个新的 S3 bucket
这个 bucket 用来存放 CSV 文件
创建新的 Lambda function：
plain text
```
todo_import_handler
```
Runtime 选择：
plain text
```
Python 3.9
```
Role 选择：
plain text
```
LabRole / labRole
```
在 Lambda 的 Function Overview / Designer 区域点击 Add trigger
Trigger source 选择：
plain text
```
S3
```
Bucket 选择刚刚创建的 bucket
添加 trigger
替换 Lambda 模板代码为官方 Python 代码
创建 CSV 文件
CSV 每行 3 列：

打开 Cloud9
Create Environment
填 name 和 optional description
默认配置即可
创建环境
等环境 ready
在 Cloud9 terminal 运行：
bash
```
aws sts get-caller-identity
```
如果 AWS Academy session 过期，需要重新：
bash
```
aws configure
```

在 Cloud9 terminal 运行：
bash
```
sam init
```
选择：
plain text
```
AWS Quick Start Templates
```
Runtime 选择：
plain text
```
Node.js 20.x
```
给项目起名字
进入 SAM 创建的项目目录
运行：
bash
```
sam build
```
部署：
bash
```
sam deploy --guided
```
根据提示配置 deployment
部署完成后找到：
plain text
```
HelloWorldApi
```
复制 OutputValue 到浏览器或用 curl 测试
删除 SAM 应用时，需要去 CloudFormation 删除 stack

问题	原因	解决
AWS Console 打不开	Lab 没启动	回到 Academy 点 Start Lab
创建资源失败	LabRole 或权限受限	按 Lab 要求使用 LabRole
一段时间后命令失效	session expired	重启 Learner Lab

错误	后果
table name 写成 `todo`	Lambda 代码里写的是 `todos`，会找不到表
primary key 写成 `taskId`	后面代码使用 `id`，会不匹配
id type 选 Number	后面 Lambda 生成的是字符串 ID，会不匹配
Region 切错	你以为表不存在

AWS Console 搜索：
plain text
```
Lambda
```
进入 Lambda dashboard
点击：
plain text
```
Create function
```
选择：
plain text
```
Author from scratch
```
Function name 填：
plain text
```
todo_handler
```
Runtime 选择：
plain text
```
Node.js 20.x
```
Permissions / Execution role 部分：
- 展开：
  plain text
  Change default execution role
- 选择：
  plain text
  Use an existing role
- Existing role 选择：
  plain text
  LabRole / labRole
点击：
plain text
```
Create function
```

id	title	desc	done	updatedAt
xxx	First Task	sample description	false	1710000000000

AWS Console 搜索：
plain text
```
API Gateway
```
进入 API Gateway
找到 REST API
点击：
plain text
```
Build
```
选择：
plain text
```
New API
```
API name 填：
plain text
```
todo-api
```
点击：
plain text
```
Create API
```

在 API Gateway 的 Resources 页面
选中根路径：
plain text
```
/
```
点击：
plain text
```
Actions
```
选择：
plain text
```
Create Resource
```
Resource Name 填：
plain text
```
api
```
Resource Path 应该自动变成：
plain text
```
/api
```
点击：
plain text
```
Create Resource
```

选中：
plain text
```
/api
```
Actions -> Create Resource
Resource Name 填：
plain text
```
tasks
```
Resource Path 应该是：
plain text
```
/tasks
```
勾选：
plain text
```
Enable API Gateway CORS
```
点击 Create Resource

选中：
plain text
```
/api/tasks
```
点击：
plain text
```
Actions
```
选择：
plain text
```
Create Method
```
下拉框选择：
plain text
```
GET
```
点击 checkmark
Integration type 选择：
plain text
```
Lambda Function
```
建议勾选：
plain text
```
Use Lambda Proxy integration
```
Lambda Region 选择你 Lambda 所在的 Region
Lambda Function 填：
plain text
```
todo_handler
```
保存
如果弹出 Add Permission to Lambda Function，点击 OK

选中：
plain text
```
/api/tasks
```
Actions -> Create Method
选择：
plain text
```
POST
```
Integration type:
plain text
```
Lambda Function
```
勾选：
plain text
```
Use Lambda Proxy integration
```
Lambda function:
plain text
```
todo_handler
```
保存
Add Permission 时点击 OK

选中：
plain text
```
/api/tasks
```
Actions -> Create Resource
Resource Name 填：
plain text
```
{taskId}
```
Resource Path 应该也是：
plain text
```
/{taskId}
```
勾选：
plain text
```
Enable API Gateway CORS
```
点击 Create Resource

选中：
plain text
```
/api/tasks/{taskId}
```
Actions -> Create Method
选择：
plain text
```
GET
```
Integration type:
plain text
```
Lambda Function
```
勾选：
plain text
```
Use Lambda Proxy integration
```
Lambda function:
plain text
```
todo_handler
```
保存
Add Permission 时点击 OK

选中：
plain text
```
/api/tasks/{taskId}
```
Actions -> Create Method
分别创建：
plain text
```
PUT
DELETE
```
Integration 都连接到：
plain text
```
todo_handler
```
勾选 Lambda Proxy integration
保存并允许 Add Permission

点击：
plain text
```
Actions
```
选择：
plain text
```
Deploy API
```
Deployment stage:
- 第一次选择：
  plain text
  [New Stage]
Stage name 填：
plain text
```
prod
```
Description 可选：
plain text
```
Lab09 first deployment
```
点击 Deploy

层	负责什么
API Gateway	接收 HTTP 请求，处理 URL、method、headers、CORS
Lambda	判断业务逻辑，例如 GET/POST/PUT/DELETE
DynamoDB	保存和读取 Todo 数据

AWS Console 搜索：
plain text
```
S3
```
进入 S3
点击：
plain text
```
Create bucket
```
Bucket name 填一个全球唯一名字，例如：
plain text
```
lab09-todo-import-你的名字或学号
```

进入 Lambda dashboard
点击 Create function
Function name 填：
plain text
```
todo_import_handler
```
Runtime 选择：
plain text
```
Python 3.9
```
Execution role 选择：
plain text
```
Use existing role
```
Role 选择：
plain text
```
LabRole / labRole
```
点击 Create function

Lambda	作用
`todo_handler`	处理 REST API 请求
`todo_import_handler`	处理 S3 上传事件，导入 CSV

打开 todo_import_handler
找到 Function Overview / Designer
点击：
plain text
```
Add trigger
```
Trigger source 选择：
plain text
```
S3
```
Bucket 选择刚刚创建的 bucket
Event type 选择类似：
plain text
```
All object create events
```
可选 suffix：
plain text
```
.csv
```
点击 Add

title	desc	done
Buy milk	2L milk	false
Finish lab	Complete serverless lab	false
Submit report	Upload PDF	true

错误	原因
AccessDenied	LabRole 权限不够或资源不在允许范围
ResourceNotFoundException	DynamoDB table 名字错或 Region 错
KeyError: Records	你手动 Test Event 格式不是 S3 event
UnicodeDecodeError	CSV 编码不是 UTF-8
IndexError	CSV 行不是 3 列

AWS Console 搜索：
plain text
```
Cloud9
```
打开 Cloud9 dashboard
点击：
plain text
```
Create Environment
```
填 Name，例如：
plain text
```
lab09-cloud9
```
Description 可选
下一页默认即可
点击 Create environment
等几分钟

HTTP Method	操作	本 Lab 对应
GET	读取	获取 tasks
POST	创建	新建 task
PUT	更新	修改 task
DELETE	删除	删除 task

plain text

用户 / 浏览器 / curl
        |
        v
API Gateway
负责接收 HTTP 请求
        |
        v
Lambda
负责运行后端业务逻辑
        |
        v
DynamoDB
负责保存 Todo 数据

plain text

第一阶段：先准备数据库
DynamoDB table: todos

第二阶段：写后端逻辑
Lambda function: todo_handler

第三阶段：把后端逻辑变成真正的 HTTP API
API Gateway REST API

第四阶段：实现自动化导入
S3 upload CSV -> trigger Lambda -> write to DynamoDB

第五阶段：了解更工程化的 Serverless 开发方式
Cloud9 + SAM

plain text

正确情况：

us-east-1
├── DynamoDB: todos
├── Lambda: todo_handler
├── API Gateway: todo-api
└── S3 bucket: todo-import-bucket


容易出错的情况：

us-east-1
├── Lambda: todo_handler

ap-southeast-2
└── DynamoDB: todos

结果：
Lambda 默认可能找不到你正在看的那个 table。

plain text

DynamoDB
└── Table: todos
    ├── Item 1
    │   ├── id
    │   ├── title
    │   ├── desc
    │   └── done
    ├── Item 2
    │   ├── id
    │   ├── title
    │   ├── desc
    │   └── done
    └── Item 3
        ├── id
        ├── title
        ├── desc
        └── done

plain text

HTTP request
    |
    v
API Gateway
    |
    v
Lambda event
    |
    v
todo_handler 判断 event.httpMethod
    |
    ├── GET    -> dynamo.scan / dynamo.get
    ├── POST   -> dynamo.put
    ├── PUT    -> dynamo.update
    └── DELETE -> dynamo.delete

plain text

GET /api/tasks
        |
        v
event.httpMethod = "GET"
event.pathParameters = null / undefined
        |
        v
读取全部 tasks


GET /api/tasks/abc-123
        |
        v
event.httpMethod = "GET"
event.pathParameters.taskId = "abc-123"
        |
        v
读取指定 task

plain text

/api/tasks
├── GET      获取全部 tasks
└── POST     创建 task

/api/tasks/{taskId}
├── GET      获取指定 task
├── PUT      更新指定 task
└── DELETE   删除指定 task

plain text

Upload tasks.csv to S3
        |
        v
S3 ObjectCreated Event
        |
        v
todo_import_handler
        |
        v
Read CSV content
        |
        v
DynamoDB put_item

plain text

传统方式：

用户手动点按钮
        |
        v
后端运行


Event-driven 方式：

事件发生：S3 有新文件
        |
        v
自动触发 Lambda
        |
        v
自动处理文件

plain text

Stack Name: sam-hello-world
AWS Region: 当前 Region
Confirm changes before deploy: Y
Allow SAM CLI IAM role creation: Y
Disable rollback: N
Save arguments to configuration file: Y

plain text

你的 SAM 项目
        |
        v
template.yaml
        |
        v
sam build
        |
        v
sam deploy
        |
        v
CloudFormation stack
        |
        ├── Lambda
        ├── API Gateway
        ├── S3 bucket
        └── IAM roles

plain text

手动上传 CSV 文件
        |
        v
S3 产生 ObjectCreated event
        |
        v
Lambda 自动被调用
        |
        v
读取 CSV
        |
        v
写入 DynamoDB

plain text

GET    /api/tasks          获取全部
POST   /api/tasks          创建一个
GET    /api/tasks/{id}     获取指定
PUT    /api/tasks/{id}     更新指定
DELETE /api/tasks/{id}     删除指定

plain text

API Gateway = 接待员
Lambda = 干活的人
DynamoDB = 存数据的柜子
S3 = 放文件的仓库
S3 Trigger = 仓库一有新文件就自动通知干活的人
SAM = 自动搭建这些服务的工具

plain text

一个 Serverless 应用通常由多个云服务协作完成。
每个服务只负责一部分：
API Gateway 负责入口
Lambda 负责逻辑
DynamoDB 负责数据
S3 负责文件
Trigger 负责事件驱动

javascript

import { DynamoDB } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
const dynamo = DynamoDBDocument.from(new DynamoDB());

export const handler = async (event, context) => {
   let body;
   let statusCode = '200';
   const headers = {'Content-Type': 'application/json',};
   const tableName = 'todos';
   try {
       switch (event.httpMethod) {
           case 'DELETE':
               body = await dynamo.delete(JSON.parse(event.body));
               break;
           case 'GET':
               if (event.pathParameters && event.pathParameters.taskId) {
                   let params = {
                       TableName: tableName,
                       FilterExpression: "id = :id",
                       ExpressionAttributeValues: {
                           ":id": event.pathParameters.taskId
                       },
                   };
                   body = await dynamo.scan(params);
               }
               else
                   body = await dynamo.scan({ TableName: tableName });
               break;
           case 'POST':
               var data = {};
               data.desc = event.body && JSON.parse(event.body.trim()).desc || '';
               data.done = event.body && JSON.parse(event.body.trim()).done || false;
               data.title = event.body && JSON.parse(event.body.trim()).title || '';
               data.id = context.awsRequestId;
               data.updatedAt = new Date().getTime();
               let params = {TableName: tableName, Item: data};
               body = await dynamo.put(params);
               body.message = data;
               statusCode = '201';
               break;
           case 'PUT':
               body = await dynamo.update(JSON.parse(event.body));
               break;
           default:
               throw new Error(`Unsupported method "${event.httpMethod}"`);
       }
   }
   catch (err) {
       statusCode = '400';
       body = err.message;
   }
   finally {
       body = JSON.stringify(body);
   }
   return {
       statusCode,
       body,
       headers,
   };
};

json

{
  "httpMethod": "PUT",
  "pathParameters": {
    "taskId": "把这里替换成你的真实 id"
  },
  "body": "{\"title\":\"Updated Task\",\"desc\":\"updated description\",\"done\":true}"
}

bash

curl -X POST "https://你的-api-id.execute-api.你的-region.amazonaws.com/prod/api/tasks" \
  -H "Content-Type: application/json" \
  -d '{"title":"newtask-from-curl","desc":"created from curl","done":false}'

bash

curl -X PUT "https://你的-api-id.execute-api.你的-region.amazonaws.com/prod/api/tasks/把这里换成真实id" \
  -H "Content-Type: application/json" \
  -d '{"title":"updated from curl","desc":"updated desc","done":true}'

python

import json
import boto3
import os
import sys
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):
   for record in event['Records']:
       bucket = record['s3']['bucket']['name']
       key = unquote_plus(record['s3']['object']['key'])
       print("File{0} uploaded to{1} bucket".format(key, bucket))
       csvfile = s3_client.get_object(Bucket=bucket, Key=key)
       csvcontent = csvfile['Body'].read().decode('utf8').splitlines()
       for line in csvcontent:
           tokens = line.strip().split(",")
           if len(tokens) > 2:
               data = {}
               data['id'] = {'S': str(uuid.uuid4())}
               data['title'] = {'S': tokens[0].strip()}
               data['desc'] = {'S': tokens[1].strip()}
               data['done'] = {'S': tokens[2].strip()}
               response = dynamodb.put_item(TableName=TABLE_NAME, Item=data)
   return {
       'statusCode': 200,
       'body': json.dumps('Records successfully inserted into database...')
   }

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

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

function makeResponse(statusCode, body) {
    return {
        statusCode,
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
    };
}

function parseBody(event) {
    if (!event.body) {
        return {};
    }

    if (typeof event.body === 'object') {
        return event.body;
    }

    return JSON.parse(event.body.trim());
}

export const handler = async (event, context) => {
    try {
        const method = event.httpMethod;

        switch (method) {
            case 'GET': {
                const taskId = event.pathParameters?.taskId;

                if (taskId) {
                    const result = await dynamo.get({
                        TableName: tableName,
                        Key: {
                            id: taskId,
                        },
                    });

                    return makeResponse(200, result.Item || {});
                }

                const result = await dynamo.scan({
                    TableName: tableName,
                });

                return makeResponse(200, result);
            }

            case 'POST': {
                const data = parseBody(event);

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

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

                return makeResponse(201, {
                    message: item,
                });
            }

            case 'PUT': {
                const data = parseBody(event);
                const id = event.pathParameters?.taskId || data.id;

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

                const result = await dynamo.update({
                    TableName: tableName,
                    Key: {
                        id: id,
                    },
                    UpdateExpression: 'set title = :title, #desc = :desc, done = :done, updatedAt = :updatedAt',
                    ExpressionAttributeNames: {
                        '#desc': 'desc',
                    },
                    ExpressionAttributeValues: {
                        ':title': data.title || '',
                        ':desc': data.desc || '',
                        ':done': data.done ?? false,
                        ':updatedAt': new Date().getTime(),
                    },
                    ReturnValues: 'ALL_NEW',
                });

                return makeResponse(200, {
                    message: result.Attributes,
                });
            }

            case 'DELETE': {
                const data = parseBody(event);
                const id = event.pathParameters?.taskId || data.id;

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

                await dynamo.delete({
                    TableName: tableName,
                    Key: {
                        id: id,
                    },
                });

                return makeResponse(200, {
                    message: `Task${id} deleted successfully`,
                });
            }

            default:
                throw new Error(`Unsupported method "${method}"`);
        }
    }
    catch (err) {
        return makeResponse(400, {
            error: err.message,
        });
    }
};

ChatGPT 说

0. 本周一句话总结

1. 本周 Lab / Applied 总览

1.1 主题是什么

1.2 这周总共要完成什么

ChatGPT 说

0. 本周一句话总结

1. 本周 Lab / Applied 总览

1.1 主题是什么

1.2 这周总共要完成什么

1.3 整个实验的主线是什么

1.4 这周每个 AWS 服务分别负责什么

DynamoDB

Lambda

API Gateway

S3

IAM Role / LabRole

SAM

2. PDF 中所有需要动手完成的任务清单

2.1 前置要求

2.2 Task 1: Data Persistence

2.3 Task 2: Lambda Business Logic

2.4 Task 3: API Gateway REST API

2.5 Task 4: Importing Todo Tasks from CSV Files

2.6 Task 5: Setup Cloud9 Development Environment

2.7 Task 6: Create Hello-World Serverless Application with SAM

3. Step-by-step 操作指导

Task 0：开始前检查环境

Step 0.1：登录 AWS Academy

Step 0.2：统一 Region

Task 1：创建 DynamoDB Table

Step 1.1：打开 DynamoDB

Step 1.2：创建 todos 表

Step 1.3：这一步背后的原理

Step 1.4：哪些地方必须理解

Task 2：创建 Lambda 实现 Todo 业务逻辑

Step 2.1：创建 Lambda function

Step 2.2：这一步背后的原理

Step 2.3：复制官方 Lambda 代码并 Deploy

Step 2.4：创建 POST Test Event

Step 2.5：这一步背后的原理

Step 2.6：检查 DynamoDB 里是否真的写入

Exercise 1：测试 GET 请求

Step 2.7：测试 GET 全部 tasks

Step 2.8：测试 GET 指定 task

Step 2.9：这一步背后的原理

Exercise 2：修正 DELETE 和 PUT 的问题

Step 2.10：先理解官方代码的问题

Step 2.11：替换成推荐修正版 Lambda 代码

Step 2.12：测试 PUT

Step 2.13：测试 DELETE

Step 2.14：PUT / DELETE 背后的原理

Task 3：用 API Gateway 创建 REST API

Step 3.1：创建 REST API

Step 3.2：创建 /api resource

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

Step 3.4：CORS 是什么

Step 3.5：在 /api/tasks 下创建 GET method

Step 3.6：为什么建议使用 Lambda Proxy integration

Step 3.7：在 /api/tasks 下创建 POST method

Step 3.8：在 API Gateway 内部测试 POST

Step 3.9：创建 /api/tasks/{taskId} resource

Step 3.10：给 /api/tasks/{taskId} 创建 GET method

Step 3.11：可选：创建 PUT 和 DELETE method

Step 3.12：Deploy API

Step 3.13：用浏览器测试 GET

Step 3.14：用 curl 测试 GET 和 POST

Step 3.15：API Gateway 背后的原理

Step 3.16：常见错误排查

错误 1：浏览器显示 Missing Authentication Token

错误 2：POST 返回 500

错误 3：改了 API 但 URL 还是旧结果

Task 4：S3 上传 CSV 自动导入 DynamoDB

Step 4.1：创建 S3 bucket

Step 4.2：创建导入用 Lambda function

Step 4.3：给 Lambda 添加 S3 Trigger

Step 4.4：粘贴 Python Lambda 代码

Step 4.5：理解这段 Python 代码

Step 4.6：创建 CSV 文件

Step 4.7：上传 CSV 到 S3

Step 1.2：创建 `todos` 表

Step 3.2：创建 `/api` resource

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

Step 3.5：在 `/api/tasks` 下创建 GET method

Step 3.7：在 `/api/tasks` 下创建 POST method

Step 3.9：创建 `/api/tasks/{taskId}` resource

Step 3.10：给 `/api/tasks/{taskId}` 创建 GET method

Q5：为什么要使用 `id` 作为 primary key？