教程：部署无服务器应用程序

在 CodeCatalyst导航窗格中，选择代码，然后选择源存储库。

选择添加存储库，然后选择创建存储库。

在存储库名称中，输入：

codecatalyst-cfn-source-repository

选择创建。

为该角色创建策略，如下所示：

1. 登录到 AWS。

2. 从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

3. 在导航窗格中，选择策略。

4. 选择创建策略。

5. 选择 JSON 选项卡。

6. 删除现有代码。

7. 粘贴以下代码：

   {
       "Version": "2012-10-17",
       "Statement": [{
       "Action": [
           "cloudformation:CreateStack",
           "cloudformation:DeleteStack",
           "cloudformation:Describe*",
           "cloudformation:UpdateStack",
           "cloudformation:CreateChangeSet",
           "cloudformation:DeleteChangeSet",
           "cloudformation:ExecuteChangeSet",
           "cloudformation:SetStackPolicy",
           "cloudformation:ValidateTemplate",
           "cloudformation:List*",
           "iam:PassRole"
       ],
       "Resource": "*",
       "Effect": "Allow"
   }]
   }

   注意

   首次使用该角色运行工作流程操作时，请在资源策略语句中使用通配符，然后在策略可用后使用资源名称缩小策略范围。

   "Resource": "*"

8. 选择下一步：标签。

9. 选择下一步：审核。

10. 在名称中，输入：

    codecatalyst-deploy-policy

11. 选择 创建策略。

    现在，您已经创建了权限策略。

创建部署角色，如下所示：

1. 在导航窗格中，选择 Roles（角色），然后选择 Create role（创建角色）。

2. 选择 “自定义信任策略”。

3. 删除现有的自定义信任策略。

4. 添加以下自定义信任策略：

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Sid": "",
               "Effect": "Allow",
               "Principal": {
                   "Service":  [
                      "codecatalyst-runner.amazonaws.com",
                      "codecatalyst.amazonaws.com"
                    ]
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }

5. 选择下一步。

6. 在权限策略中，搜索codecatalyst-deploy-policy并选中其复选框。

7. 选择下一步。

8. 在 “角色名称” 中，输入：

   codecatalyst-deploy-role

9. 在角色描述中，输入：

   CodeCatalyst deploy role

10. 选择 创建角色。

现在，您已经创建了一个带有信任策略和权限策略的部署角色。

按如下方式获取部署角色ARN：

1. 在导航窗格中，选择角色。

2. 在搜索框中，输入您刚刚创建的角色的名称（codecatalyst-deploy-role）。

3. 从列表中选择角色。

   此时将显示该角色的 “摘要” 页面。

4. 在顶部，复制该ARN值。

现在，您已经创建了具有相应权限的部署角色并获得了该角色ARN。

为该角色创建策略，如下所示：

1. 登录到 AWS。

2. 从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

3. 在导航窗格中，选择策略。

4. 选择创建策略。

5. 选择 JSON 选项卡。

6. 删除现有代码。

7. 粘贴以下代码：

   {
       "Version": "2012-10-17",
       "Statement": [{
       "Action": [
           "s3:PutObject",
           "iam:PassRole"
       ],
       "Resource": "*",
       "Effect": "Allow"
   }]
   }

   注意

   首次使用该角色运行工作流程操作时，请在资源策略语句中使用通配符，然后在策略可用后使用资源名称缩小策略范围。

   "Resource": "*"

8. 选择下一步：标签。

9. 选择下一步：审核。

10. 在名称中，输入：

    codecatalyst-build-policy

11. 选择 创建策略。

    现在，您已经创建了权限策略。

创建生成角色，如下所示：

1. 在导航窗格中，选择 Roles（角色），然后选择 Create role（创建角色）。

2. 选择 “自定义信任策略”。

3. 删除现有的自定义信任策略。

