教程：部署无服务器应用程序 - Amazon CodeCatalyst
先决条件 步骤 1：创建源存储库步骤 2：创建 AWS 角色步骤 3：将 AWS 角色添加到 CodeCatalyst步骤 4：创建 Amazon S3 存储桶第 5 步：添加源文件步骤 6：创建并运行工作流程第 7 步：做出改变清理

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

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

在本教程中，您将学习如何使用工作流程构建、测试和部署无服务器应用程序作为 CloudFormation 堆栈。

本教程中的应用程序是一个简单的 Web 应用程序，可输出 “Hello World” 消息。它由一个 AWS Lambda 函数和一个 Amazon API Gateway 组成，您可以使用 AWS Serverless Application Model (AWS SAM) 来构建它，后者是的扩展AWS CloudFormation。

先决条件

开始前的准备工作：

  • 你需要一个带有关联 AWS 账户的 CodeCatalyst 空间。有关更多信息，请参阅 创建空间。

  • 在你的空间里，你需要一个名为：

    codecatalyst-cfn-project

    使用 “从头开始” 选项来创建此项目。

    有关更多信息，请参阅 在 Amazon 中创建一个空项目 CodeCatalyst。

  • 在你的项目中，你需要一个 CodeCatalyst 名为：

    codecatalyst-cfn-environment

    按如下方式配置此环境：

    • 选择任何类型，例如 “非生产”。

    • 将您的 AWS 账户与之关联。

    • 对于默认IAM角色，请选择任意角色。稍后您将指定其他角色。

    有关更多信息，请参阅 部署到 AWS 账户 和 VPCs。

步骤 1：创建源存储库

在此步骤中，您将在中创建源存储库 CodeCatalyst。此存储库用于存储教程的源文件，例如 Lambda 函数文件。

有关源存储库的更多信息，请参阅创建源存储库。

创建源存储库

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

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

  3. 在存储库名称中，输入：

    codecatalyst-cfn-source-repository

  4. 选择创建。

现在，您已经创建了一个名为的存储库codecatalyst-cfn-source-repository。

步骤 2：创建 AWS 角色

在此步骤中，您将创建以下 AWS IAM角色：

  • 部署角色-授予 CodeCatalyst Deploy AWS CloudFormation stack 操作访问您的 AWS 账户和 CloudFormation 服务的权限，您将在其中部署无服务器应用程序。部署 AWS CloudFormation 堆栈操作是您的工作流程的一部分。

  • 构建角色-授予 CodeCatalyst 构建操作权限以访问您的 AWS 账户并写入存储您的无服务器应用程序包的 Amazon S3。生成操作是您的工作流程的一部分。

  • 堆栈角色- CloudFormation 授予读取和修改您稍后将提供的 AWS SAM 模板中指定的资源的权限。还授予权限 CloudWatch。

有关IAM角色的更多信息，请参阅《AWS Identity and Access Management 用户指南》中的IAM角色。

注意

为了节省时间，您可以创建一个名为角色的CodeCatalystWorkflowDevelopmentRole-spaceName角色，而不是前面列出的三个角色。有关更多信息，请参阅 为您的账户和空间创建CodeCatalystWorkflowDevelopmentRole-spaceName角色。了解该CodeCatalystWorkflowDevelopmentRole-spaceName角色具有非常广泛的权限，可能会带来安全风险。我们建议您仅在教程和安全性较低的场景中使用此角色。本教程假设您正在创建前面列出的三个角色。

注意

还需要一个 Lambda 执行角色，但您无需立即创建它，因为当您在步骤 5 中运行工作流程时，sam-template.yml文件会为您创建它。

创建部署角色

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

    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. 选择 创建策略。

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

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

    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. 选择 创建角色。

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

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

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

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

    3. 从列表中选择角色。

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

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

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

创建生成角色

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

    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. 选择 创建策略。

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

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

    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. 选择 创建角色。

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

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

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

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

    3. 从列表中选择角色。

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

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

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

创建堆栈角色

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

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

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

    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. 选择 创建角色。

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

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

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

    3. 从列表中选择角色。

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

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

步骤 3：将 AWS 角色添加到 CodeCatalyst

在此步骤中，您将构建角色 (codecatalyst-build-role) 和部署角色 (codecatalyst-deploy-role) 添加到空间中的 CodeCatalyst 账户连接。

注意

您无需将堆栈角色 (codecatalyst-stack-role) 添加到连接中。这是因为在部署角色之间 CodeCatalyst 已经建立连接之后 CloudFormation（不是 CodeCatalyst） AWS 使用堆栈角色。由于堆栈角色不用于获取 CodeCatalyst 访问权限 AWS，因此无需将其与账户连接相关联。

向账户连接添加构建和部署角色

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

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

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

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

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

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

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

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

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

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

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

步骤 4：创建 Amazon S3 存储桶

在此步骤中，您将创建一个 Amazon S3 存储桶，用于存储无服务器应用程序的部署包.zip 文件。

创建 Amazon S3 存储桶

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

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

  3. 在存储桶名称中，输入：

    codecatalyst-cfn-s3-bucket

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

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

