1. 简介
AWS App2Container (A2C) 是一个命令行工具，可以帮助您转移在本地数据中心或虚拟机上运行的应用程序，以便它们在由 Amazon ECS 或 Amazon EKS 管理的容器中运行。
但是，对现有应用程序进行容器化需要执行一长串手动任务，例如识别应用程序依赖项、编写 dockerfiles 以及为每个应用程序设置构建和部署过程。这些手动任务很耗时，容易出错，并且可能减慢现代化工作的速度。
App2Container 可以直接在运行应用程序的服务器上使用，或者在工作机器上执行容器化和部署步骤。
可以使用 App2Container 容器化以下应用程序：
- 在 Windows 上的 IIS 7.5+ 中运行的 ASP.NET (.NET 3.5+) Web 应用程序
- 在 Linux 上运行的 Java 应用程序（独立的 JBoss、Apache Tomcat 和常规 Java 应用程序，例如 Spring Boot、IBM WebSphere、Oracle WebLogic 等）。
1.1 A2C 工作原理
App2Container 执行以下任务:
- 为应用服务器创建一份清单，列出服务器上所有正在运行的，可以被容器化的应用程序（ ASP.NET in windows、Java in Linux）；
- 分析正在运行的，可被容器化应用程序的运行时依赖关系，包括协作进程和网络端口依赖关系；
- 提取用于的容器化的应用程序构件，并且生成一个 Dockerfile；
- 初始化应用程序容器的构建；
- 生成在 Amazon ECS 或 Amazon EKS 上部署容器所需的 AWS 构件。例如：
- 一个 CloudFormation 模板，用于配置所需的计算、网络和安全基础设施，以便使用 Amazon ECS 或 Amazon EKS 部署容器。
- 一个 Amazon ECR 容器镜像、Amazon ECS 任务定义和一个 Kubernetes 部署所需的 yaml 资源清单，该yaml 通过与各种 AWS 服务集成，实现了应用程序的安全性和可伸缩性的最佳实践。
- 用于在 AWS Codepipeline 中设置构建和发布容器的模板，AWS Codepipeline 也利用 AWS CodeBuild 和 CodeDeploy。
1.2 通过 A2C 访问AWS
初始化 App2Container 时，向它提供 AWS 凭据。这允许 App2Container 在 Amazon S3 中存储构件(如果配置它的话)，并允许使用 AWS 服务 (如 Amazon ECS 和 Amazon EKS ) 创建和部署应用程序容器。
1.3 定价
App2Container 免费使用。只有当使用其他 AWS 服务来运行容器化应用程序 (如 Amazon ECR、Amazon ECS 和 Amazon EKS) 时才需要付费。
2. 使用前设置
2.1 授权给 IAM 用户
App2Container 需要访问 AWS 服务才能运行它的大多数命令。运行 app2container 命令需要两组完全不同的权限。
- 通用权限用户组：可以运行除了 Deploy 之外的所有命令；
- 部署权限用户组：对于部署，App2Container 必须能够为容器管理服务 (带有 Amazon ECS 或 Amazon EKS 的 Amazon ECR ) 创建或更新 AWS 对象，并创建带有 AWS CodeStar 服务的管道。
:::info 建议创建通用的 IAM 资源，如果计划使用 App2Container 来部署容器或创建 pipeline，那么您需要为部署创建独立的 IAM 资源。 :::
2.2 选择在哪里进行容器化
要使用 A2C，需要提前在应用程序运行的服务器上配置 AWS profile、安装 App2Container 命令行工具、安装 Docker。
如果运行应用的服务器不能安装这些，或者没有外网环境，那么建议使用针对 Amazon ECS 优化的 AMI 启动一个 EC2 实例作为工作机，作为专用服务器来运行容器化和部署过程。
它必须具有与应用程序服务器相同的基本操作系统，且操作系统必须支持容器。
2.3 配置 AWS profile
因为 App2Container 需要访问 AWS 资源来实现容器化和部署，它使用 AWS profile 的数据来控制用户对 AWS 的访问。
需要在工作机上安装 ACL，使用 ACL 容器化应用程序，并且推荐使用 ACL 生成 pipeline 来执行部署。
2.4 安装 Docker
省略。
3. 在 Linux 上容器化一个 Java 应用示例
本教程将带您完成使用 App2Container 在 Linux 上封装现有 Java 应用程序的步骤，并将其部署到 Amazon ECS 或 Amazon EKS 上。您可以在应用服务器上完成所有步骤，也可以在应用服务器上执行初始步骤，并在工作机器上执行容器化和部署步骤。
3.1 Prerequisites
您对应用程序服务器以及工作机器 (如果使用的话) 有根访问权。
应用程序服务器 (以及工作机器，如果使用的话) 有 tar 和 20gb 的空闲空间。
3.2 Step 1: Install App2Container
App2Container for Linux 被打包成了一个 tar.gz 文档。文档中包含一个交互式的 shell 脚本，它可以帮助在你的服务器上安装 App2Container。
3.2.1 下载并安装 App2Container for Linux
下载安装文件有两种方式，任选其一：
使用 curl 命令从 S3 下载安装包：
$ curl -o AWSApp2Container-installer-linux.tar.gz https://app2container-release-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/AWSApp2Container-installer-linux.tar.gz
使用浏览器下载：URL: https://app2container-release-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/AWSApp2Container-installer-linux.tar.gz。
解压包
$ sudo tar xvf AWSApp2Container-installer-linux.tar.gz
运行脚本
$ sudo ./install.sh
3.2.2 校验下载包
在下载 tar.gz 文件的所在目录中，运行以下命令以生成下载的 tar.gz 文件的散列值。 ```shell $ md5sum AWSApp2Container-installer-linux.tar.gz a0a1234f567bf89012345a6ce7bf89a0 AWSAppContainerization-installer-linux.tar.gz
$sha256sum AWSApp2Container-installer-linux.tar.gz 01bc2d345f6789012345bd6aa789012345d67dea8b9c0f1234ee5a67890123d4 AWSAppContainerization-installer-linux.tar.gz
使用以下链接从 Amazon S3 下载 App2Container 散列文件，并将其内容与您在步骤1中生成的散列进行比较:- [AWSApp2Container-installer-linux.tar.gz.md5](https://app2container-release-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/AWSApp2Container-installer-linux.tar.gz.md5).- [AWSApp2Container-installer-linux.tar.gz.sha256](https://app2container-release-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/AWSApp2Container-installer-linux.tar.gz.sha256).<a name="r9m3U"></a>## 3.3 Step 2: Initialize App2Container运行 `init` 命令：```shell$ sudo app2container init
系统会提示您提供以下信息，输入 <enter> 来选择接受默认值。
- Workspace directory path：一个本地目录，App2Container 可以在容器化过程中存储构件。默认值是
/root/app2container。 - AWS profile：包含运行 App2Container 所需的信息，比如 AWS 访问密钥。默认是 default profile。
- Amazon S3 bucket：（非必须项）提供一个 S3 存储桶名称，用于将容器化过程生成的构建上传到 S3 存储桶，访问 S3 需要 AWS profile 的配置信息。默认是不使用 S3 存储桶。
- Permission to collect usage metrics：（非必须项）可以选择允许 App2Container 收集关于主机操作系统、应用程序类型和您运行的 App2Container 命令的信息。默认情况下允许收集指标。
- Whether to enforce signed images：（非必须项）可以选择要求使用 Docker Content Trust (DCT) 对容器镜像文件进行签名。默认值是 no。
3.4 Step 3: Analyze your application
在应用运行的服务器上，执行以下流程来为容器化应用程序做准备。
准备容器化：
运行
inventory命令列出服务器上所有运行的 Java 进程：$ sudo app2container inventory
输出结果是一个 JSON 对象集合，每个 Java 应用是一个对象，对象信息如下：
"java-app-id": {"processId": pid,"cmdline": "/user/bin/java ...","applicationType": "java-apptype"}
在输出的 JSON 集合中，找到要容器化的应用程序 ID，执行
analyze命令为应用程序生成分析报告（替换java-app-id）：$ sudo app2container analyze --application-id java-app-id
analyze命令输出的是一个 JSON 文件analysis.json，保存在 init 命令中指定的工作目录 Workspace directory path。（可选）可以使用应用程序分析生成的
analysis.json模板，收集已分析应用程序的相关信息，以帮助你从analysisInfo部分识别所有系统依赖项，并更新容器化参数，以使用containerParameters部分来自定义为应用程序生成的容器映像。$ cat java-tomcat-9e8e4799/analysis.json{"a2CTemplateVersion": "1.0","createdTime": "2020-06-24 07:40:5424","containerParameters": {"_comment1": "*** EDITABLE: The below section can be edited according to the application requirements.Please see the analyisInfo section below for deetails discoverd regarding the application. ***","imageRepository": "java-tomcat-9e8e4799","imageTag": "latest","containerBaseImage": "ubuntu:18.04","coopProcesses": [ 6446, 6549, 6646]},"analysisInfo": {"_comment2": "*** NON-EDITABLE: Analysis Results ***","processId": 2537,"appId": "java-tomcat-9e8e4799","userId": "1000","groupId": "1000","cmdline": [...],"os": {...},"ports": [...]}}
3.5 Step 4: Transform your application
容器化阶段取决于你是在应用服务器上执行所有步骤，还是仅仅在应用服务器执行 analysis ，然后在工作机上进行容器化和部署的步骤。
在应用服务器上对应用进行容器化：
如果要在应用服务器上执行所有的容器化流程，执行 containerize 命令。
$ sudo app2container containerize --application-id java-app-id
输出结果是一些部署所需的文件，保存在 init 命令指定的工作目录中。
在工作机上对应用进行容器化：
如果你仅在应用服务器上执行 analysis ，在工作机上执行容器化和部署，那么那下面流程来转化应用。
在应用服务器上，执行
extract命令生成构件，这步依赖于工作目录中的analysis.json模板：$ sudo app2container extract --application-id java-app-id
如果在运行
init命令时指定了 S3 存储桶，extract命令对应用所提取的构件会被上传到 S3 存储桶。否则需要手动拷贝extract生成的构件到工作机中。在工作机上执行
containerize命令：$ sudo app2container containerize --input-archive /path/extraction-file.tar
输出结果是一些部署所需的构件，保存在
init命令指定的工作目录中。- 应用的容器镜像
Image，可以使用docker run启动容器并测试应用功能； deployment.json模板文件，可以编辑参数，以更改要在 Amazon ECR 中注册的镜像仓库名称、ECS 任务定义参数或 Kubernetes 应用程序名称。$ cat java-tomcat-9e8e4799/deployment.json{"a2CTemplateVersion": "1.0","applicationId": "java-tomcat-9e8e4799","imageName": "java-tomcat-9e8e4799","exposedPorts": [{"localPort": 8090,"protocol": "tcp6"}],"environment": [],"ecrParameters": {"ecrRepoTag": "latest"},"ecsParameters": {"createEcsArtifacts": true,"ecsFamily": "java-tomcat-9e8e4799","cpu": 2,"memory": 4096,"dockerSecurityOption": "","enableCloudwatchLogging": false,"publicApp": true,"stackName": "a2c-java-tomcat-9e8e4799-ECS","reuseResources": {"vpcId": "","cfnStackName": "","sshKeyPairName": ""},"gMSAParameters": {"domainSecretsArn": "","domainDNSName": "","domainNetBIOSName": "","createGMSA": false,"gMSAName": ""}},"eksParameters": {"createEksArtifacts": false,"applicationName": "","stackName": "a2c-java-tomcat-9e8e4799-EKS","reuseResources": {"vpcId": "","cfnStackName": "","sshKeyPairName": ""}}}
- 应用的容器镜像
3.6 Step 5: Deploy your application
检查上一步中生成的部署构件，可以根据需要修改 deployment.json 模板文件一些信息。
你可以选择编辑上一步生成的
Dockerfile来更改应用程序，并根据需要执行docker build命令构建新的应用 Image。运行
generate app-deployment命令generate app-deployment命令生成在 Amazon EKS 中部署应用程序容器所需的构件- 此命令基于在运行
containerize命令过程中生成的 deployment.json 模板文件工作。App2Container 现在还将生成 ECS/EKS cloudformation 模板，并提供部署这些堆栈的选项。 - 该命令会将容器 Image 上传到用户指定的 ECR 镜像仓库，为 Amazon ECS 和 EKS 部署生成 cloudformation 模板。
- 您可以在 Amazon ECS 上注册 ECS 任务定义，并使用 kubectl 通过 App2Container 生成的 amazon-eks-master.template.deployment.yaml 在现有 Amazon EKS 或自行管理的 kubernetes 集群上启动容器化应用程序。 ```shell $ sudo app2container generate app-deployment —application-id java-tomcat-9e8e4799 AWS pre-requisite check succeeded Docker pre-requisite check succeeded Created ECR Repository Uploaded Cloud Formation resources to S3 Bucket: none Generated Cloud Formation Master template at: /home/ubuntu/app2container/ws/java-tomcat-9e8e4799/EksDeployment/amazon-eks-master.template.yaml EKS Cloudformation templates and additional deployment artifacts generated successfully for application java-tomcat-9e8e4799
- 此命令基于在运行
You’re all set to use AWS Cloudformation to manage your application stack. Next Steps: 1.Edit the cloudformation template as necessary. 2.Create an application stack using the AWS CLI or the AWS Console.AWS CLI command:
aws cloudformation deploy --template-file /home/ubuntu/app2container/ws/java-tomcat-9e8e4799/EksDeployment/amazon-eks-master.template.yaml --capabilities CAPABILITY_NAMED_IAM --stack-name java-tomcat-9e8e4799
3.Setup a pipeline for your application stack:
app2container generate pipeline --application-id java-tomcat-9e8e4799
- 也可通过 `generate app-deployment --deploy` 直接将容器化的应用程序部署到 Amazon EKS 中
```shell
$ sudo app2container generate app-deployment --application-id java-tomcat-9e8e4799 --deploy
AWS pre-requisite check succeeded
Docker pre-requisite check succeeded
Created ECR Repository
Uploaded Cloud Formation resources to S3 Bucket: none
Generated Cloud Formation Master template at: /home/ubuntu/app2container/ws/java-tomcat-9e8e4799/EksDeployment/amazon-eks-master.template.yaml
Initiated Cloudformation stack creation.This may take a few minutes.Please visit the AWS Cloudformation Console to track progress.
Deploying application to EKS
3.7 Step 6: Clean up
要从应用服务器或工作机中删除 App2Container，需要删除安装目录 /usr/local/app2container ，并且将 path 中的安装路径也移除掉。
4. 容器配置文件 analysis.json 解析
当执行 analyze 命令，会生成应用程序分析报告 analysis.json， containerize 命令使用此文件构建应用的 Image，并生成构件。
你可以通过配置文件中 containerParameters 片段中的字段，来自定义你的应用容器 Image。自定义容器 Image 时，对于用不到的字段，字符串设置为空，数值设置为 0，布尔值设置为 false。
以下为 Java 应用的 analysis.json 文件详细内容：
- 只读数据：
Control fields：与文件创建有关的字段，例如模板的版本和创建时间；analysisInfo：描述应用程序的系统依赖项；
- 可配置数据（包含在
**containerParameters**片段中）：imageRepository（镜像仓库，必需项）：应用程序 Image 所保存的仓库名称；imageTag（镜像标签，必需项）：应用程序 Image 的 Tag；containerBaseImage（基础镜像，必需项）：构建应用程序 Image 所用到的基础镜像 Image，通常是一个基础操作系统镜像，如 ubuntu:18.04；appExcludedFiles（可选项，字符串数组）：指定要在容器构建中排除的文件和目录；appSpecificFiles（可选项，字符串数组）：指定容器构建中要包含的文件和目录；applicationMode（必需项，布尔值）：切换到生成容器镜像的优化模式 (仅支持独立的 Java JBoss 和 Java Tomcat 应用程序)。logLocations（可选项，字符串数组）：指定需要输出到 stdout 的日志文件或日志目录，这可以让应用程序之前在应用服务器中产生的日志文件也能集成到 AWS 服务，例如 CloudWatch、Kinesis Data FireHore；enableDynamicLogging（必需项，布尔值）：在应用程序创建时，将日志输出到 stdout。假如 true，要求在logLocations中配置日志目录；dependencies（可选项，字符串数组）：通过analyze命令为应用程序分析出的所有依赖进程或依赖应用列表。你可以在这里移除某些依赖关系来将它们排除在应用容器镜像之外；
文件内容示例：
{
"a2CTemplateVersion": "",
"createdTime": "",
"containerParameters": {
"_comment1": "*** EDITABLE: The below section can be edited according to the application requirements. Please see the analysisInfo section below for details discovered regarding the application. ***",
"imageRepository": "java-tomcat-6e6f3a87",
"imageTag": "latest",
"containerBaseImage": "ubuntu:18.04",
"appExcludedFiles": [],
"appSpecificFiles": [],
"applicationMode": true,
"logLocations": [],
"enableDynamicLogging": false,
"dependencies": []
},
"analysisInfo": {
"_comment2": "*** NON-EDITABLE: Analysis Results ***",
"processId": 2065,
"appId": "java-tomcat-6e6f3a87",
"userId": "1000",
"groupId": "1000",
"cmdline": [
"/usr/bin/java",
"... list of commands",
"start"
],
"osData": {
"BUG_REPORT_URL": "",
"HOME_URL": "",
"ID": "ubuntu",
"ID_LIKE": "debian",
"NAME": "Ubuntu",
"PRETTY_NAME": "Ubuntu 18.04.2 LTS",
"PRIVACY_POLICY_URL": "",
"SUPPORT_URL": "",
"UBUNTU_CODENAME": "",
"VERSION": "",
"VERSION_CODENAME": "",
"VERSION_ID": "18.04"
},
"osName": "ubuntu",
"ports": [
{
"localPort": 8080,
"protocol": "tcp6"
},
{
"localPort": 8009,
"protocol": "tcp6"
},
{
"localPort": 8005,
"protocol": "tcp6"
}
],
"Properties": {
"catalina.base": "<application directory>",
"catalina.home": "<application directory>",
"classpath": "<application directory>/bin/bootstrap.jar:... etc.",
"ignore.endorsed.dirs": "",
"java.io.tmpdir": "<application directory>/temp",
"java.protocol.handler.pkgs": "org.apache.catalina.webresources",
"java.util.logging.config.file": "<application directory>/conf/logging.properties",
"java.util.logging.manager": "org.apache.juli.ClassLoaderLogManager",
"jdk.tls.ephemeralDHKeySize": "2048",
"jdkVersion": "11.0.7",
"org.apache.catalina.security.SecurityListener.UMASK": ""
},
"AdvancedAppInfo": {
"Directories": {
"base": "<application directory>",
"bin": "<application directory>/bin",
"conf": "<application directory>/conf",
"home": "<application directory>",
"lib": "<application directory>/lib",
"logConfig": "<application directory>/conf/logging.properties",
"logs": "<application directory>/logs",
"tempDir": "<application directory>/temp",
"webapps": "<application directory>/webapps",
"work": "<application directory>/work"
},
"distro": "java-tomee",
"flavor": "plume",
"jdkVersion": "11.0.7",
"version": "8.0.0"
},
"env": {
"HOME": "... Java Home directory",
"JDK_JAVA_OPTIONS": "",
"LANG": "C.UTF-8",
"LC_TERMINAL": "iTerm2",
"LC_TERMINAL_VERSION": "3.3.11",
"LESSCLOSE": "/usr/bin/lesspipe %s %s",
"LESSOPEN": "| /usr/bin/lesspipe %s",
"LOGNAME": "ubuntu",
"LS_COLORS": "",
"MAIL": "",
"OLDPWD": "",
"PATH": "... server PATH",
"PWD": "",
"SHELL": "/bin/bash",
"SHLVL": "1",
"SSH_CLIENT": "",
"SSH_CONNECTION": "",
"SSH_TTY": "",
"TERM": "",
"USER": "ubuntu",
"XDG_DATA_DIRS": "",
"XDG_RUNTIME_DIR": "",
"XDG_SESSION_ID": "1",
"_": "bin/startup.sh"
},
"cwd": "",
"procUID": {
"euid": "1000",
"suid": "1000",
"fsuid": "1000",
"ruid": "1000"
},
"procGID": {
"egid": "1000",
"sgid": "1000",
"fsgid": "1000",
"rgid": "1000"
},
"userNames": {
"1000": "ubuntu"
},
"groupNames": {
"1000": "ubuntu"
},
"fileDescriptors": [
"<application directory>/logs/... log files",
"<application directory>/lib/... jar files",
"... etc.",
"/usr/lib/jvm/.../lib/modules"
],
"dependencies": {}
}
}
5. 容器部署文件 deployment.json 解析
当执行 containerize 命令时，会生成一个 deployment.json 文件。
generate app-deployment 命令使用这个 deployment 文件，以及其他文件来生成应用程序的部署构件。
这个文件中的所有字段都是可进行修改配置的，以便定制自己的部署模板。
:::info deployment.json 文件包含 Amazon ECS 和 Amazon EKS 两部分，在部署的前，你只能选择其中一种容器管理服务，将其设置为 true，另一种设置为 false。部署到 Amazon ECS 的标志是 createEcsArtifacts，部署到 Amazon EKS 的标志是 createEksArtifacts。 :::
虽然 deployment.json 中所有字段都可修改，但是以下字段不应修改：a2CTemplateVersion、applicationId、imageName。对于用不到的字段，字符串设置为空，数值设置为 0，布尔值设置为 false。
以下是文件详细内容：
exposedPorts（必需的对象数组）：一个JSON对象数组，表示在容器运行时应该公开的端口。每个对象由以下字段组成：localPort(number)：为容器通信公开的端口；protocol(string)：用于公开端口的应用协议。例如 http；
environment(对象数组)：传递给目标容器管理服务的环境变量。对于 Amazon ECS 部署，键/值对会更新到 ECS 的任务定义；对于 Amazon EKS 部署，键/值对会更新到 Kubernetes 的 deployment.yaml 资源清单文件；ecrParameters(对象)：包含在 Amazon ECR 中注册应用程序容器 Image 所需的参数。ecrRepoTag(字符串，必需)：用于在 Amazon ECR 中注册应用程序容器 Image 的版本 Tag。
ecsParameters(对象)：包含部署到 Amazon ECS 所需的参数。createEcsArtifacts 参数始终是必需的。本节中标记为必需的其他参数仅适用于 ECS 部署。createEcsArtifacts(布尔值，必需)：指示是否要部署 Amazon ECS 的标志；ecsFamily(字符串，必需)：在 ECS 任务定义中用于 ECS family 的 ID。我们建议将该值设置为应用程序 ID。cpu(必需的数字或字符串)：为 Task 配置的 cpu 单元的硬限制。在 ECS 任务定义中，它可以表示为一个整数，使用 CPU 单位，例如1024，或者使用 vCPUs 表示为一个字符串，例如 “1 vCPU” 或 “1 vcpu”。当注册任务定义时，vCPU 值被转换为表示 CPU 单元的整数。memory(必需的数字或字符串)：为 Task 配置的内存硬限制（MiB）。在 ECS 任务定义中，它可以表示为整数，使用 MiB，例如1024，或者表示为字符串，使用 GB，例如 “1GB”。当注册任务定义时，GB 值将转换为表示 MiB 的整数。dockerSecurityOption(字符串)：对于 .NET 应用程序，这是 ECS 任务定义的 gMSA Credspec location 值。enableCloudwatchLogging(布尔值，required*)：设置 ECS 任务定义来为您的 Windows 应用程序容器启用 CloudWatch 日志记录的标志。如果设置为真，则 analysis.json 的 enableDynamicLogging 字段必须有一个有效值。publicApp(Boolean, required)：当您的应用程序运行时，使用公共端点配置 CloudFormation 模板的标志。stackName(字符串，必需的)：用作 CloudFormation 堆栈应用程序资源名(arn)的前缀的名称。我们建议为此使用应用程序 ID。reuseResources(对象)：包含可在整个 CloudFormation 模板中使用的共享资源标识符。vpcId(字符串)：VPC ID，如果您想携带自己的 VPC，或者复用 App2Container 为之前的部署创建的现有 VPC。cfnStackName(字符串)：使用 App2Container 为容器化的应用程序创建的 CloudFormation 堆栈的名称或 ID (arn)。sshKeyPairName(字符串)：用于运行容器的实例的 Amazon EC2 密钥对的名称。
deployTarget(字符串，required)：标识哪一种 ECS 容器启动类型运行任务或 CloudFormation 模板。有效值是“EC2”和“FARGATE”。
fireLensParameters(对象)：包含使用 FireLens 为 Amazon ECS 任务路由应用程序日志所需的参数。enableFireLensLogging 参数始终是必需的。本节中标记为必需的其他参数仅适用于 FireLens 用于日志路由。enableFireLensLogging(Boolean，required)：为 Amazon ECS 使用 FireLens 来配置容器的应用程序日志路由的标志。logDestinations(对象数组)：用于应用程序日志路由的唯一目标目的地列表。如果配置了多个目的地，App2Container 将创建一个包含 FireLens 配置的自定义文件。否则，目标参数将直接在 ECS 任务定义和 CloudFormation 模板中使用。service(字符串)：将日志导向的 AWS 服务。有效值是“cloudwatch”、“firehose”和“kinesis”。regexFilter(字符串)：一个 Ruby 正则表达式，用于匹配日志内容，以确定将日志路由到何处。streamName(字符串)：将日志传递到目的地创建的日志流的名称。
eksParameters(对象)：包含部署到 Amazon EKS 所需的参数。createEksArtifacts 参数始终是必需的。本节中标记为 required 的其他参数仅适用于 EKS 部署。createEksArtifacts(Boolean, required)：指示是否要部署 Amazon EKS 的标志。stackName(字符串，必需的)：用作 CloudFormation 堆栈应用程序资源名(arn)的前缀的名称。我们建议为此使用应用程序 ID。reuseResources(对象)：包含可在整个 CloudFormation 模板中使用的共享资源标识符。vpcId(字符串)：VPC ID，如果您想携带自己的 VPC，或者复用 App2Container 为之前的部署创建的现有 VPC。cfnStackName(字符串)：使用 App2Container 为容器化的应用程序创建的 CloudFormation 堆栈的名称或 ID (arn)。sshKeyPairName(字符串)：用于运行容器的实例的 Amazon EC2 密钥对的名称。
文件内容示例：
{
"a2CTemplateVersion": "3.1",
"applicationId": "java-tomcat-6e6f3a87",
"imageName": "java-tomcat-6e6f3a87",
"exposedPorts": [
{
"localPort": 8080,
"protocol": "tcp6"
},
{
"localPort": 8009,
"protocol": "tcp6"
},
{
"localPort": 8005,
"protocol": "tcp6"
}
],
"environment": [],
"ecrParameters": {
"ecrRepoTag": "latest"
},
"ecsParameters": {
"createEcsArtifacts": true,
"ecsFamily": "java-tomcat-6e6f3a87",
"cpu": 2,
"memory": 4096,
"dockerSecurityOption": "",
"enableCloudwatchLogging": false,
"publicApp": true,
"stackName": "app2container-java-tomcat-6e6f3a87-ECS",
"reuseResources": {
"vpcId": "",
"cfnStackName": "",
"sshKeyPairName": ""
},
"gMSAParameters": {
"domainSecretsArn": "",
"domainDNSName": "",
"domainNetBIOSName": "",
"createGMSA": false,
"gMSAName": ""
},
"deployTarget": "FARGATE"
},
"fireLensParameters": {
"enableFireLensLogging": true,
"logDestinations": [
{
"service": "cloudwatch",
"matchRegex": "^.*INFO.*$",
"streamName": "Info"
},
{
"service": "cloudwatch",
"matchRegex": "^.*WARN.*$",
"streamName": "Warn"
}
]
},
"eksParameters": {
"createEksArtifacts": false,
"applicationName": "",
"stackName": "java-tomcat-6e6f3a87",
"reuseResources": {
"vpcId": "",
"cfnStackName": "",
"sshKeyPairName": ""
}
}
}
6. 容器流水线 pipeline.json 解析
执行 generate app-deployment 命令，会为应用程序生成一个 pipeline.json 文件。
generate pipeline 命令使用这个 pipeline.json 文件，以及其他文件，会生成 pipeline 部署构件。
pipeline.json 中的所有字段都可以根据需要进行修改配置。但 a2CTemplateVersion 字段不建议修改。
对于用不到的字段，字符串设置为空，数值设置为 0，布尔值设置为 false。
以下是文件详细内容：
sourceInfo(object)：包含 AWS CodeStar 配置所需的 JSON 对象。CodeCommit(object)：包含 AWS CodeCommit 配置所需的参数。repositoryName(string, required)：代码托管仓库名称；branch(string, required)：代码提交的分支；
imageInfo(object)：包含 AWS ECR 配置所需的参数。image(string, required)：. : ；
releaseInfo(object)：包含带有参数的 JSON 对象，这些参数用于为目标部署环境创建管道。ECS | EKS(object)：包含 JSON 对象，表示要部署的环境。键名指定应用程序容器管道的目标容器管理服务。key 必须是“ECS”或“EKS”。必须启用至少一个管道环境。beta(object)：clusterName(string, required)：要在 CloudFormation 堆栈中设置的 ECS 或 EKS 集群的名称。serviceName(string，required)：要在 CloudFormation 堆栈中设置的 ECS 服务的名称。（只适用于 ECS 管道）enabled(Boolean, required)：指示是否应该配置 beta 环境的标志。
prod(object)clusterName(string, required)：要在 CloudFormation 堆栈中设置的 ECS 或 EKS 集群的名称。serviceName(string，required)：要在 CloudFormation 堆栈中设置的 ECS 服务的名称。（只适用于 ECS 管道）enabled(Boolean, required)：指示是否应该配置 pro 环境的标志。
下面的示例展示了一个运行在 Linux 上的 Java 应用程序的 pipeline.json 文件。可以在文件中看到的，该应用程序在 beta 环境中运行，而且还没有配置 prod 环境。
{
"a2CTemplateVersion": "3.1",
"sourceInfo": {
"CodeCommit": {
"repositoryName": "app2container-java-tomcat-6e6f3a87-ecs",
"branch": "master"
}
},
"releaseInfo": {
"ECS": {
"beta": {
"clusterName": "app2container-java-tomcat-6e6f3a87-ECS-Cluster",
"serviceName": "app2container-java-tomcat-6e6f3a87-ECS-LBWebAppStack-etc.",
"enabled": true
},
"prod": {
"clusterName": "",
"serviceName": "",
"enabled": false
}
}
}
}
若有收获，就点个赞吧
0 人点赞