4. 添加以下自定义信任策略：

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Sid": "",
               "Effect": "Allow",
               "Principal": {
                   "Service":  [
                      "codecatalyst-runner.amazonaws.com",
                      "codecatalyst.amazonaws.com"
                    ]
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }

5. 选择下一步。

6. 在权限策略中，搜索codecatalyst-build-policy并选中其复选框。

7. 选择下一步。

8. 在 “角色名称” 中，输入：

   codecatalyst-build-role

9. 在角色描述中，输入：

   CodeCatalyst build role

10. 选择 创建角色。

现在，您已经创建了一个包含信任策略和权限策略的构建角色。

获取构建角色ARN，如下所示：

1. 在导航窗格中，选择角色。

2. 在搜索框中，输入您刚刚创建的角色的名称（codecatalyst-build-role）。

3. 从列表中选择角色。

   此时将显示该角色的 “摘要” 页面。

4. 在顶部，复制该ARN值。

现在，您已经创建了具有相应权限的构建角色并获得了该角色ARN。

AWS 使用要部署堆栈的账户登录。

从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

按如下方式创建堆栈角色：

1. 在导航窗格中，选择角色。

2. 选择 创建角色。

3. 选择 AWS 服务。

4. 在用例部分，CloudFormation从下拉列表中进行选择。

5. 选择 CloudFormation 单选按钮。

6. 在底部，选择下一步。

7. 使用搜索框找到以下权限策略，然后选中相应的复选框。

   注意

   如果您搜索的政策未显示，请务必选择 “清除筛选条件”，然后重试。

   • CloudWatchFullAccess

   • AWS CloudFormationFullAccess

   • IAMFullAccess

   • AWS Lambda_ FullAccess

   • 一个mazonAPIGateway管理员

   • 亚马逊 3 FullAccess

   • Amazon EC2ContainerRegistryFullAccess

   第一个策略允许访问 CloudWatch 以在警报发生时启用堆栈回滚。

   其余策略 AWS SAM 允许访问堆栈中将在本教程中部署的服务和资源。有关更多信息，请参阅《AWS Serverless Application Model 开发人员指南》中的权限。

8. 选择下一步。

9. 在 “角色名称” 中，输入：

   codecatalyst-stack-role

10. 选择 创建角色。

按如下方式获取堆栈角色：ARN

1. 在导航窗格中，选择角色。

2. 在搜索框中，输入您刚刚创建的角色的名称（codecatalyst-stack-role）。

3. 从列表中选择角色。

4. 在 “摘要” 部分中，复制该ARN值。稍后您将需要用到它。

现在，您已经创建了具有相应权限的堆栈角色，并且已经获得了该角色ARN。

在中 CodeCatalyst，导航到您的空间。

选择 AWS accounts (账户)。此时将显示账户关联列表。

选择代表您在其中创建构建和部署角色的 AWS 账户的账户连接。

从管理控制台中选择 “ AWS 管理角色”。

将出现 “向 Amazon CodeCatalyst 空间添加IAM角色” 页面。您可能需要登录才能访问该页面。

选择添加您在中创建的现有角色IAM。

将出现一个下拉列表。该列表显示了所有具有信任策略的IAM角色，其中包括codecatalyst-runner.amazonaws.com和codecatalyst.amazonaws.com服务委托人。

在下拉列表中，选择codecatalyst-build-role，然后选择添加角色。

选择添加IAM角色，选择添加您在中创建的现有角色 IAM，然后在下拉列表中选择codecatalyst-deploy-role。选择 Add role (添加角色)。

现在，您已将构建和部署角色添加到您的空间。

复制 A mazon CodeCatalyst 显示名称的值。稍后，在创建工作流程时，您将需要此值。

打开 Amazon S3 控制台，网址为https://console.aws.amazon.com/s3/。

在主窗格中，选择创建存储桶。

在存储桶名称中，输入：

codecatalyst-cfn-s3-bucket