现在，您已经在美国西部（俄勒冈州）us-west-2 区域创建了一个名codecatalyst-cfn-s3-bucket为的存储桶。

第 5 步：添加源文件

在此步骤中，您将向源存储库中添加多个应用程序 CodeCatalyst 源文件。该hello-world文件夹包含您将部署的应用程序文件。该tests文件夹包含单元测试。文件夹结构如下所示：

.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh

.npmignore 文件

该.npmignore文件指示 npm 应从应用程序包中排除哪些文件和文件夹。在本教程中，npm 不包括该tests文件夹，因为它不是应用程序的一部分。

添加.npmignore 文件

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

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

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

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

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

  6. 在 “文件名” 栏中输入：

    .npmignore

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

    tests/*

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

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

打包.json 文件

该package.json文件包含有关您的 Node 项目的重要元数据，例如项目名称、版本号、描述、依赖关系以及描述如何与应用程序交互和运行应用程序的其他详细信息。

本教程package.json中的包括依赖项列表和test脚本。测试脚本执行以下操作：

  • 使用 mocha，测试脚本运行中指定的单元测试，hello-world/tests/unit/并使用 x unit 报告器将结果写入junit.xml文件。

  • 使用伊斯坦布尔 (nyc)，测试脚本使用三叶草报告器生成代码覆盖率报告 (clover.xml)。有关更多信息，请参阅伊斯坦布尔文档中的使用备用报告器。

添加 package.json 文件

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

  2. 在 “文件名” 栏中输入：

    package.json

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

    {
  "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"
  }
}

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

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

sam-template.yml 文件

该sam-template.yml文件包含部署 Lambda 函数和API网关以及一起配置它们的说明。它遵循AWS Serverless Application Model 模板规范，该规范扩展了 AWS CloudFormation 模板规范。

在本教程中，您将使用 AWS SAM 模板而不是常规 AWS CloudFormation 模板，因为 AWS SAM 提供了一种有用的:: Serverless AWS:: Function 资源类型。这种类型执行许多 behind-the-scenes 配置，你通常必须写出这些配置才能使用基本 CloudFormation 语法。例如，AWS::Serverless::Function创建了一个 Lambda 函数、Lambda 执行角色和启动该函数的事件源映射。如果你想用 basic 来编写，你必须对所有这些代码进行编码 CloudFormation。

尽管本教程使用预先编写的模板，但您可以使用构建操作生成一个模板作为工作流程的一部分。有关更多信息，请参阅 部署 AWS CloudFormation 堆栈。

添加 sam-template.yml 文件

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

  2. 在 “文件名” 栏中输入：

    sam-template.yml

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

    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

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

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

setup-sam.sh 文件

该setup-sam.sh文件包含下载和安装该 AWS SAM CLI实用程序的说明。工作流使用此实用程序打包hello-world源代码。

添加 setup-sam.sh 文件

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

  2. 在 “文件名” 栏中输入：

    setup-sam.sh

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

    #!/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 的地区。

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

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

app.js 文件

app.js包含 Lambda 函数代码。在本教程中，代码返回文本hello world。

添加 app.js 文件

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

  2. 在 “文件名” 栏中输入：

    hello-world/app.js

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

    // 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
};

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

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

test-handler.js 文件

该test-handler.js文件包含 Lambda 函数的单元测试。

添加 test-handler.js 文件

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

  2. 在 “文件名” 栏中输入：

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

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

    '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");
    });
});

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

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

现在，您已经添加了所有源文件。

花点时间仔细检查您的工作，并确保将所有文件放在正确的文件夹中。文件夹结构如下所示：

.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh

步骤 6：创建并运行工作流程

在此步骤中，您将创建一个工作流程，用于打包您的 Lambda 源代码并进行部署。该工作流由以下按顺序运行的构建块组成：

  • 触发器-当您将更改推送到源存储库时，此触发器会自动启动工作流程运行。有关触发器的更多信息，请参阅启动工作流程使用触发器自动运行。

  • 测试操作 (Test)-触发时，此操作将安装 N ode 包管理器 (npm)，然后运行该npm run test命令。此命令告诉 npm 运行package.json文件中定义的test脚本。该test脚本反过来运行单元测试并生成两个报告：测试报告 (junit.xml) 和代码覆盖率报告 (clover.xml)。有关更多信息，请参阅 打包.json 文件。

    接下来，测试操作将XML报告转换为 CodeCatalyst 报告，并将其显示在 CodeCatalyst 控制台中，位于测试操作的 “报告” 选项卡下。

    有关测试操作的更多信息，请参阅使用工作流程进行测试。

  • 构建操作 (BuildBackend)-测试操作完成后，构建操作将下载并安装，打包hello-world源代码 AWS SAM CLI，然后将包复制到您的 Amazon S3 存储桶（Lambda 服务期望的位置）。该操作还会输出一个名为的新 AWS SAM 模板文件，sam-template-packaged.yml并将其放置在名为的输出构件中buildArtifact。

    有关生成操作的更多信息，请参阅使用工作流程进行构建。

  • 部署操作 (DeployCloudFormationStack)-生成操作完成后，部署操作将查找生成操作 (buildArtifact) 生成的输出对象，在其中找到 AWS SAM 模板，然后运行该模板。该 AWS SAM 模板创建了一个用于部署无服务器应用程序的堆栈。

创建工作流

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

  2. 选择 “创建工作流程”。

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

  4. 对于 Branch，选择main。

  5. 选择创建。

  6. 删除YAML示例代码。

  7. 添加以下YAML代码：

    注意

    在下面的YAML代码中，如果你愿意，你可以省略这些Connections:部分。如果省略这些部分，则必须确保在您的环境中 “默认IAM角色” 字段中指定的角色包含中步骤 2：创建 AWS 角色描述的两个角色的权限和信任策略。有关使用默认IAM角色设置环境的更多信息，请参阅创建环境。

    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

    在前面的代码中，替换：

    • 的两个实例 codecatalyst-cfn-environment 使用您的环境名称。

    • 的两个实例 codecatalyst-account-connection 显示您的账户连接的显示名称。显示名称可能是一个数字。有关更多信息，请参阅 步骤 3：将 AWS 角色添加到 CodeCatalyst。

    • codecatalyst-build-role 使用您在中创建的构建角色的名称步骤 2：创建 AWS 角色。

    • codecatalyst-cfn-s3-bucket 使用您在中创建的 Amazon S3 存储桶的名称步骤 4：创建 Amazon S3 存储桶。

    • 的两个实例 us-west-2 包括您的 Amazon S3 存储桶所在的区域（第一个实例）和堆栈的部署区域（第二个实例）。这些区域可能有所不同。本教程假设两个区域都设置为us-west-2。有关 Amazon S3 和支持的区域的详细信息 AWS CloudFormation，请参阅中的服务终端节点和配额AWS 一般参考。

    • codecatalyst-deploy-role 使用您在中创建的部署角色的名称步骤 2：创建 AWS 角色。

    • codecatalyst-cfn-environment 使用您在中创建的环境的名称先决条件 。

    • arn:aws:iam::111122223333:role/StackRole 使用您在中创建的堆栈角色的 Amazon 资源名称 (ARN) 步骤 2：创建 AWS 角色。

      注意

      如果您决定不创建构建、部署和堆叠角色，请替换 codecatalyst-build-role, codecatalyst-deploy-role，以及 arn:aws:iam::111122223333:role/StackRole 使用CodeCatalystWorkflowDevelopmentRole-spaceName角色ARN的名称或名称。有关该角色的更多信息，请参阅 步骤 2：创建 AWS 角色。

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

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

  9. 选择 Commit (提交)。

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

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

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

      add initial workflow file

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

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

    5. 选择 Commit (提交)。

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

查看正在运行的工作流程

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

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

  3. 选择 “运行” 选项卡。

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

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

  6. 选择BuildBackend查看构建进度。

  7. 选择DeployCloudFormationStack查看部署进度。

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

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

    • 如果工作流程运行成功，请转到下一个过程。

    • 如果工作流程在测试或BuildBackend操作中运行失败，请选择日志来解决问题。

    • 如果DeployCloudFormationStack操作的工作流程运行失败，请选择部署操作，然后选择摘要选项卡。滚动至CloudFormation 事件部分以查看详细的错误消息。如果发生了回滚， AWS 请在重新运行工作流程之前通过 AWS CloudFormation 控制台删除codecatalyst-cfn-stack堆栈。

验证部署

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

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

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

    提示

    您可以通过一些小配置将其 CodeCatalyst 显示URL在工作流程图中。有关更多信息，请参阅 在工作流程图URL中显示应用程序。

验证单元测试结果和代码覆盖率

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

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

验证已部署的资源

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

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

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

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

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

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

第 7 步：做出改变

在此步骤中，您将对 Lambda 源代码进行更改并提交。此提交将启动新的工作流程运行。此次运行以蓝绿色方案部署新的 Lambda 函数，该方案使用 Lambda 控制台中指定的默认流量转移配置。

更改您的 Lambda 来源

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

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

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

  4. 更改应用程序文件：

    1. 选择 hello-world 文件夹。

    2. 选择 app.js 文件。

    3. 选择编辑。

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

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

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

  5. 更新单元测试：

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

    2. 选择编辑。

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

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

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

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

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

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

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

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

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

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

清理

清理本教程中使用的文件和服务，以免被收费。

在 CodeCatalyst 控制台中进行清理

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

  2. 删除codecatalyst-cfn-workflow。

  3. 删除codecatalyst-cfn-environment。

  4. 删除codecatalyst-cfn-source-repository。

  5. 删除codecatalyst-cfn-project。

要在里面清理干净 AWS Management Console

  1. 清理一下 CloudFormation，如下所示：

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

    2. 删除codecatalyst-cfn-stack。

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

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

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

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

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

    4. 删除存储桶。

  3. 清理一下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。

在本教程中，您学习了如何使用 CodeCatalyst 工作流程和部署 CloudFormation 堆栈操作将无服务器应用程序部署为 AWS CloudFormation 堆栈。