本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # AWS 解决方案构造入门 本主题介绍如何安装和配置 AWS Cloud Development Kit (AWS CDK)、AWS 解决方案构造，以及如何使用 AWS 解决方案构造模式创建您的第一个 AWS CDK 应用程序。 **注意** AWS CDK 版本 ≥ 1.46.0 的 AWS CDK 支持 AWS 解决方案构造。 **提示** 想要深入挖掘？ 试试试试看[CDK 研讨会](https://cdkworkshop.com/)了解真实世界项目的更深入介绍。 **提示** 有关 AWS Cloud Development Kit (AWS CDK) 入门的更多信息，请参阅[AWS CDK 开发人员指南](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html)。 ## Prerequisites AWS 解决方案构造是基于 AWS CDK 构建的，因此您需要安装 Node.js (>= 10.3.0)，即使是那些使用 TypeScript 或 JavaScript 以外的语言工作的解决方案也是如此。这是因为[AWS CDK](https://github.com/aws/aws-cdk)和 AWS 解决方案构造是在 TypeScript 中开发的，并在 Node.js 上运行。其他支持语言的绑定使用此后端和工具集。 您必须提供您的证书和 AWS 区域才能使用 AWS CDK CLI，如指定您的证书和区域中所述。 其他先决条件取决于您的开发语言，如下所示。 | **语言** | **先决条件** | | --- | --- | | ![\[Python\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/python.png)Python | Python >= 3.6 | | ![\[TypeScript\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/typescript.png)TypeScript | TypeScript >= 2.7 | | ![\[Java\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/java.png)Java | Java >= 1.8 | ## 安装 AWS CDK 要安装和配置 AWS CDK，请参阅 AWS CDK 开发人员指南-[安装 AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_install)。 ## 使用 AWS 解决方案构造 使用 AWS 解决方案构造时创建新应用程序的典型工作流程采用与 AWS CDK 相同的方法。 1. 创建应用程序目录。 1. 初始化应用程序。 1. 添加 AWS 解决方案构造模式依赖关系。 1. 将其他代码添加到应用程序。 1. 如有必要，编译应用程序。 1. 部署应用程序中定义的资源。 1. 测试应用程序。 如果存在任何问题，请循环修改、编译（如有必要）、部署和测试。 # 演练-第 1 部分 **注意** AWS CDK 版本等于 1.46.0，支持 AWS 解决方案构造。 本教程将向您介绍如何创建和部署一个简单的 “Hello 构造” AWS CDK 应用程序，该应用程序使用 AWS 解决方案构造中的模式，从初始化项目到部署生成的 AWS CloudFormation 模板。Hello 构造应用程序将创建以下简单的解决方案： ![\[架构示意图\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/tutorial-part1.png) ## Hello 构造 让我们开始使用基于模式的开发来构建我们的第一个 AWS CDK 应用程序。 **注意** 这是一个修改示例`Hello CDK!`来自 的[CDK 研讨会](https://cdkworkshop.com/)。如果这是您第一次使用 AWS CDK，我们建议您从本研讨会开始进行实践演练，以及如何利用 CDK 构建真实项目。 ## 创建应用程序目录并初始化 AWS CDK 为 CDK 应用程序创建目录，然后在该目录中创建 AWS CDK 应用程序。 ------ #### [ TypeScript ] ``` mkdir hello-constructs cd hello-constructs cdk init --language typescript ``` ------ #### [ Python ] ``` mkdir hello-constructs cd hello-constructs cdk init --language python ``` ------ **提示** 现在是在您最喜爱的 IDE 中打开项目并进行探索的好时机。要了解有关项目结构的更多信息，请选择相应的链接： [TypeScript](https://cdkworkshop.com/20-typescript/20-create-project/300-structure.html) [Python](https://cdkworkshop.com/30-python/20-create-project/300-structure.html) ## 更新项目基础依赖 **警告** 为确保正确的功能，AWS 解决方案构造和 AWS CDK 包必须在您的项目中使用相同的版本号。例如，如果您使用的是 AWS 解决方案构造 v.1.52.0，则还必须使用 AWS CDK v.1.52.0。 **提示** 请注意 AWS 解决方案构造的最新版本，并将该版本号应用于`VERSION_NUMBER`占位符（适用于 AWS 解决方案构造和 AWS CDK 包）。要检查构造库的所有公开版本，[Click here](https://github.com/awslabs/aws-solutions-constructs/releases)。 ------ #### [ TypeScript ] 编辑`package.json`文件并输入以下信息： ``` "devDependencies": { "@aws-cdk/assert": "VERSION_NUMBER", "@types/jest": "^24.0.22", "@types/node": "10.17.5", "jest": "^24.9.0", "ts-jest": "^24.1.0", "aws-cdk": "VERSION_NUMBER", "ts-node": "^8.1.0", "typescript": "~3.7.2" }, "dependencies": { "@aws-cdk/core": "VERSION_NUMBER", "source-map-support": "^0.5.16" } ``` ------ #### [ Python ] 编辑`setup.py`文件并输入以下信息： ``` install_requires=[ "aws-cdk.core==VERSION_NUMBER", ], ``` ------ 安装项目基础依赖关系。 ------ #### [ TypeScript ] ``` npm install ``` ------ #### [ Python ] ``` source .venv/bin/activate pip install -r requirements.txt ``` ------ 构建并运行应用程序，并确认它创建了一个空堆栈。 ------ #### [ TypeScript ] ``` npm run build cdk synth ``` ------ #### [ Python ] ``` cdk synth ``` ------ 你应该看到一个类似如下的堆栈，其中`CDK-VERSION`是 CDK 的版本。（您的输出可能与此处显示的内容略有不同。） ------ #### [ TypeScript ] ``` Resources: CDKMetadata: Type: AWS::CDK::Metadata Properties: Modules: aws-cdk=CDK-VERSION,@aws-cdk/core=VERSION_NUMBER,@aws-cdk/cx-api=VERSION_NUMBER,jsii-runtime=node.js/10.17.0 ``` ------ #### [ Python ] ``` Resources: CDKMetadata: Type: AWS::CDK::Metadata Properties: Modules: aws-cdk=CDK-VERSION,@aws-cdk/core=VERSION_NUMBER,@aws-cdk/cx-api=VERSION_NUMBER,jsii-runtime=Python/3.7.7 ``` ------ ## Lambda 处理程序代码 我们将从 AWS Lambda 处理程序代码开始。 创建目录`lambda`，包含在项目树的根目录中。 ------ #### [ TypeScript ] 添加名为的文件`lambda/hello.js`，包含以下内容： ``` exports.handler = async function(event) { console.log("request:", JSON.stringify(event, null, 2)); return { statusCode: 200, headers: { "Content-Type": "text/plain" }, body: `Hello, AWS Solutions Constructs! You've hit ${event.path}\n` }; }; ``` ------ #### [ Python ] 添加名为的文件`lambda/hello.py`，包含以下内容： ``` import json def handler(event, context): print('request: {}'.format(json.dumps(event))) return { 'statusCode': 200, 'headers': { 'Content-Type': 'text/plain' }, 'body': 'Hello, CDK! You have hit {}\n'.format(event['path']) } ``` ------ 这是一个简单的 Lambda 函数，它返回文本 “你好，构造！您已经点击了 [网址路径]”。函数的输出还包括 HTTP 状态代码和 HTTP 标头。API Gateway 使用它们来制定对用户的 HTTP 响应。 这个 Lambda 是在 JavaScript 中提供的。有关用您选择的语言编写 Lambda 函数的详细信息，请参阅[AWS Lambda 文档](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)。 ## 安装 AWS CDK 和 AWS 解决方案构建依赖关系 AWS 解决方案构造随附一个丰富的结构库。该库分为模块，每个模块都有一个模块。例如，如果您想为 AWS Lambda 函数定义 Amazon API Gateway 剩余 API，我们将需要使用`aws-apigateway-lambda`Click 库。 我们还需要从 AWS CDK 添加 AWS Lambda 和 Amazon API Gateway 构造库。 将 AWS Lambda 模块及其所有依赖项安装到我们的项目中： **注意** 请记住，将用于 AWS 解决方案构造和 AWS CDK 的正确匹配版本替换为`VERSION_NUMBER`每个命令的占位符字段。软件包之间的版本不匹配可能会导致错误。 ------ #### [ TypeScript ] ``` npm install -s @aws-cdk/aws-lambda@VERSION_NUMBER ``` ------ #### [ Python ] ``` pip install aws_cdk.aws_lambda==VERSION_NUMBER ``` ------ 接下来，将 Amazon API Gateway 模块及其所有依赖项安装到我们的项目中： ------ #### [ TypeScript ] ``` npm install -s @aws-cdk/aws-apigateway@VERSION_NUMBER ``` ------ #### [ Python ] ``` pip install aws_cdk.aws_apigateway==VERSION_NUMBER ``` ------ 最后，安装 AWS 解决方案构造`aws-apigateway-lambda`模块及其所有依赖关系到我们的项目中： ------ #### [ TypeScript ] ``` npm install -s @aws-solutions-constructs/aws-apigateway-lambda@VERSION_NUMBER ``` ------ #### [ Python ] ``` pip install aws_solutions_constructs.aws_apigateway_lambda==VERSION_NUMBER ``` ------ ## 将亚马逊API 网关/AWS Lambda 模式添加到堆栈 现在，让我们定义 AWS 解决方案构造模式，用于使用 AWS Lambda 代理实现 Amazon API Gateway。 ------ #### [ TypeScript ] 编辑文件`lib/hello-constructs.ts`, 包含以下内容: ``` import * as cdk from '@aws-cdk/core'; import * as lambda from '@aws-cdk/aws-lambda'; import * as api from '@aws-cdk/aws-apigateway'; import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda'; export class HelloConstructsStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // The code that defines your stack goes here const api_lambda_props: ApiGatewayToLambdaProps = { lambdaFunctionProps: { code: lambda.Code.fromAsset('lambda'), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hello.handler' }, apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } } }; new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props); } } ``` ------ #### [ Python ] 编辑文件`hello_constructs/hello_constructs_stack.py`, 包含以下内容: ``` from aws_cdk import ( aws_lambda as _lambda, aws_apigateway as apigw, core, ) from aws_solutions_constructs import ( aws_apigateway_lambda as apigw_lambda ) class HelloConstructsStack(core.Stack): def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here apigw_lambda.ApiGatewayToLambda( self, 'ApiGatewayToLambda', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hello.handler', ), api_gateway_props=apigw.RestApiProps( default_method_options=apigw.MethodOptions( authorization_type=apigw.AuthorizationType.NONE ) ) ) ``` ------ 就是这样 为了定义代理 AWS Lambda 函数的所有请求的 API Gateway，您需要执行这些操作。让我们将我们的新堆栈与原始堆栈进行比较： ------ #### [ TypeScript ] ``` npm run build cdk diff ``` ------ #### [ Python ] ``` cdk diff ``` ------ 输出应该如下所示： ``` Stack HelloConstructsStack IAM Statement Changes ┌───┬─────────────────────────────┬────────┬─────────────────────────────┬─────────────────────────────┬──────────────────────────────┐ │ │ Resource │ Effect │ Action │ Principal │ Condition │ ├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤ │ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │ │ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │ │ │ │ │ │ │ S::Partition}:execute-api:${ │ │ │ │ │ │ │ AWS::Region}:${AWS::AccountI │ │ │ │ │ │ │ d}:${RestApi0C43BF4B}/${Rest │ │ │ │ │ │ │ Api/DeploymentStage.prod}/*/ │ │ │ │ │ │ │ {proxy+}" │ │ │ │ │ │ │ } │ │ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │ │ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │ │ │ │ │ │ │ S::Partition}:execute-api:${ │ │ │ │ │ │ │ AWS::Region}:${AWS::AccountI │ │ │ │ │ │ │ d}:${RestApi0C43BF4B}/test-i │ │ │ │ │ │ │ nvoke-stage/*/{proxy+}" │ │ │ │ │ │ │ } │ │ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │ │ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │ │ │ │ │ │ │ S::Partition}:execute-api:${ │ │ │ │ │ │ │ AWS::Region}:${AWS::AccountI │ │ │ │ │ │ │ d}:${RestApi0C43BF4B}/${Rest │ │ │ │ │ │ │ Api/DeploymentStage.prod}/*/ │ │ │ │ │ │ │ " │ │ │ │ │ │ │ } │ │ + │ ${LambdaFunction.Arn} │ Allow │ lambda:InvokeFunction │ Service:apigateway.amazonaw │ "ArnLike": { │ │ │ │ │ │ s.com │ "AWS:SourceArn": "arn:${AW │ │ │ │ │ │ │ S::Partition}:execute-api:${ │ │ │ │ │ │ │ AWS::Region}:${AWS::AccountI │ │ │ │ │ │ │ d}:${RestApi0C43BF4B}/test-i │ │ │ │ │ │ │ nvoke-stage/*/" │ │ │ │ │ │ │ } │ ├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤ │ + │ ${LambdaFunctionServiceRole │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.co │ │ │ │ .Arn} │ │ │ m │ │ ├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤ │ + │ ${LambdaRestApiCloudWatchRo │ Allow │ sts:AssumeRole │ Service:apigateway.amazonaw │ │ │ │ le.Arn} │ │ │ s.com │ │ ├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤ │ + │ arn:aws:logs:${AWS::Region} │ Allow │ logs:CreateLogGroup │ AWS:${LambdaRestApiCloudWat │ │ │ │ :${AWS::AccountId}:* │ │ logs:CreateLogStream │ chRole} │ │ │ │ │ │ logs:DescribeLogGroups │ │ │ │ │ │ │ logs:DescribeLogStreams │ │ │ │ │ │ │ logs:FilterLogEvents │ │ │ │ │ │ │ logs:GetLogEvents │ │ │ │ │ │ │ logs:PutLogEvents │ │ │ ├───┼─────────────────────────────┼────────┼─────────────────────────────┼─────────────────────────────┼──────────────────────────────┤ │ + │ arn:aws:logs:${AWS::Region} │ Allow │ logs:CreateLogGroup │ AWS:${LambdaFunctionService │ │ │ │ :${AWS::AccountId}:log-grou │ │ logs:CreateLogStream │ Role} │ │ │ │ p:/aws/lambda/* │ │ logs:PutLogEvents │ │ │ └───┴─────────────────────────────┴────────┴─────────────────────────────┴─────────────────────────────┴──────────────────────────────┘ (NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299) Parameters [+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/S3Bucket AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aS3Bucket9780A3BC: {"Type":"String","Description":"S3 bucket for asset \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""} [+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/S3VersionKey AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aS3VersionKey37F36FFB: {"Type":"String","Description":"S3 key for asset version \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""} [+] Parameter AssetParameters/ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a/ArtifactHash AssetParametersba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340aArtifactHash80199FBC: {"Type":"String","Description":"Artifact hash for asset \"ba91444ebd644d9419e8cfee417f3aaa728507dd428788a2fc40574646c4340a\""} Conditions [+] Condition CDKMetadataAvailable: {"Fn::Or":[{"Fn::Or":[{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-northeast-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-northeast-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-south-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-southeast-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ap-southeast-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"ca-central-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"cn-north-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"cn-northwest-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-central-1"]}]},{"Fn::Or":[{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-north-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"eu-west-3"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"me-south-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"sa-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-east-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-east-2"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-west-1"]},{"Fn::Equals":[{"Ref":"AWS::Region"},"us-west-2"]}]}]} Resources [+] AWS::Logs::LogGroup ApiGatewayToLambda/ApiAccessLogGroup ApiGatewayToLambdaApiAccessLogGroupE2B41502 [+] AWS::IAM::Role LambdaFunctionServiceRole LambdaFunctionServiceRole0C4CDE0B [+] AWS::Lambda::Function LambdaFunction LambdaFunctionBF21E41F [+] AWS::ApiGateway::RestApi RestApi RestApi0C43BF4B [+] AWS::ApiGateway::Deployment RestApi/Deployment RestApiDeployment180EC503d2c6df3c8dc8b7193b98c1a0bff4e677 [+] AWS::ApiGateway::Stage RestApi/DeploymentStage.prod RestApiDeploymentStageprod3855DE66 [+] AWS::ApiGateway::Resource RestApi/Default/{proxy+} RestApiproxyC95856DD [+] AWS::Lambda::Permission RestApi/Default/{proxy+}/ANY/ApiPermission.HelloConstructsStackRestApiFDB18C2E.ANY..{proxy+} RestApiproxyANYApiPermissionHelloConstructsStackRestApiFDB18C2EANYproxyE43D39B3 [+] AWS::Lambda::Permission RestApi/Default/{proxy+}/ANY/ApiPermission.Test.HelloConstructsStackRestApiFDB18C2E.ANY..{proxy+} RestApiproxyANYApiPermissionTestHelloConstructsStackRestApiFDB18C2EANYproxy0B23CDC7 [+] AWS::ApiGateway::Method RestApi/Default/{proxy+}/ANY RestApiproxyANY1786B242 [+] AWS::Lambda::Permission RestApi/Default/ANY/ApiPermission.HelloConstructsStackRestApiFDB18C2E.ANY.. RestApiANYApiPermissionHelloConstructsStackRestApiFDB18C2EANY5684C1E6 [+] AWS::Lambda::Permission RestApi/Default/ANY/ApiPermission.Test.HelloConstructsStackRestApiFDB18C2E.ANY.. RestApiANYApiPermissionTestHelloConstructsStackRestApiFDB18C2EANY81DBDF56 [+] AWS::ApiGateway::Method RestApi/Default/ANY RestApiANYA7C1DC94 [+] AWS::ApiGateway::UsagePlan RestApi/UsagePlan RestApiUsagePlan6E1C537A [+] AWS::Logs::LogGroup ApiAccessLogGroup ApiAccessLogGroupCEA70788 [+] AWS::IAM::Role LambdaRestApiCloudWatchRole LambdaRestApiCloudWatchRoleF339D4E6 [+] AWS::ApiGateway::Account LambdaRestApiAccount LambdaRestApiAccount Outputs [+] Output RestApi/Endpoint RestApiEndpoint0551178A: {"Value":{"Fn::Join":["",["https://",{"Ref":"RestApi0C43BF4B"},".execute-api.",{"Ref":"AWS::Region"},".",{"Ref":"AWS::URLSuffix"},"/",{"Ref":"RestApiDeploymentStageprod3855DE66"},"/"]]}} ``` 这是不错的。这个简单的示例包含 AWS 解决方案构造中的一个架构良好的模式，为您的堆栈添加了 21 个新资源。 ## CDK 部署 **提示** 您必须引导 AWS 环境，然后才能部署包含 Lambda 函数的第一个 AWS CDK 应用程序。这将创建一个临时存储桶，AWS CDK 用于部署包含资产的堆栈。如果这是您第一次使用 AWS CDK 部署资产，则需要运行`cdk bootstrap`将 CDK 工具包堆栈部署到您的 AWS 环境中。 好了，已做好部署准备了吗？ ``` cdk deploy ``` ## 堆栈输出 部署完成后，您将注意到以下行： ``` Outputs: HelloConstructsStack.RestApiEndpoint0551178A = https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/ ``` 这是由 AWS 解决方案构造模式自动添加的堆栈输出，其中包含 API Gateway 终端节点的 URL。 ## 测试应用程序 让我们尝试使用`curl`。复制 URL 并执行（您的前缀和地区可能会有所不同）。 ``` curl https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/ ``` 输出应该如下所示： ``` Hello, AWS Solutions Constructs! You've hit / ``` 如果这是您收到的输出，您的应用程序可以正常工作！ # 演练-第 2 部分 **注意** AWS CDK 版本 ≥ 1.46.0，支持 AWS 解决方案构造。 本教程将向您介绍如何修改[第 1 部分](walkthrough-part-1.md)。我们的修改将使用 AWS Lambda 向 AWS 解决方案构造中的 DynamoDB 模式添加站点点击计数器。修改 Hello 构造应用程序将导致以下解决方案： ![\[alt text not found\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/tutorial-part2.png) ## 点击计数器 Lambda 代码 让我们先为命中计数器 AWS Lambda 函数编写代码。此函数将： + 增加一个与 Amazon DynamoDB 表中的 API 路径相关的计数器， + 调用下游 Hello AWS Lambda 函数， + 并将响应返回给最终用户。 ------ #### [ TypeScript ] 添加名为的文件`lambda/hitcounter.js`更改为以下内容： ``` const { DynamoDB, Lambda } = require('aws-sdk'); exports.handler = async function(event) { console.log("request:", JSON.stringify(event, undefined, 2)); // create AWS SDK clients const dynamo = new DynamoDB(); const lambda = new Lambda(); // update dynamo entry for "path" with hits++ await dynamo.updateItem({ TableName: process.env.DDB_TABLE_NAME, Key: { path: { S: event.path } }, UpdateExpression: 'ADD hits :incr', ExpressionAttributeValues: { ':incr': { N: '1' } } }).promise(); // call downstream function and capture response const resp = await lambda.invoke({ FunctionName: process.env.DOWNSTREAM_FUNCTION_NAME, Payload: JSON.stringify(event) }).promise(); console.log('downstream response:', JSON.stringify(resp, undefined, 2)); // return response back to upstream caller return JSON.parse(resp.Payload); }; ``` ------ #### [ Python ] 添加名为的文件`lambda/hitcounter.py`更改为以下内容： ``` import json import os import boto3 ddb = boto3.resource('dynamodb') table = ddb.Table(os.environ['DDB_TABLE_NAME']) _lambda = boto3.client('lambda') def handler(event, context): print('request: {}'.format(json.dumps(event))) table.update_item( Key={'path': event['path']}, UpdateExpression='ADD hits :incr', ExpressionAttributeValues={':incr': 1} ) resp = _lambda.invoke( FunctionName=os.environ['DOWNSTREAM_FUNCTION_NAME'], Payload=json.dumps(event), ) body = resp['Payload'].read() print('downstream response: {}'.format(body)) return json.loads(body) ``` ------ ## 安装新的依赖关系 **注意** 请记住，将用于 AWS 解决方案构造和 AWS CDK 的正确匹配版本替换为`VERSION_NUMBER`每个命令的占位符字段。这应该与本演练第一部分用于依赖关系的版本号相同。软件包之间的版本不匹配可能会导致错误。 像往常一样，我们首先需要安装我们的解决方案更新所需的依赖关系。首先，我们需要安装 DynamoDB 构造库： ------ #### [ TypeScript ] ``` npm install -s @aws-cdk/aws-dynamodb@VERSION_NUMBER ``` ------ #### [ Python ] ``` pip install aws_cdk.aws_dynamodb==VERSION_NUMBER ``` ------ 最后，安装 AWS 解决方案构造`aws-lambda-dynamodb`模块及其所有依赖关系到我们的项目中： ------ #### [ TypeScript ] ``` npm install -s @aws-solutions-constructs/aws-lambda-dynamodb@VERSION_NUMBER ``` ------ #### [ Python ] ``` pip install aws_solutions_constructs.aws_lambda_dynamodb==VERSION_NUMBER ``` ------ ## 定义资源 现在，让我们更新我们的堆栈代码以适应我们的新架构。 首先，我们将导入我们的新依赖关系，并将 “Hello” 函数移动到`aws-apigateway-lambda`模式，我们在第 1 部分创建。 ------ #### [ TypeScript ] 编辑文件`lib/hello-constructs.ts`更改为以下内容： ``` import * as cdk from '@aws-cdk/core'; import * as lambda from '@aws-cdk/aws-lambda'; import * as api from '@aws-cdk/aws-apigateway'; import * as dynamodb from '@aws-cdk/aws-dynamodb'; import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda'; import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb'; export class HelloConstructsStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // The code that defines your stack goes here const helloFunc = new lambda.Function(this, 'HelloHandler', { runtime: lambda.Runtime.NODEJS_12_X, code: lambda.Code.fromAsset('lambda'), handler: 'hello.handler' }); const api_lambda_props: ApiGatewayToLambdaProps = { lambdaFunctionProps: { code: lambda.Code.fromAsset('lambda'), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hello.handler' }, apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } } }; new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props); } } ``` ------ #### [ Python ] 编辑文件`hello_constructs/hello_constructs_stack.py`更改为以下内容： ``` from aws_cdk import ( aws_lambda as _lambda, aws_apigateway as apigw, aws_dynamodb as ddb, core, ) from aws_solutions_constructs import ( aws_apigateway_lambda as apigw_lambda, aws_lambda_dynamodb as lambda_ddb ) class HelloConstructsStack(core.Stack): def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here self._handler = _lambda.Function( self, 'HelloHandler', runtime=_lambda.Runtime.PYTHON_3_7, handler='hello.handler', code=_lambda.Code.asset('lambda'), ) apigw_lambda.ApiGatewayToLambda( self, 'ApiGatewayToLambda', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hello.handler', ), api_gateway_props=apigw.RestApiProps( default_method_options=apigw.MethodOptions( authorization_type=apigw.AuthorizationType.NONE ) ) ) ``` ------ 接下来，我们将添加`aws-lambda-dynamodb`模式来构建我们更新的架构的命中计数器服务。 ![\[alt text not found\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/tutorial-part2a.png) 下面的下一个更新定义了`aws-lambda-dynamodb`模式，方法是使用命中计数器处理程序定义 AWS Lambda 函数。此外，Amazon DynamoDB 表的定义名称为`Hits`和一个分区键`path`。 ------ #### [ TypeScript ] 编辑文件`lib/hello-constructs.ts`更改为以下内容： ``` import * as cdk from '@aws-cdk/core'; import * as lambda from '@aws-cdk/aws-lambda'; import * as api from '@aws-cdk/aws-apigateway'; import * as dynamodb from '@aws-cdk/aws-dynamodb'; import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda'; import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb'; export class HelloConstructsStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // The code that defines your stack goes here const helloFunc = new lambda.Function(this, 'HelloHandler', { runtime: lambda.Runtime.NODEJS_12_X, code: lambda.Code.fromAsset('lambda'), handler: 'hello.handler' }); // hit counter, aws-lambda-dynamodb pattern const lambda_ddb_props: LambdaToDynamoDBProps = { lambdaFunctionProps: { code: lambda.Code.asset(`lambda`), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hitcounter.handler', environment: { DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName } }, dynamoTableProps: { tableName: 'Hits', partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING } } }; const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props); const api_lambda_props: ApiGatewayToLambdaProps = { lambdaFunctionProps: { code: lambda.Code.fromAsset('lambda'), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hello.handler' }, apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } } }; new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props); } } ``` ------ #### [ Python ] 编辑文件`hello_constructs/hello_constructs_stack.py`更改为以下内容： ``` from aws_cdk import ( aws_lambda as _lambda, aws_apigateway as apigw, aws_dynamodb as ddb, core, ) from aws_solutions_constructs import ( aws_apigateway_lambda as apigw_lambda, aws_lambda_dynamodb as lambda_ddb ) class HelloConstructsStack(core.Stack): def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here self.hello_func = _lambda.Function( self, 'HelloHandler', runtime=_lambda.Runtime.PYTHON_3_7, handler='hello.handler', code=_lambda.Code.asset('lambda'), ) # hit counter, aws-lambda-dynamodb pattern self.hit_counter = lambda_ddb.LambdaToDynamoDB( self, 'LambdaToDynamoDB', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hitcounter.handler', environment={ 'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name } ), dynamo_table_props=ddb.TableProps( table_name='Hits', partition_key={ 'name': 'path', 'type': ddb.AttributeType.STRING } ) ) apigw_lambda.ApiGatewayToLambda( self, 'ApiGatewayToLambda', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hello.handler', ), api_gateway_props=apigw.RestApiProps( default_method_options=apigw.MethodOptions( authorization_type=apigw.AuthorizationType.NONE ) ) ) ``` ------ 接下来，我们需要授予从`aws-lambda-dynamodb`模式来调用我们的 Hello 函数。 ------ #### [ TypeScript ] 编辑文件`lib/hello-constructs.ts`更改为以下内容： ``` import * as cdk from '@aws-cdk/core'; import * as lambda from '@aws-cdk/aws-lambda'; import * as api from '@aws-cdk/aws-apigateway'; import * as dynamodb from '@aws-cdk/aws-dynamodb'; import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda'; import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb'; export class HelloConstructsStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // The code that defines your stack goes here // hello function responding to http requests const helloFunc = new lambda.Function(this, 'HelloHandler', { runtime: lambda.Runtime.NODEJS_12_X, code: lambda.Code.fromAsset('lambda'), handler: 'hello.handler' }); // hit counter, aws-lambda-dynamodb pattern const lambda_ddb_props: LambdaToDynamoDBProps = { lambdaFunctionProps: { code: lambda.Code.asset(`lambda`), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hitcounter.handler', environment: { DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName } }, dynamoTableProps: { tableName: 'Hits', partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING } } }; const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props); // grant the hitcounter lambda role invoke permissions to the hello function helloFunc.grantInvoke(hitcounter.lambdaFunction); const api_lambda_props: ApiGatewayToLambdaProps = { lambdaFunctionProps: { code: lambda.Code.fromAsset('lambda'), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hello.handler' }, apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } } }; new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props); } } ``` ------ #### [ Python ] 编辑文件`hello_constructs/hello_constructs_stack.py`更改为以下内容： ``` from aws_cdk import ( aws_lambda as _lambda, aws_apigateway as apigw, aws_dynamodb as ddb, core, ) from aws_solutions_constructs import ( aws_apigateway_lambda as apigw_lambda, aws_lambda_dynamodb as lambda_ddb ) class HelloConstructsStack(core.Stack): def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here self.hello_func = _lambda.Function( self, 'HelloHandler', runtime=_lambda.Runtime.PYTHON_3_7, handler='hello.handler', code=_lambda.Code.asset('lambda'), ) # hit counter, aws-lambda-dynamodb pattern self.hit_counter = lambda_ddb.LambdaToDynamoDB( self, 'LambdaToDynamoDB', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hitcounter.handler', environment={ 'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name } ), dynamo_table_props=ddb.TableProps( table_name='Hits', partition_key={ 'name': 'path', 'type': ddb.AttributeType.STRING } ) ) # grant the hitcounter lambda role invoke permissions to the hello function self.hello_func.grant_invoke(self.hit_counter.lambda_function) apigw_lambda.ApiGatewayToLambda( self, 'ApiGatewayToLambda', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hello.handler', ), api_gateway_props=apigw.RestApiProps( default_method_options=apigw.MethodOptions( authorization_type=apigw.AuthorizationType.NONE ) ) ) ``` ------ 最后，我们需要更新原始`aws-apigateway-lambda`模式来利用我们的新命中计数器函数，该函数是通过`aws-lambda-dynamodb`模式。 ------ #### [ TypeScript ] 编辑文件`lib/hello-constructs.ts`更改为以下内容： ``` import * as cdk from '@aws-cdk/core'; import * as lambda from '@aws-cdk/aws-lambda'; import * as api from '@aws-cdk/aws-apigateway'; import * as dynamodb from '@aws-cdk/aws-dynamodb'; import { ApiGatewayToLambda, ApiGatewayToLambdaProps } from '@aws-solutions-constructs/aws-apigateway-lambda'; import { LambdaToDynamoDB, LambdaToDynamoDBProps } from '@aws-solutions-constructs/aws-lambda-dynamodb'; export class HelloConstructsStack extends cdk.Stack { constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // The code that defines your stack goes here // hello function responding to http requests const helloFunc = new lambda.Function(this, 'HelloHandler', { runtime: lambda.Runtime.NODEJS_12_X, code: lambda.Code.fromAsset('lambda'), handler: 'hello.handler' }); // hit counter, aws-lambda-dynamodb pattern const lambda_ddb_props: LambdaToDynamoDBProps = { lambdaFunctionProps: { code: lambda.Code.asset(`lambda`), runtime: lambda.Runtime.NODEJS_12_X, handler: 'hitcounter.handler', environment: { DOWNSTREAM_FUNCTION_NAME: helloFunc.functionName } }, dynamoTableProps: { tableName: 'Hits', partitionKey: { name: 'path', type: dynamodb.AttributeType.STRING } } }; const hitcounter = new LambdaToDynamoDB(this, 'LambdaToDynamoDB', lambda_ddb_props); // grant the hitcounter lambda role invoke permissions to the hello function helloFunc.grantInvoke(hitcounter.lambdaFunction); const api_lambda_props: ApiGatewayToLambdaProps = { existingLambdaObj: hitcounter.lambdaFunction, apiGatewayProps: { defaultMethodOptions: { authorizationType: api.AuthorizationType.NONE } } }; new ApiGatewayToLambda(this, 'ApiGatewayToLambda', api_lambda_props); } } ``` ------ #### [ Python ] 编辑文件`hello_constructs/hello_constructs_stack.py`更改为以下内容： ``` from aws_cdk import ( aws_lambda as _lambda, aws_apigateway as apigw, aws_dynamodb as ddb, core, ) from aws_solutions_constructs import ( aws_apigateway_lambda as apigw_lambda, aws_lambda_dynamodb as lambda_ddb ) class HelloConstructsStack(core.Stack): def __init__(self, scope: core.Construct, id: str, **kwargs) -> None: super().__init__(scope, id, **kwargs) # The code that defines your stack goes here self.hello_func = _lambda.Function( self, 'HelloHandler', runtime=_lambda.Runtime.PYTHON_3_7, handler='hello.handler', code=_lambda.Code.asset('lambda'), ) # hit counter, aws-lambda-dynamodb pattern self.hit_counter = lambda_ddb.LambdaToDynamoDB( self, 'LambdaToDynamoDB', lambda_function_props=_lambda.FunctionProps( runtime=_lambda.Runtime.PYTHON_3_7, code=_lambda.Code.asset('lambda'), handler='hitcounter.handler', environment={ 'DOWNSTREAM_FUNCTION_NAME': self.hello_func.function_name } ), dynamo_table_props=ddb.TableProps( table_name='Hits', partition_key={ 'name': 'path', 'type': ddb.AttributeType.STRING } ) ) # grant the hitcounter lambda role invoke permissions to the hello function self.hello_func.grant_invoke(self.hit_counter.lambda_function) apigw_lambda.ApiGatewayToLambda( self, 'ApiGatewayToLambda', existing_lambda_obj=self.hit_counter.lambda_function, api_gateway_props=apigw.RestApiProps( default_method_options=apigw.MethodOptions( authorization_type=apigw.AuthorizationType.NONE ) ) ) ``` ------ ## 查看更改 让我们构建我们的项目，并回顾我们在部署此项目时将发生的资源变化： ``` npm run build cdk diff ``` 我们的输出应该如下所示： ``` Stack HelloConstructsStack IAM Statement Changes ┌───┬───────────────────────────────────┬────────┬───────────────────────────────────┬────────────────────────────────────┬───────────┐ │ │ Resource │ Effect │ Action │ Principal │ Condition │ ├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤ │ + │ ${HelloHandler.Arn} │ Allow │ lambda:InvokeFunction │ AWS:${LambdaFunctionServiceRole} │ │ ├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤ │ + │ ${HelloHandler/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │ ├───┼───────────────────────────────────┼────────┼───────────────────────────────────┼────────────────────────────────────┼───────────┤ │ + │ ${LambdaToDynamoDB/DynamoTable.Ar │ Allow │ dynamodb:BatchGetItem │ AWS:${LambdaFunctionServiceRole} │ │ │ │ n} │ │ dynamodb:BatchWriteItem │ │ │ │ │ │ │ dynamodb:DeleteItem │ │ │ │ │ │ │ dynamodb:GetItem │ │ │ │ │ │ │ dynamodb:GetRecords │ │ │ │ │ │ │ dynamodb:GetShardIterator │ │ │ │ │ │ │ dynamodb:PutItem │ │ │ │ │ │ │ dynamodb:Query │ │ │ │ │ │ │ dynamodb:Scan │ │ │ │ │ │ │ dynamodb:UpdateItem │ │ │ └───┴───────────────────────────────────┴────────┴───────────────────────────────────┴────────────────────────────────────┴───────────┘ IAM Policy Changes ┌───┬─────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐ │ │ Resource │ Managed Policy ARN │ ├───┼─────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤ │ + │ ${HelloHandler/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │ └───┴─────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘ (NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299) Resources [+] AWS::IAM::Role HelloHandler/ServiceRole HelloHandlerServiceRole11EF7C63 [+] AWS::Lambda::Function HelloHandler HelloHandler2E4FBA4D [+] AWS::DynamoDB::Table LambdaToDynamoDB/DynamoTable LambdaToDynamoDBDynamoTable53C1442D [+] AWS::IAM::Policy LambdaFunctionServiceRole/DefaultPolicy LambdaFunctionServiceRoleDefaultPolicy126C8897 [~] AWS::Lambda::Function LambdaFunction LambdaFunctionBF21E41F ├─ [+] Environment │ └─ {"Variables":{"DOWNSTREAM_FUNCTION_NAME":{"Ref":"HelloHandler2E4FBA4D"},"DDB_TABLE_NAME":{"Ref":"LambdaToDynamoDBDynamoTable53C1442D"}}} ├─ [~] Handler │ ├─ [-] hello.handler │ └─ [+] hitcounter.handler └─ [~] DependsOn └─ @@ -1,3 +1,4 @@ [ ] [ [+] "LambdaFunctionServiceRoleDefaultPolicy126C8897", [ ] "LambdaFunctionServiceRole0C4CDE0B" [ ] ] ``` ## CDk 部署 好，准备部署了吗？ ``` cdk deploy ``` ## 堆栈输出 部署完成后，您将注意到以下内容： ``` Outputs: HelloConstructsStack.RestApiEndpoint0551178A = https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/ ``` ## 测试应用程序 让我们尝试用 curl 击中这个端点。复制 URL 并执行（您的前缀和区域可能会有所不同）。 ``` curl https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/ ``` 输出应该如下所示： ``` Hello, AWS Solutions Constructs! You've hit / ``` 现在，我们来看一下`Hits`Amazon DynamoDB 表。 1. 转到 DynamoDB 控制台。 1. 确保您位于创建表的区域。 1. Select**表**，然后选择**命中数**表。 1. 打开表格并选择 “项目”。 1. 你应该看到你为每个路径获得了多少点击。 ![\[alt text not found\]](http://docs.aws.amazon.com/zh_cn/solutions/latest/constructs/images/tutorial-part2b.png) 1. 尝试点击新路径并刷新 “项目” 视图。您应看到一个新项目，包含`hits`计数为 1。 如果这是您收到的输出，您的应用程序可以正常工作！ # 示例使用案例 此库包括一系列功能用例实现，用于演示构造架构模式的用法。它们可以用与架构模式相同的方式使用，并且可以被概念化为这些模式的额外 “更高级别” 抽象。以下用例作为功能示例提供： ## AWS 静态 S3 网站 这个用例模式（`aws-s3-static-website`）实现了一个 Amazon CloudFront 分发、Amazon S3 存储桶和基于 AWS Lambda 的自定义资源，以复制 Wild Rydes 演示网站的静态网站内容（`aws-serverless-web-app`实现。 **源代码（aws-s3-静态网站）** [https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-s3-static-website](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-s3-static-website) ## AWS 简单无服务器映像处理程序 这个用例模式（`aws-serverless-image-handler`）实现了 Amazon CloudFront 分发、Amazon API Gateway REST API、AWS Lambda 函数和必要的权限/逻辑，以配置功能图像处理程序 API，用于从部署账户中的一个或多个 Amazon S3 存储桶提供图像内容。 **源代码（AWS 无服务器图像处理程序）** [https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-serverless-image-handler](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-serverless-image-handler) ## AWS 无服务器 Web 应用程序 这个用例模式（`aws-serverless-web-app`）实现了一个简单的无服务器 Web 应用程序，允许用户从 Wild Rydes 舰队请求独角兽骑行。该应用程序将向用户提供一个基于 HTML 的用户界面，用于指示他们想要被拾取的位置，并将在后端与 RESTful Web 服务进行接口，以提交请求并派遣附近的独角兽。该应用程序还将为用户提供服务注册和登录的设施，然后再申请乘车服务。 **源代码（AWS 无服务器网络应用程序）** [https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use\$1cases/aws-serverless-web-app](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-serverless-web-app)