对于 AWS 区域（亚马逊云科技区域），选择一个区域。本教程假设您选择了美国西部（俄勒冈）us-west-2。有关 Amazon S3 支持的区域的信息，请参阅中的亚马逊简单存储服务终端节点和配额AWS 一般参考。

在页面底部，选择创建存储桶。

打开 CodeCatalyst 控制台，网址为 https://codecatalyst.aws/。

选择你的项目，codecatalyst-cfn-project

在导航窗格中，选择代码，然后选择源存储库。

从源存储库列表中，选择您的存储库codecatalyst-cfn-source-repository。

在文件中，选择创建文件。

在 “文件名” 栏中输入：

.npmignore

在文本框中，输入以下代码：

tests/*

选择 “提交”，然后再次选择 “提交”。

现在，您已经在存储库的根目录.npmignore中创建了一个名为的文件。

在存储库中的 “文件” 中，选择 “创建文件”。

在 “文件名” 栏中输入：

package.json

在文本框中，输入以下代码：

{
  "name": "hello_world",
  "version": "1.0.0",
  "description": "hello world sample for NodeJS",
  "main": "app.js",
  "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
  "author": "SAM CLI",
  "license": "MIT",
  "dependencies": {
    "axios": "^0.21.1",
    "nyc": "^15.1.0"
  },
  "scripts": {
    "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
  },
  "devDependencies": {
    "aws-sdk": "^2.815.0",
    "chai": "^4.2.0",
    "mocha": "^8.2.1"
  }
}

选择 “提交”，然后再次选择 “提交”。

现在，您已在存储库的根目录中package.json添加了一个名为的文件。

在存储库中的 “文件” 中，选择 “创建文件”。

在 “文件名” 栏中输入：

sam-template.yml

在文本框中，输入以下代码：

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
  serverless-api

  Sample SAM Template for serverless-api
  
# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
Globals:
  Function:
    Timeout: 3

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
    Properties:
      CodeUri: hello-world/
      Handler: app.lambdaHandler
      Runtime: nodejs12.x
      Events:
        HelloWorld:
          Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
          Properties:
            Path: /hello
            Method: get

Outputs:
  # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
  # Find out about other implicit resources you can reference within AWS SAM at
  # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
  HelloWorldApi:
    Description: "API Gateway endpoint URL for the Hello World function"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
  HelloWorldFunction:
    Description: "Hello World Lambda function ARN"
    Value: !GetAtt HelloWorldFunction.Arn
  HelloWorldFunctionIamRole:
    Description: "Implicit Lambda execution role created for the Hello World function"
    Value: !GetAtt HelloWorldFunctionRole.Arn

选择 “提交”，然后再次选择 “提交”。

现在，您已在存储库的根文件夹sam-template.yml下添加了一个名为的文件。

在存储库中的 “文件” 中，选择 “创建文件”。

在 “文件名” 栏中输入：

setup-sam.sh

在文本框中，输入以下代码：

#!/usr/bin/env bash
echo "Setting up sam"

yum install unzip -y

curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory

./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2

在前面的代码中，替换 us-west-2 与您所在 AWS 的地区。

选择 “提交”，然后再次选择 “提交”。

现在，您已在存储库的根目录中setup-sam.sh添加了一个名为的文件。

在存储库中的 “文件” 中，选择 “创建文件”。

在 “文件名” 栏中输入：

hello-world/app.js

在文本框中，输入以下代码：

// const axios = require('axios')
// const url = 'http://checkip.amazonaws.com/';
let response;

/**
 *
 * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
 * @param {Object} event - API Gateway Lambda Proxy Input Format
 *
 * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
 * @param {Object} context
 *
 * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
 * @returns {Object} object - API Gateway Lambda Proxy Output Format
 * 
 */
exports.lambdaHandler = async (event, context) => {
    try {
        // const ret = await axios(url);
        response = {
            'statusCode': 200,
            'body': JSON.stringify({
                message: 'hello world',
                // location: ret.data.trim()
            })
        }
    } catch (err) {
        console.log(err);
        return err;
    }

    return response
};

选择 “提交”，然后再次选择 “提交”。

现在，您已经创建了一个名为的文件夹hello-world和一个名为的文件app.js。

在存储库中的 “文件” 中，选择 “创建文件”。

在 “文件名” 栏中输入：

hello-world/tests/unit/test-handler.js

在文本框中，输入以下代码：

'use strict';

const app = require('../../app.js');
const chai = require('chai');
const expect = chai.expect;
var event, context;

describe('Tests index', function () {
    it('verifies successful response', async () => {
        const result = await app.lambdaHandler(event, context)

        expect(result).to.be.an('object');
        expect(result.statusCode).to.equal(200);
        expect(result.body).to.be.an('string');

        let response = JSON.parse(result.body);

        expect(response).to.be.an('object');
        expect(response.message).to.be.equal("hello world");
        // expect(response.location).to.be.an("string");
    });
});

选择 “提交”，然后再次选择 “提交”。

现在，您已在该hello-world/tests/unit文件夹test-handler.js下添加了一个名为的文件。

在导航窗格中，选择 C I/CD，然后选择工作流程。

选择 “创建工作流程”。

对于源存储库，选择codecatalyst-cfn-source-repository。

对于 Branch，选择main。

选择创建。

删除YAML示例代码。

添加以下YAML代码：

Name: codecatalyst-cfn-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main   
Actions:
  Test:
    Identifier: aws/managed-test@v1
    Inputs:
      Sources:
        - WorkflowSource
    Outputs:
      Reports:
        CoverageReport:
          Format: CLOVERXML
          IncludePaths:
            - "coverage/*"
        TestReport:
          Format: JUNITXML
          IncludePaths:
            - junit.xml
    Configuration:
      Steps:
        - Run: npm install
        - Run: npm run test  
  BuildBackend:
    Identifier: aws/build@v1
    DependsOn:
      - Test
    Environment:
      Name: codecatalyst-cfn-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-build-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration: 
      Steps:
        - Run: . ./setup-sam.sh
        - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
    Outputs:
      Artifacts:
        - Name: buildArtifact
          Files:
            - "**/*"
  DeployCloudFormationStack:
    Identifier: aws/cfn-deploy@v1
    DependsOn: 
      - BuildBackend
    Environment:
      Name: codecatalyst-cfn-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-deploy-role
    Inputs:
      Artifacts:
        - buildArtifact
      Sources: []
    Configuration:
      name: codecatalyst-cfn-stack
      region: us-west-2
      role-arn: arn:aws:iam::111122223333:role/StackRole
      template: ./sam-template-packaged.yml
      capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND

在前面的代码中，替换：

有关前面显示的代码中属性的信息，请参阅“部署 AWS CloudFormation 堆栈” 操作 YAML。

（可选）选择验证以确保YAML代码在提交之前有效。

选择 Commit (提交)。

在 “提交工作流程” 对话框中，输入以下内容：

1. 对于工作流程文件名，保留默认值codecatalyst-cfn-workflow。

2. 在 “提交消息” 中，输入：

   add initial workflow file

3. 对于 “存储库”，选择codecatalyst-cfn-source-repository。

4. 对于分支名称，选择主分支。

5. 选择 Commit (提交)。

现在，您已经创建了一个工作流程。由于在工作流程顶部定义了触发器，因此工作流程运行会自动启动。具体而言，当您将codecatalyst-cfn-workflow.yaml文件提交（并推送）到源存储库时，触发器会启动工作流程运行。

在导航窗格中，选择 C I/CD，然后选择工作流程。

选择您刚刚创建的工作流程:codecatalyst-cfn-workflow.

选择 “运行” 选项卡。

在 “运行 ID” 列中，选择运行 ID。

选择 “测试” 以查看测试进度。

选择BuildBackend查看构建进度。

选择DeployCloudFormationStack查看部署进度。

有关查看运行详细信息的更多信息，请参阅查看工作流程运行状态和详细信息。

DeployCloudFormationStack操作完成后，请执行以下操作：

成功部署后，从靠近顶部的水平菜单栏中选择变量 (7)。（请勿在右侧窗格中选择变量。）

旁边 HelloWorldApi，将其粘贴https://URL到浏览器中。

将显示来自 Lambda 函数的 hello wor ld JSON 消息，表示工作流程已成功部署和配置 Lambda 函数和网关。API

在工作流程图中，选择 “测试”，然后选择 “报告”。

选择TestReport查看单元测试结果，或者选择CoverageReport查看正在测试的文件的代码覆盖率详细信息，在本例中为app.js和test-handler.js。

登录 AWS Management Console 并打开API网关控制台，网址为https://console.aws.amazon.com/apigateway/。

观察codecatalyst-cfn-stackAPI AWS SAM 模板创建的。该API名称来自工作流程定义文件中的Configuration/name值 (codecatalyst-cfn-workflow.yaml)。

打开 AWS Lambda 控制台，网址为https://console.aws.amazon.com/lambda/。

在导航窗格中，选择函数。

选择您的 Lambda 函数，。codecatalyst-cfn-stack-HelloWorldFunction-string

你可以看到 API Gateway 是如何触发该函数的。此集成是根据 AWS SAM AWS::Serverless::Function资源类型自动配置的。

在中 CodeCatalyst，导航到您的项目。

在导航窗格中，选择代码，然后选择源存储库。

选择您的源存储库codecatalyst-cfn-source-repository。

更改应用程序文件：

1. 选择 hello-world 文件夹。

2. 选择 app.js 文件。

3. 选择编辑。

4. 在第 23 行，改hello world为Tutorial complete!。

5. 选择 “提交”，然后再次选择 “提交”。

   提交会导致工作流程运行启动。此次运行将失败，因为您尚未更新单元测试以反映名称的更改。

更新单元测试：

1. 选择hello-world\tests\unit\test-handler.js。

2. 选择编辑。

3. 在第 19 行，更改hello world为Tutorial complete!。

4. 选择 “提交”，然后再次选择 “提交”。

   提交会导致另一个工作流程开始运行。这次运行将成功。

在导航窗格中，选择 C I/CD，然后选择工作流程。

选择codecatalyst-cfn-workflow，然后选择 “运行”。

选择最近一次运行的运行 ID。它应该仍在进行中。

选择 “测试” BuildBackend、“和” DeployCloudFormationStack以查看工作流程的运行进度。

工作流程完成后，选择顶部附近的变量 (7)。

旁边 HelloWorldApi，将其粘贴https://URL到浏览器中。

浏览器中会显示一条Tutorial complete!消息，表明您的新应用程序已成功部署。

打开 CodeCatalyst 控制台，网址为 https://codecatalyst.aws/。

删除codecatalyst-cfn-workflow。

删除codecatalyst-cfn-environment。

删除codecatalyst-cfn-source-repository。

删除codecatalyst-cfn-project。

清理一下 CloudFormation，如下所示：

1. 打开 AWS CloudFormation 控制台，网址为 https://console.aws.amazon.com/cloudformation。

2. 删除codecatalyst-cfn-stack。

   删除堆栈会从 Gate API way 和 Lambda 服务中移除所有教程资源。

在 Amazon S3 中进行清理，如下所示：

1. 打开 Amazon S3 控制台，网址为https://console.aws.amazon.com/s3/。

2. 选择 codecatalyst-cfn-s3-bucket。

3. 删除存储桶中的内容。

4. 删除存储桶。

清理一下IAM，如下所示：

1. 从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

2. 删除codecatalyst-deploy-policy。

3. 删除codecatalyst-build-policy。

4. 删除codecatalyst-stack-policy。

5. 删除codecatalyst-deploy-role。

6. 删除codecatalyst-build-role。

7. 删除codecatalyst-stack-role。