本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 操作结构参考
此部分仅为操作配置提供参考。有关管道结构的概念性介绍，请参阅 [CodePipeline 管道结构参考](reference-pipeline-structure.md)。
中的每个操作提供者在工作流结构中 CodePipeline 使用一组必填和可选的配置字段。本节按操作提供方提供了以下参考信息：
+ 管道结构操作块中包含的 `ActionType` 字段的有效值，如 `Owner` 和 `Provider`。
+ 管道结构操作部分中包含的 `Configuration` 参数（必需和可选）的描述和其他参考信息。
+ 有效的示例 JSON 和 YAML 操作字段。
此部分会定期进行更新，添加更多操作提供方。参考信息当前对下列操作提供方可用：
**Topics**
+ [Amazon EC2 操作参考](action-reference-EC2Deploy.md)
+ [Amazon ECR 源操作参考](action-reference-ECR.md)
+ [`ECRBuildAndPublish` 构建操作参考](action-reference-ECRBuildAndPublish.md)
+ [Amazon ECS 和 CodeDeploy 蓝绿色部署操作参考](action-reference-ECSbluegreen.md)
+ [Amazon Elastic Container Service 部署操作参考](action-reference-ECS.md)
+ [Amazon Elastic Kubernetes Service `EKS` 部署操作参考](action-reference-EKS.md)
+ [AWS Lambda 部署操作参考](action-reference-LambdaDeploy.md)
+ [Amazon S3 部署操作参考](action-reference-S3Deploy.md)
+ [Amazon S3 源操作参考](action-reference-S3.md)
+ [AWS AppConfig 部署操作参考](action-reference-AppConfig.md)
+ [CloudFormation 部署操作参考](action-reference-CloudFormation.md)
+ [CloudFormation StackSets](action-reference-StackSets.md)
+ [AWS CodeBuild 生成和测试操作参考](action-reference-CodeBuild.md)
+ [AWS CodePipeline 调用操作参考](action-reference-PipelineInvoke.md)
+ [AWS CodeCommit 源操作参考](action-reference-CodeCommit.md)
+ [AWS CodeDeploy 部署操作参考](action-reference-CodeDeploy.md)
+ [CodeStarSourceConnection 适用于 Bitbucket Cloud GitHub、、 GitHub 企业服务器、 GitLab .com 和 GitLab 自我管理操作](action-reference-CodestarConnectionSource.md)
+ [Commands 操作参考](action-reference-Commands.md)
+ [AWS Device Farm 测试操作参考](action-reference-DeviceFarm.md)
+ [Elastic Beanstalk 部署操作参考](action-reference-Beanstalk.md)
+ [Amazon Inspector `InspectorScan` 调用操作参考](action-reference-InspectorScan.md)
+ [AWS Lambda 调用操作参考](action-reference-Lambda.md)
+ [AWS OpsWorks 部署操作参考](action-reference-OpsWorks.md)
+ [AWS Service Catalog部署操作参考](action-reference-ServiceCatalog.md)
+ [AWS Step Functions](action-reference-StepFunctions.md)
# Amazon EC2 操作参考
您使用 Amazon EC2 `EC2` 操作将应用程序代码部署到您的部署实例集。您的部署实例集可以由 Amazon EC2 Linux 实例或 Linux SSM 管理的节点组成。您的实例必须已安装 SSM 代理。
**注意**
此操作仅支持 Linux 实例类型。支持的最大实例集规模是 500 个实例。
该操作将根据指定的最大实例数选择一定数量的实例。将首先选择先前实例中的失败实例。如果实例已经部署了相同的输入构件（例如之前操作失败的情况），则操作将跳过在这些实例上的部署。
**注意**
此操作仅支持 V2 类型管道。
**Topics**
+ [操作类型](#action-reference-EC2Deploy-type)
+ [配置参数](#action-reference-EC2Deploy-parameters)
+ [输入构件](#action-reference-EC2Deploy-input)
+ [输出构件](#action-reference-EC2Deploy-output)
+ [EC2 部署操作的服务角色策略权限](#action-reference-EC2Deploy-permissions-action)
+ [部署规范文件参考](#action-reference-EC2Deploy-spec-reference)
+ [操作声明](#action-reference-EC2Deploy-example)
+ [带有部署规范示例的操作声明](#action-reference-EC2Deploy-example-spec)
+ [另请参阅](#action-reference-EC2Deploy-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`EC2`
+ 版本：`1`
## 配置参数
**InstanceTagKey**
是否必需：是
您在 Amazon EC2 中创建的实例的标签键，例如 `Name`。
**InstanceTagValue**
必需：否
您在 Amazon EC2 中创建的实例的标签值，例如 `my-instances`。
如果未指定此值，则**InstanceTagKey**将匹配所有带有的实例。
**InstanceType**
是否必需：是
在 Amazon EC2 中创建的实例或 SSM 节点的类型。有效值为 `EC2` 和 `SSM_MANAGED_NODE`。
您必须已经在所有实例上创建、标记并安装了 SSM 代理。
创建实例时，会创建角色或使用现有的 EC2 实例角色。为避免`Access Denied`错误，您必须向实例角色添加 S3 存储桶权限，以授予实例对 CodePipeline 项目存储桶的权限。创建默认角色或更新现有角色，将 `s3:GetObject` 权限范围缩小到管道所在区域的构件存储桶。
**TargetDirectory**
必需：是（如果指定了脚本）。
在 Amazon EC2 实例中用来运行脚本的目录。
**DeploySpec**
必须：是（如果指定了部署规范）
用于配置部署、安装和生命周期事件的文件。有关部署规范字段的描述和信息，请参阅[部署规范文件参考](#action-reference-EC2Deploy-spec-reference)。要查看指定了部署规范文件的操作配置，请参阅[带有部署规范示例的操作声明](#action-reference-EC2Deploy-example-spec)中的示例。
**MaxBatch**
必需：否
允许同时部署的实例最大数量。
**MaxError**
必需：否
部署期间允许的实例错误最大数量。
**TargetGroupNameList**
必需：否
要部署的目标组名称列表。您必须已经创建了目标组。
目标组提供了一组用于处理特定请求的实例。如果指定了目标组，则实例将在部署前从目标组中移除，并在部署后重新添加到目标组。
**PreScript**
必需：否
在操作部署阶段之前运行的脚本。
**PostScript**
是否必需：是
在操作部署阶段之后运行的脚本。
下图显示了已选择**使用操作配置**的**编辑**页面示例。
![\[新管道的 “编辑” 操作页面，其中 “部 EC2署” 操作使用操作配置指定\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-action.png)
下图显示了选择 “**使用 DeploySpec 文件**” 的操作的 **“编辑**” 页面示例。
![\[新管道的 “编辑” 操作页面，其中包含使用规范文件的 “ EC2部署” 操作选项\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-action-spec.png)
## 输入构件
+ **构件数：**`1`
+ **描述：**为支持部署期间的脚本操作而提供的文件（如果有）。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## EC2 部署操作的服务角色策略权限
CodePipeline 运行操作时， CodePipeline 服务角色需要以下权限，这些权限已适当缩小范围，便于具有最低权限的访问权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementWithAllResource",
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"elasticloadbalancing:DescribeTargetGroupAttributes",
"elasticloadbalancing:DescribeTargetGroups",
"elasticloadbalancing:DescribeTargetHealth",
"ssm:CancelCommand",
"ssm:DescribeInstanceInformation",
"ssm:ListCommandInvocations"
],
"Resource": [
"*"
]
},
{
"Sid": "StatementForLogs",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForElasticloadbalancing",
"Effect": "Allow",
"Action": [
"elasticloadbalancing:DeregisterTargets",
"elasticloadbalancing:RegisterTargets"
],
"Resource": [
"arn:aws:elasticloadbalancing:us-east-1:111122223333:targetgroup/[[targetGroupName]]/*"
]
},
{
"Sid": "StatementForSsmOnTaggedInstances",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/{{tagKey}}": "{{tagValue}}"
}
}
},
{
"Sid": "StatementForSsmApprovedDocuments",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1::document/AWS-RunPowerShellScript",
"arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
]
}
]
}
```
------
### 在日志中记录管道的 CloudWatch 组
CodePipeline 运行操作时，使用管道名称 CodePipeline 创建日志组，如下所示。这样就可以使用管道名称缩小日志资源的权限范围。
```
/aws/codepipeline/MyPipelineName
```
上述服务角色更新中包含以下日志记录权限。
+ 日志：CreateLogGroup
+ 日志：CreateLogStream
+ 日志：PutLogEvents
要在控制台中使用操作详细信息对话框页面查看日志，必须在控制台角色中添加查看日志的权限。有关更多信息，请参阅[在控制台中查看计算日志所需的权限](security-iam-permissions-console-logs.md)中的控制台权限策略示例。
### 服务角色策略 CloudWatch 日志权限
CodePipeline 运行操作时，使用管道名称 CodePipeline 创建日志组，如下所示。这样就可以使用管道名称缩小日志资源的权限范围。
```
/aws/codepipeline/MyPipelineName
```
要在控制台中使用操作详细信息对话框页面查看日志，必须在控制台角色中添加查看日志的权限。有关更多信息，请参阅[在控制台中查看计算日志所需的权限](security-iam-permissions-console-logs.md)中的控制台权限策略示例。
## 部署规范文件参考
CodePipeline 运行操作时，您可以指定一个规范文件来配置实例的部署。部署规范文件指定要安装的内容以及运行哪些生命周期事件钩子以响应部署生命周期事件。部署规范文件始终采用 YAML 格式。部署规范文件用于：
+ 将应用程序修订中的源文件映射到其在实例上的目的地。
+ 为部署的文件指定自定义权限。
+ 指定要在部署过程的各个阶段在每个实例上运行的脚本。
部署规范文件支持该 AppSpec 文件支持的 CodeDeploy 特定部署配置参数。您可以直接使用现有 AppSpec 文件，任何不支持的参数都将被忽略。有关中该 AppSpec文件的更多信息 CodeDeploy，请参阅《*[CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)用户指南*》中的 “应用程序规范” 文件参考。
文件部署参数的指定方式如下。
+ `files` - 部署规范文件为部署文件指定 `source:` 和 `destination:`。
+ `scripts` - 部署的脚本事件。支持两个事件：`BeforeDeploy` 和 `AfterDeploy`。
+ `hooks` - 事件的生命周期挂钩。支持以下钩子：`ApplicationStop`、`BeforeInstall`、`AfterInstall`、`ApplicationStart` 和 `ValidateService`。
**注意**
hooks 参数可用于 AppSpec 兼容， CodeDeploy并且仅在 0.0 版（AppSpec 格式）中可用。对于这种格式， CodePipeline 将尽力对事件进行映射。
规范文件中必须使用正确的 YAML 空间；否则，如果部署规范文件中的位置和空间数量不正确，将发生错误。有关间距的更多信息，请参阅 [YAML](http://www.yaml.org/) 规范。
下方是部署规范文件示例。
```
version: 0.1
files:
- source: /index.html
destination: /var/www/html/
scripts:
BeforeDeploy:
- location: scripts/install_dependencies
timeout: 300
runas: myuser
AfterDeploy:
- location: scripts/start_server
timeout: 300
runas: myuser
```
要查看指定了部署规范文件的操作配置，请参阅[带有部署规范示例的操作声明](#action-reference-EC2Deploy-example-spec)中的示例。
## 操作声明
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
PostScript: "test/script.sh",
TargetDirectory: "/home/ec2-user/deploy"
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2",
"PostScript": "test/script.sh",
"TargetDirectory": "/home/ec2-user/deploy"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## 带有部署规范示例的操作声明
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
DeploySpec: "deployspec.yaml"
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeploySpec": "deployspec.yaml",
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用以下命令部署到 Amazon EC2 实例 CodePipeline](tutorials-ec2-deploy.md)：本教程将引导您创建 EC2 实例，在其中部署脚本文件，并使用 EC2 操作创建管道。
+ [EC2 部署操作失败并显示错误消息“`No such file`”](troubleshooting.md#troubleshooting-ec2-deploy)：本主题描述了针对 EC2 操作中文件未找到错误的故障排除方法。
# Amazon ECR 源操作参考
在新映像推送到 Amazon ECR 存储库时触发管道。此操作提供了一个映像定义文件，该文件引用推送到 Amazon ECR 的映像的 URI。此源操作通常与其他源操作（例如 CodeCommit）结合使用，以允许所有其他源构件的源位置。有关更多信息，请参阅 [教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)。
当您使用控制台创建或编辑管道时， CodePipeline 会创建一个 EventBridge 规则，当存储库发生更改时，该规则会启动您的管道。
**注意**
对于 Amazon ECR、Amazon S3 或 CodeCommit 源，您还可以使用输入转换条目创建源替换，以便`revisionValue`在 EventBridge 管道事件中使用 in，其中派生自对象密钥、提交或图像 ID 的源事件变量。`revisionValue`有关更多信息，请参阅[Amazon ECR 源操作和 EventBridge 资源](create-cwe-ecr-source.md)、[连接到启用事件源的 Amazon S3 源操作](create-S3-source-events.md)或[CodeCommit 源操作和 EventBridge](triggering.md)下的流程中包含的输入转换条目的可选步骤。
您必须事先创建 Amazon ECR 存储库并推送映像，然后才能通过 Amazon ECR 操作连接管道。
**Topics**
+ [操作类型](#action-reference-ECR-type)
+ [配置参数](#action-reference-ECR-config)
+ [输入构件](#action-reference-ECR-input)
+ [输出构件](#action-reference-ECR-output)
+ [输出变量](#action-reference-ECR-variables)
+ [服务角色权限：Amazon ECR 操作](#edit-role-ecr)
+ [操作声明（Amazon ECR 示例）](#action-reference-ECR-example)
+ [另请参阅](#action-reference-ECR-links)
## 操作类型
+ 类别：`Source`
+ 拥有者：`AWS`
+ 提供方：`ECR`
+ 版本：`1`
## 配置参数
**RepositoryName**
是否必需：是
向其中推送映像的 Amazon ECR 存储库的名称。
**ImageTag**
必需：否
为映像使用的标签。
如果未指定 `ImageTag` 的值，则该值默认为 `latest`。
## 输入构件
+ **构件数：**`0`
+ **描述：**输入构件不适用于此操作类型。
## 输出构件
+ **构件数：**`1`
+ **描述：**此操作生成包含 `imageDetail.json` 文件的构件，该文件包含触发管道执行的映像的 URI。有关 `imageDetail.json` 文件的信息，请参阅[用于亚马逊 ECS 部署操作的 imageDetail.json 文件 blue/green](file-reference.md#file-reference-ecs-bluegreen)。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**RegistryId**
与包含存储库的注册表关联的 AWS 账户 ID。
**RepositoryName**
向其中推送映像的 Amazon ECR 存储库的名称。
**ImageTag**
为映像使用的标签。
当源修订被覆盖时，`ImageTag` 输出变量不会输出
**ImageDigest**
映像清单的 `sha256` 摘要。
**ImageURI**
映像的 URI。
## 服务角色权限：Amazon ECR 操作
对于 Amazon ECR 支持，请将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": [
"ecr:DescribeImages"
],
"Resource": "resource_ARN"
},
```
有关此操作的更多信息，请参阅[Amazon ECR 源操作参考](#action-reference-ECR)。
## 操作声明（Amazon ECR 示例）
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: ECR
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ImageTag: latest
RepositoryName: my-image-repo
Name: ImageSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "ECR"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ImageTag": "latest",
"RepositoryName": "my-image-repo"
},
"Name": "ImageSource"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)— 本教程提供了一个示例应用程序规范文件以及示例 CodeDeploy 应用程序和部署组，用于创建管道，其中包含部署到 Amazon ECS 实例的 Amazon ECR 源。 CodeCommit
# `ECRBuildAndPublish` 构建操作参考
此构建操作允许您在源发生更改时自动构建和推送新映像。此操作基于指定的 Docker 文件位置构建并推送映像。此构建操作与中的 Amazon ECR 源操作不同 CodePipeline，后者会在您的 Amazon ECR 源存储库发生更改时触发管道。有关该操作的信息，请参阅[Amazon ECR 源操作参考](action-reference-ECR.md)。
这不是会触发管道的源操作。此操作会构建映像并将其推送到您的 Amazon ECR 映像存储库。
在将操作添加到管道之前，您必须已经创建了 Amazon ECR 存储库并已将 Dockerfile 添加到源代码存储库中 GitHub，例如。
**重要**
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。
**注意**
此操作仅适用于 V2 类型管道。
**Topics**
+ [操作类型](#action-reference-ECRBuildAndPublish-type)
+ [配置参数](#action-reference-ECRBuildAndPublish-config)
+ [输入构件](#action-reference-ECRBuildAndPublish-input)
+ [输出构件](#action-reference-ECRBuildAndPublish-output)
+ [输出变量](#action-reference-ECRBuildAndPublish-output-variables)
+ [服务角色权限：`ECRBuildAndPublish` 操作](#edit-role-ECRBuildAndPublish)
+ [操作声明](#action-reference-ECRBuildAndPublish-example)
+ [另请参阅](#action-reference-ECRBuildAndPublish-links)
## 操作类型
+ 类别：`Build`
+ 拥有者：`AWS`
+ 提供方：`ECRBuildAndPublish`
+ 版本：`1`
## 配置参数
**ECRRepository名称**
是否必需：是
向其中推送映像的 Amazon ECR 存储库的名称。
**DockerFilePath**
必需：否
用于构建镜像的 Docker 文件的位置。如果该文件位置不在根级别，您可以选择提供备用 Docker 文件位置。
如果未指定 `DockerFilePath` 的值，则该值默认为源存储库根级别。
**ImageTags**
必需：否
为映像使用的标签。您可以逗号分隔的字符串列表形式输入多个标签。
如果未指定 `ImageTags` 的值，则该值默认为 `latest`。
**RegistryType**
必需：否
指定存储库是公共还是私有。有效值为 `private | public`。
如果未指定 `RegistryType` 的值，则该值默认为 `private`。
## 输入构件
+ **构件数：**`1`
+ **描述：**源操作生成的构件，其中包含构建映像所需的 Dockerfile。
## 输出构件
+ **构件数：**`0`
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**ECRImageDigestId **
映像清单的 `sha256` 摘要。
**ECRRepository名称 **
向其中推送映像的 Amazon ECR 存储库的名称。
## 服务角色权限：`ECRBuildAndPublish` 操作
如需 `ECRBuildAndPublish` 操作支持，请将以下内容添加到策略语句中：
```
{
"Statement": [
{
"Sid": "ECRRepositoryAllResourcePolicy",
"Effect": "Allow",
"Action": [
"ecr:DescribeRepositories",
"ecr:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:GetAuthorizationToken"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetAuthorizationToken",
"ecr:InitiateLayerUpload",
"ecr:UploadLayerPart",
"ecr:CompleteLayerUpload",
"ecr:PutImage",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "PrivateECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"ecr-public:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:InitiateLayerUpload",
"ecr-public:UploadLayerPart",
"ecr-public:CompleteLayerUpload",
"ecr-public:PutImage",
"ecr-public:BatchCheckLayerAvailability",
"sts:GetServiceBearerToken"
],
"Resource": "PublicECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"sts:GetServiceBearerToken"
],
"Resource": "*"
}
]
}
```
此外，如果尚未为`Commands`操作添加以下权限，请向您的服务角色添加以下权限以查看 CloudWatch 日志。
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**注意**
在服务角色策略声明中使用基于资源的权限，将权限范围缩小到管道资源级别。
有关此操作的更多信息，请参阅[`ECRBuildAndPublish` 构建操作参考](#action-reference-ECRBuildAndPublish)。
## 操作声明
------
#### [ YAML ]
```
name: ECRBuild
actionTypeId:
category: Build
owner: AWS
provider: ECRBuildAndPublish
version: '1'
runOrder: 1
configuration:
ECRRepositoryName: actions/my-imagerepo
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: BuildVariables
```
------
#### [ JSON ]
```
{
"name": "ECRBuild",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"provider": "ECRBuildAndPublish",
"version": "1"
},
"runOrder": 1,
"configuration": {
"ECRRepositoryName": "actions/my-imagerepo"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "BuildVariables"
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用 CodePipeline （V2 类型）构建 Docker 镜像并将其推送到亚马逊 ECR](tutorials-ecr-build-publish.md)：本教程提供了示例 Dockerfile 和创建管道的说明，该管道用于在源存储库发生更改时将您的映像推送到 ECR，然后部署到 Amazon ECS。
# Amazon 弹性容器服务和 CodeDeploy 蓝绿色部署操作参考
你可以在中配置一个使用部署 AWS CodePipeline 来部署容器应用程序的 blue/green 管道。在 blue/green 部署中，您可以启动应用程序的新版本和旧版本，也可以在将流量重新路由到新版本之前对其进行测试。您还可以监控部署流程并且在存在问题的情况下迅速回滚。
已完成的管道会检测您的图像或任务定义文件的更改，并使用 CodeDeploy 这些更改将流量路由和部署到 Amazon ECS 集群和负载均衡器。 CodeDeploy 在您的负载均衡器上创建一个新的侦听器，该侦听器可以通过特殊端口定位您的新任务。您也可以将管道配置为使用存储您的 Amazon ECS 任务定义的源位置，例如存储 CodeCommit 库。
在创建管道之前，您必须已经创建 Amazon ECS CodeDeploy 资源、资源以及负载均衡器和目标组。您必须已将图像标记并存储在图像存储库中，并将任务定义和 AppSpec 文件上传到文件存储库。
**注意**
本主题介绍了 Amazon ECS 到 CodeDeploy 蓝/绿部署操作。 CodePipeline有关中 Amazon ECS 标准部署操作的参考信息 CodePipeline，请参阅[Amazon Elastic Container Service 部署操作参考](action-reference-ECS.md)。
**Topics**
+ [操作类型](#action-reference-ECSbluegreen-type)
+ [配置参数](#action-reference-ECSbluegreen-config)
+ [输入构件](#action-reference-ECSbluegreen-input)
+ [输出构件](#action-reference-ECSbluegreen-output)
+ [服务角色权限：`CodeDeployToECS` 操作](#edit-role-codedeploy-ecs)
+ [操作声明](#action-reference-ECSbluegreen-example)
+ [另请参阅](#action-reference-ECSbluegreen-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`CodeDeployToECS`
+ 版本：`1`
## 配置参数
**ApplicationName**
是否必需：是
中的应用程序名称 CodeDeploy。在创建管道之前，您必须已经在中创建了应用程序 CodeDeploy。
**DeploymentGroupName**
是否必需：是
为您为 CodeDeploy 应用程序创建的 Amazon ECS 任务集指定的部署组。在创建管道之前，您必须已经在中创建了部署组 CodeDeploy。
**TaskDefinitionTemplateArtifact**
是否必需：是
用于为部署操作提供任务定义文件的输入构件的名称。这通常为源操作的输出构件的名称。使用控制台时，源操作输出构件的默认名称为 `SourceArtifact`。
**AppSpecTemplateArtifact**
是否必需：是
为部署操作提供 AppSpec 文件的输入对象的名称。此值会在管道运行时进行更新。这通常为源操作的输出构件的名称。使用控制台时，源操作输出构件的默认名称为 `SourceArtifact`。对于`TaskDefinition`在 AppSpec 文件中，您可以保留``占位符文本，如下所[示](tutorials-ecs-ecr-codedeploy.md#tutorials-ecs-ecr-codedeploy-taskdefinition)。
**AppSpecTemplatePath**
必需：否
存储在管道源 AppSpec 文件位置（例如您的管道存储 CodeCommit 库）中的文件的文件名。默认文件名为 `appspec.yaml`。如果您的 AppSpec 文件名相同，并且存储在文件存储库的根级别，则无需提供文件名。如果路径不是默认路径，请输入路径和文件名。
**TaskDefinitionTemplatePath**
必需：否
存储在管道文件源位置（例如您的管道存储 CodeCommit 库）中的任务定义的文件名。默认文件名为 `taskdef.json`。如果您的任务定义文件同名且存储在文件存储库的根级别，则无需提供文件名。如果路径不是默认路径，请输入路径和文件名。
**图片 ArtifactName**
必需：否
用于为部署操作提供映像的输入构件的名称。这通常是映像存储库的输出构件，如 Amazon ECR 源操作的输出。
`` 的可用值为 1 到 4。
**图片 ContainerName**
必需：否
映像存储库（如 Amazon ECR 源存储库）中可用映像的名称。
`` 的可用值为 1 到 4。
## 输入构件
+ **构件数：**`1 to 5`
+ **描述：**该`CodeDeployToECS`操作首先在源文件存储库中查找任务定义文件和文件，然后在图像存储库中查找图像，然后动态生成任务定义的新修订版，最后运行 AppSpec 命令将任务集和容器部署到集群。 AppSpec
`CodeDeployToECS` 操作会查找将映像 URI 映射到映像的 `imageDetail.json` 文件。当您向 Amazon ECR 映像存储库提交更改时，管道 ECR 源操作会为该提交创建 `imageDetail.json` 文件。在未自动执行操作的情况下，您还可以为管道手动添加 `imageDetail.json` 文件。有关 `imageDetail.json` 文件的信息，请参阅[用于亚马逊 ECS 部署操作的 imageDetail.json 文件 blue/green](file-reference.md#file-reference-ecs-bluegreen)。
`CodeDeployToECS` 操作会动态生成任务定义的新修订版。在此阶段，该操作会将任务定义文件中的占位符替换为从 imageDetail.json 文件检索到的映像 URI。例如，如果您将 *IMAGE1\$1NAM* E 设置为 Image1 ContainerName 参数，则应将占位符 *< IMAGE1 \$1NAME> 指定为任务*定义文件中图像字段的值。在这种情况下， CodeDeployToECS 操作会将占位符 *< IMAGE1 \$1NAME>* 替换为从您指定为 Image1 的构件中的 ImageDetail.json 检索到的实际图像 URI。ArtifactName
对于任务定义更新，该 CodeDeploy `AppSpec.yaml`文件包含`TaskDefinition`属性。
```
TaskDefinition:
```
创建新任务定义后，`CodeDeployToECS` 操作将会更新此属性。
对于 `TaskDefinition` 字段的值，占位符文本必须为 。`CodeDeployToECS` 操作会将此占位符替换为动态生成的任务定义的实际 ARN。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限：`CodeDeployToECS` 操作
对于`CodeDeployToECS`操作（blue/green deployments), the following are the minimum permissions needed to create pipelines with a CodeDeploy to Amazon ECS blue/green部署操作）。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCodeDeployDeploymentActions",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetDeployment"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployApplicationActions",
"Action": [
"codedeploy:GetApplication",
"codedeploy:GetApplicationRevision",
"codedeploy:RegisterApplicationRevision"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]",
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployDeploymentConfigAccess",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:*"
],
"Effect": "Allow"
},
{
"Sid": "AllowECSRegisterTaskDefinition",
"Action": [
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
],
"Effect": "Allow"
},
{
"Sid": "AllowPassRoleToECS",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[PassRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
您可以选择加入以使用 Amazon ECS 中的标记授权。选择加入后，您必须授予以下权限：`ecs:TagResource`。有关如何选择加入以及如何确定是否需要权限和是否强制执行标记授权的更多信息，请参阅《Amazon Elastic Container Service 开发者指南》中的[标记授权时间表](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline)。
您还必须添加 `iam:PassRole` 权限以使用任务 IAM 角色。有关更多信息，请参阅 [Amazon ECS 任务执行 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)和[任务 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)。
您还可以将 `ecs-tasks.amazonaws.com` 添加到 `iam:PassedToService` 条件下的服务列表中，如上述示例所示。
## 操作声明
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeployToECS
Version: '1'
RunOrder: 1
Configuration:
AppSpecTemplateArtifact: SourceArtifact
ApplicationName: ecs-cd-application
DeploymentGroupName: ecs-deployment-group
Image1ArtifactName: MyImage
Image1ContainerName: IMAGE1_NAME
TaskDefinitionTemplatePath: taskdef.json
AppSpecTemplatePath: appspec.yaml
TaskDefinitionTemplateArtifact: SourceArtifact
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
- Name: MyImage
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeployToECS",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"AppSpecTemplateArtifact": "SourceArtifact",
"ApplicationName": "ecs-cd-application",
"DeploymentGroupName": "ecs-deployment-group",
"Image1ArtifactName": "MyImage",
"Image1ContainerName": "IMAGE1_NAME",
"TaskDefinitionTemplatePath": "taskdef.json",
"AppSpecTemplatePath": "appspec.yaml",
"TaskDefinitionTemplateArtifact": "SourceArtifact"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
},
{
"Name": "MyImage"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)— 本教程将引导您创建 blue/green 部署所需的 Amazon ECS 资源 CodeDeploy 和 Amazon ECS 资源。本教程展示了如何将 Docker 映像推送到 Amazon ECR，并创建 Amazon ECS 任务定义，其中列出您的 Docker 映像名称、容器名称、Amazon ECS 服务名称和负载均衡器配置。然后，本教程将引导您完成为部署创建 AppSpec 文件和管道的过程。
**注意**
本主题和教程描述了的 CodeDeploy/ECS 蓝/绿操作。 CodePipeline有关中 ECS 标准操作的信息 CodePipeline，请参阅[教程：使用进行持续部署 CodePipeline](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html)。
+ *AWS CodeDeploy 用户指南* — 有关如何在 blue/green 部署中使用负载均衡器、生产侦听器、目标组和您的 Amazon ECS 应用程序的信息，请参阅[教程：部署 Amazon ECS 服务](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)。《*AWS CodeDeploy 用户指南*》中的此参考信息概述了 Amazon ECS 和的蓝/绿部署。 AWS CodeDeploy
+ *Amazon Elastic Container Service 开发者指南*：有关使用 Docker 映像和容器、ECS 服务和集群以及 ECS 任务集的信息，请参阅[什么是 Amazon ECS？](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)
# Amazon Elastic Container Service 部署操作参考
您可以使用 Amazon ECS 操作来部署 Amazon ECS 服务和任务集。Amazon ECS 服务是部署到 Amazon ECS 集群的容器应用程序。Amazon ECS 集群是在云中托管容器应用程序的实例集。部署需要您在 Amazon ECS 中创建的任务定义和 CodePipeline 用于部署映像的图像定义文件。
**重要**
Amazon ECS 的标准部署操作会根据 Amazon ECS 服务使用的修订版 CodePipeline 创建自己的任务定义修订版。如果您在不更新 Amazon ECS 服务的情况下为任务定义创建新的修订，则部署操作将忽略这些修订。
在创建管道之前，您必须已经创建 Amazon ECS 资源，在映像存储库中标记并存储了映像，并将 BuildSpec 文件上传到您的文件存储库。
**注意**
本参考主题介绍了 Amazon ECS 的标准部署操作 CodePipeline。有关中 Amazon ECS 到 CodeDeploy 蓝/绿部署操作的参考信息 CodePipeline，请参阅。[Amazon 弹性容器服务和 CodeDeploy 蓝绿色部署操作参考](action-reference-ECSbluegreen.md)
**Topics**
+ [操作类型](#action-reference-ECS-type)
+ [配置参数](#action-reference-ECS-config)
+ [输入构件](#action-reference-ECS-input)
+ [输出构件](#action-reference-ECS-output)
+ [服务角色权限：Amazon ECS 标准操作](#edit-role-ecs)
+ [操作声明](#action-reference-ECS-example)
+ [另请参阅](#action-reference-ECS-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`ECS`
+ 版本：`1`
## 配置参数
**ClusterName**
是否必需：是
Amazon ECS 中的 Amazon ECS 集群。
**ServiceName**
是否必需：是
您在 Amazon ECS 中创建的 Amazon ECS 服务。
**FileName**
必需：否
您的映像定义文件，该 JSON 描述服务的容器名称以及映像和标签。您需要将此文件用于 ECS 标准部署。有关更多信息，请参阅[输入构件](#action-reference-ECS-input)和[适用于 Amazon ECS 标准部署操作的 imagedefinitions.json 文件](file-reference.md#pipelines-create-image-definitions)。
**DeploymentTimeout**
必需：否
Amazon ECS 部署操作超时（以分钟为单位）。该超时可配置为此操作的最大默认超时。例如：
```
"DeploymentTimeout": "15"
```
## 输入构件
+ **构件数：**`1`
+ **描述：**该操作会在管道的源文件存储库中查找 `imagedefinitions.json` 文件。图像定义文档是一个 JSON 文件，用于描述您的 Amazon ECS 容器名称以及图像和标签。 CodePipeline 使用该文件从您的图像存储库（例如 Amazon ECR）中检索图像。在未自动执行操作的情况下，您可以为管道手动添加 `imagedefinitions.json` 文件。有关 `imagedefinitions.json` 文件的信息，请参阅[适用于 Amazon ECS 标准部署操作的 imagedefinitions.json 文件](file-reference.md#pipelines-create-image-definitions)。
操作需要已推送到您的映像存储库的现有映像。由于映像映射由 `imagedefinitions.json` 文件提供，因此操作不要求包含 Amazon ECR 源以作为管道中的源操作。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限：Amazon ECS 标准操作
对于 Amazon ECS，以下是创建具有 Amazon ECS 部署操作的管道所需的最低权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TaskDefinitionPermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeTaskDefinition",
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
]
},
{
"Sid": "ECSServicePermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeServices",
"ecs:UpdateService"
],
"Resource": [
"arn:aws:ecs:*:111122223333:service/[[clusters]]/*"
]
},
{
"Sid": "ECSTagResource",
"Effect": "Allow",
"Action": [
"ecs:TagResource"
],
"Resource": [
"arn:aws:ecs:*:111122223333:task-definition/[[taskDefinitions]]:*"
],
"Condition": {
"StringEquals": {
"ecs:CreateAction": [
"RegisterTaskDefinition"
]
}
}
},
{
"Sid": "IamPassRolePermissions",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[passRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
您可以选择加入以使用 Amazon ECS 中的标记授权。选择加入后，您必须授予以下权限：`ecs:TagResource`。有关如何选择加入以及如何确定是否需要权限和是否强制执行标记授权的更多信息，请参阅《Amazon Elastic Container Service 开发者指南》中的[标记授权时间表](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline)。
您必须添加 `iam:PassRole` 权限以使用 IAM 角色执行任务。有关更多信息，请参阅 [Amazon ECS 任务执行 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)和[任务 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)。使用以下策略文本。
## 操作声明
------
#### [ YAML ]
```
Name: DeployECS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ECS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-ecs-cluster
ServiceName: sample-app-service
FileName: imagedefinitions.json
DeploymentTimeout: '15'
OutputArtifacts: []
InputArtifacts:
- Name: my-image
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ECS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-ecs-cluster",
"ServiceName": "sample-app-service",
"FileName": "imagedefinitions.json",
"DeploymentTimeout": "15"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-image"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用 CodePipeline （V2 类型）构建 Docker 镜像并将其推送到亚马逊 ECR](tutorials-ecr-build-publish.md)有关如何使用 “ ECRBuildand发布” 操作推送映像，然后使用 ECS 标准操作部署到 Amazon ECS 的教程，请参阅。
+ [教程：使用持续部署 CodePipeline](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html) — 本教程向您展示如何创建存储在源文件存储库中的 Dockerfile，例如。 CodeCommit接下来，本教程将向您展示如何合并一个 CodeBuild BuildSpec 文件，该文件用于生成您的 Docker 映像并将其推送到 Amazon ECR，并创建 imagedefinitions.json 文件。最后，您将创建 Amazon ECS 服务和任务定义，然后创建具有 Amazon ECS 部署操作的管道。
**注意**
本主题和教程介绍了 Amazon ECS 的标准部署操作 CodePipeline。有关中 Amazon ECS 到 CodeDeploy 蓝/绿部署操作的信息 CodePipeline，请参阅。[教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)
+ *Amazon Elastic Container Service 开发者指南*：有关使用 Docker 映像和容器、Amazon ECS 服务和集群以及 Amazon ECS 任务集的信息，请参阅[什么是 Amazon ECS？](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)
# Amazon Elastic Kubernetes Service `EKS` 部署操作参考
您可以使用 `EKSDeploy` 操作部署 Amazon EKS 服务。部署需要一个 CodePipeline 用于部署镜像的 Kubernetes 清单文件。
在创建管道之前，您必须事先创建 Amazon EKS 资源，并在映像存储库中存储映像。您可以选择为集群提供 VPC 信息。
**重要**
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。
**注意**
`EKS` 部署操作仅适用于 V2 类型管道。
EKS 操作支持公共和私有 EKS 集群。私有集群是 EKS 推荐的类型；但是，两种类型都支持。
跨账户操作支持 EKS 操作。要添加跨账户 EKS 操作，请在操作声明中添加目标账户中的 `actionRoleArn`。
**Topics**
+ [操作类型](#action-reference-EKS-type)
+ [配置参数](#action-reference-EKS-config)
+ [输入构件](#action-reference-EKS-input)
+ [输出构件](#action-reference-EKS-output)
+ [环境变量](#action-reference-EKS-env-variables)
+ [输出变量](#action-reference-EKS-output-vars)
+ [服务角色策略权限](#action-reference-EKS-service-role)
+ [操作声明](#action-reference-EKS-example)
+ [另请参阅](#action-reference-EKS-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`EKS`
+ 版本：`1`
## 配置参数
**ClusterName**
是否必需：是
Amazon EKS 中的 Amazon EKS 集群。
**Helm 下的选项**
当选定部署工具为 **Helm** 时，以下是可用的选项。
**HelmReleaseName **
必需：是（仅对于 **Helm** 类型是必需）
部署的发布名称。
**HelmChartLocation **
必需：是（仅对于 **Helm** 类型是必需）
部署的图表位置。
**HelmValuesFiles **
必需：否（仅对于 **Helm** 类型是可选）
要覆盖 Helm 值文件，请在 Helm 图表位置输入以逗号分隔的 Helm 值文件。
**Kubectl 下的选项**
当选定部署工具为 **Kubectl** 时，以下是可用的选项。
**ManifestFiles**
必需：是（仅对于 **Kubectl** 类型是必需）
清单文件名称，该文本文件描述服务的容器名称以及映像和标签。您可以使用此文件来参数化映像 URI 和其他信息。您可以使用环境变量来实现此目的。
您可以将此文件存储在管道的源存储库中。
**命名空间**
必需：否
要在 `kubectl` 或 `helm` 命令中使用的 Kubernetes 命名空间。
**子网**
必需：否
您的集群的 VPC 的子网。它们属于附加到您的集群的同一 VPC。您还可以提供尚未附加到您的集群的子网，并在此处进行指定。
**SecurityGroupIds**
必需：否
您的集群的 VPC 的安全组。它们属于附加到您的集群的同一 VPC。您还可以提供尚未附加到您的集群的安全组，并在此处进行指定。
## 输入构件
+ **构件数：**`1`
+ **描述：**该操作会在管道的源文件存储库中查找 Kubernetes 清单文件或 Helm 图表。如果要使用存储在 S3 存储桶中的.tgz 格式的掌舵图，则可以通过将 S3 配置 Bucket/Key 为源操作来实现。例如，提供的对象密钥将是 `my-chart-0.1.0.tgz`。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 环境变量
用于替换清单文件或 Helm 图表值文件中的映像存储库或映像标签等变量。
**Key**
键值对环境变量对的键，例如 `$IMAGE_TAG`。
**值**
键/值对的值，例如 `v1.0`。可以使用管道操作中的输出变量或管道变量来参数化该值。例如，pipeline 可以有一个 ECRBuildAndPublish 使用创建 ECR 映像的操作`${codepipeline.PipelineExecutionId}`，而 EKS 操作可以使用该图像`${codepipeline.PipelineExecutionId}`作为环境变量的值。
## 输出变量
**EKSCluster名称**
Amazon EKS 中的 Amazon EKS 集群。
## 服务角色策略权限
要运行此操作，管道的服务角色策略中必须提供以下权限。
+ **EC2 操作：** CodePipeline 运行该操作时需要 EC2 实例权限。请注意，这与创建 EKS 集群时所需的 EC2 实例角色不同。
如果您使用的是现有的服务角色，要使用此操作，需要为服务角色添加以下权限。
+ ec2: CreateNetworkInterface
+ ec2: DescribeDhcpOptions
+ ec2: DescribeNetworkInterfaces
+ ec2: DeleteNetworkInterface
+ ec2: DescribeSubnets
+ ec2: DescribeSecurityGroups
+ ec2: DescribeVpcs
+ **EKS 操作：** CodePipeline 运行操作时，需要 EKS 集群权限。请注意，这与创建 EKS 集群时所需的 IAM EKS 集群角色不同。
如果您使用的是现有的服务角色，要使用此操作，需要为服务角色添加以下权限。
+ 谢谢：DescribeCluster
+ **日志流操作：** CodePipeline 运行操作时，使用管道名称 CodePipeline 创建日志组，如下所示。这样就可以使用管道名称缩小日志资源的权限范围。
```
/aws/codepipeline/MyPipelineName
```
如果您使用的是现有的服务角色，要使用此操作，需要为服务角色添加以下权限。
+ 日志：CreateLogGroup
+ 日志：CreateLogStream
+ 日志：PutLogEvents
在服务角色策略语句中，将权限范围缩小到资源级别，如下例所示。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster"
],
"Resource": "arn:aws:eks:*:111122223333:cluster/YOUR_CLUSTER_NAME"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:CreateNetworkInterfacePermission",
"ec2:DescribeDhcpOptions",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups",
"ec2:DescribeVpcs",
"ec2:DescribeRouteTables"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
]
}
```
------
要在控制台中使用操作详细信息对话框页面查看日志，必须在控制台角色中添加查看日志的权限。有关更多信息，请参阅[在控制台中查看计算日志所需的权限](security-iam-permissions-console-logs.md)中的控制台权限策略示例。
### 将服务角色添加为集群的访问入口
在管道的服务角色策略中提供权限后，您可以通过将 CodePipeline 服务角色添加为集群的访问条目来配置集群权限。
您也可以使用具有更新权限的操作角色。有关更多信息，请参阅[步骤 4：为 CodePipeline 服务角色创建访问条目](tutorials-eks-deploy.md#tutorials-eks-deploy-access-entry)中的教程示例。
## 操作声明
------
#### [ YAML ]
```
Name: DeployEKS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: EKS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-eks-cluster
ManifestFiles: ManifestFile.json
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "EKS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-eks-cluster",
"ManifestFiles": "ManifestFile.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ 请参阅[教程：使用以下方法部署到 Amazon EKS CodePipeline](tutorials-eks-deploy.md)中的教程，了解如何创建 EKS 集群和 Kubernetes 清单文件以便向管道添加操作。
# AWS Lambda 部署操作参考
您可以使用 AWS Lambda 部署操作来管理无服务器部署的应用程序代码部署。您可以部署函数并使用部署策略进行流量部署，如下所示：
+ 用于流量转移的金丝雀和线性部署
+ 一次性全部部署
**注意**
此操作仅支持 V2 类型管道。
**Topics**
+ [操作类型](#action-reference-LambdaDeploy-type)
+ [配置参数](#action-reference-LambdaDeploy-parameters)
+ [输入构件](#action-reference-LambdaDeploy-input)
+ [输出构件](#action-reference-LambdaDeploy-output)
+ [输出变量](#action-reference-LambdaDeploy-output-variables)
+ [Lambda 部署操作的服务角色策略权限](#action-reference-LambdaDeploy-permissions-action)
+ [操作声明](#action-reference-LambdaDeploy-example)
+ [另请参阅](#action-reference-LambdaDeploy-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`Lambda`
+ 版本：`1`
## 配置参数
**FunctionName**
是否必需：是
您在 Lambda 中创建的函数的名称，例如 `MyLambdaFunction`。
您必须已创建一个版本。
**FunctionAlias**
必需：否
您在 Lambda 中创建并且是要部署到的函数的别名，例如 `live`。操作执行开始时，别名必须存在且后面有一个版本。（这将是回滚目标版本。）
如果未提供，则该操作会将源构件部署到 `$LATEST` 并创建新版本。在此使用案例中，部署策略和目标版本选项不可用。
**PublishedTargetVersion**
必需：否
要部署到的所需的 Lambda 函数版本。 FunctionAlias它可以是管道或操作级别变量，例如 `#{variables.lambdaTargetVersion}`。在操作开始执行时，版本必须已发布。
如果未提供任何输入构件，则为必需项。
**DeployStrategy**
必需：否（默认值是 `AllAtOnce`）
确定 Lambda 部署操作用于将流量从原始版本的 Lambda 函数转移到新版本所采用的速率。**FunctionAlias**可用的部署策略是金丝雀或线性。接受的格式：
+ `AllAtOnce` -
所有流量一次性转移到更新后的 Lambda 函数。
如果未指定，则默认值为 `AllAtOnce`。
+ `Canary10Percent5Minutes` - 在第一次增量中转移 10% 的流量。其余 90% 在五分钟后进行部署。
百分比和分钟数的值都可以更改。
+ `Linear10PercentEvery1Minute` - 每分钟转移 10% 的流量，直到所有流量转移完毕。
百分比和分钟数的值都可以更改。
此字段有以下注意事项：
+ 最长总等待时间为 2 天。
+ 仅在提供时**FunctionAlias**可用。
**Alarms**
必需：否
为 Lambda 部署配置的逗号分隔的警报名称列表。最多可添加 10 个警报。当监控的警报进入 ALARM 状态时，操作失败。
下图显示了操作的编辑页面示例。
![\[使用 Lambda 部署操作的新管道的编辑操作页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)
## 输入构件
+ **构件数：**`1`
+ **描述：**为支持部署期间的脚本操作而提供的文件（如果有）。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**FunctionVersion**
已部署的新 Lambda 函数版本。
## Lambda 部署操作的服务角色策略权限
CodePipeline 运行操作时， CodePipeline 服务角色需要以下权限，这些权限已适当缩小范围，便于具有最低权限的访问权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementForLambda",
"Effect": "Allow",
"Action": [
"lambda:GetAlias",
"lambda:GetFunctionConfiguration",
"lambda:GetProvisionedConcurrencyConfig",
"lambda:PublishVersion",
"lambda:UpdateAlias",
"lambda:UpdateFunctionCode"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}",
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}:*"
]
},
{
"Sid": "StatementForCloudWatch",
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarms"
],
"Resource": [
"arn:aws:cloudwatch:us-east-1:111122223333:alarm:{{AlarmNames}}"
]
},
{
"Sid": "StatementForLogs1",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}",
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForLogs2",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:log-stream:*"
]
}
]
}
```
------
## 操作声明
------
#### [ YAML ]
```
name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: Lambda
version: '1'
runOrder: 1
configuration:
DeployStrategy: Canary10Percent5Minutes
FunctionAlias: aliasV1
FunctionName: MyLambdaFunction
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "Lambda",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeployStrategy": "Canary10Percent5Minutes",
"FunctionAlias": "aliasV1",
"FunctionName": "MyLambdaFunction"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "DeployVariables"
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：使用 Lambda 函数部署 CodePipeline](tutorials-lambda-deploy.md)：本教程将引导您创建示例 Lambda 函数，您将在其中创建别名和版本，将压缩后的 Lambda 函数添加到源位置，然后在管道中运行 Lambda 操作。
# Amazon S3 部署操作参考
您可以使用 Amazon S3 部署操作，向用于静态网站托管或归档的 Amazon S3 桶部署文件。您可以指定是否在将部署文件上传到桶之前提取部署文件。
**注意**
本参考主题介绍了 Amazon S3 部署操作， CodePipeline 其中部署平台是配置为托管的 Amazon S3 存储桶。有关中 Amazon S3 源操作的参考信息 CodePipeline，请参阅[Amazon S3 源操作参考](action-reference-S3.md)。
**Topics**
+ [操作类型](#action-reference-S3Deploy-type)
+ [配置参数](#action-reference-S3Deploy-config)
+ [输入构件](#action-reference-S3Deploy-input)
+ [输出构件](#action-reference-S3Deploy-output)
+ [服务角色权限：S3 部署操作](#edit-role-s3deploy)
+ [操作配置示例](#action-reference-S3Deploy-example)
+ [另请参阅](#action-reference-S3Deploy-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`S3`
+ 版本：`1`
## 配置参数
**BucketName**
是否必需：是
要用来存储源文件的 Amazon S3 桶的名称。
**Extract**
是否必需：是
如果为 true，则会规定在上传之前提取文件。否则，应用程序文件将保持压缩状态以供上传，如托管静态网站的情况。如果为 false，则 `ObjectKey` 为必填项。
**ObjectKey**
这是有条件的。如果 `Extract` = false，则为必需
以唯一方式标识 S3 桶中对象的 Amazon S3 对象密钥的名称。
**KMSEncryptionKeyarn**
必需：否
主机存储桶的 AWS KMS 加密密钥的 ARN。`KMSEncryptionKeyARN` 参数使用提供的 AWS KMS key对上传的构件进行加密。对于 KMS 密钥，您可以使用密钥 ID、密钥 ARN 或别名 ARN。
别名只能在创建 KMS 密钥的账户中识别。对于跨账户操作，您只能使用密钥 ID 或密钥 ARN 来标识密钥。跨账户操作涉及使用其他账户（AccountB）的角色，因此指定密钥 ID 将使用其他账户（AccountB）的密钥。
CodePipeline 仅支持对称 KMS 密钥。请勿使用非对称 KMS 密钥对 S3 桶中的数据进行加密。
**CannedACL**
必需：否
`CannedACL` 参数将指定的[标准 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) 应用于部署到 Amazon S3 的对象。这将覆盖已应用于对象的任何现有 ACL。
**CacheControl**
必需：否
该`CacheControl`参数控制存储桶中对象 requests/responses 的缓存行为。有关有效值的列表，请参阅 HTTP 操作的 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 标头字段。要在 `CacheControl` 中输入多个值，请在每个值之间使用逗号。您可以为 CLI 在每个逗号后添加一个空格（可选），如本示例所示：
```
"CacheControl": "public, max-age=0, no-transform"
```
## 输入构件
+ **构件数：**`1`
+ **描述：**用于部署或存档的文件由 CodePipeline源存储库获取、压缩和上传。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限：S3 部署操作
对于 S3 部署操作支持，将以下内容添加到策略语句中：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutObjectVersionAcl",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::[[s3DeployBuckets]]",
"arn:aws:s3:::[[s3DeployBuckets]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
要获得 S3 部署操作支持，如果您的 S3 对象具有标签，则您还必须在策略语句中添加以下权限：
```
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging"
```
## 操作配置示例
下面展示了操作配置的示例。
### 当 `Extract` 设置为 `false` 时的示例配置
以下示例显示了在 `Extract` 字段设置为 `false` 的情况下，创建操作时的默认操作配置。
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'false'
ObjectKey: MyWebsite
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "false",
"ObjectKey": "MyWebsite"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
### 当 `Extract` 设置为 `true` 时的示例配置
以下示例显示了在 `Extract` 字段设置为 `true` 的情况下，创建操作时的默认操作配置。
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'true'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "true"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：创建以 Amazon S3 作为部署提供程序的管道](tutorials-s3deploy.md)：本教程将演示两个示例，引导您创建具有 S3 部署操作的管道。您可以下载示例文件，将文件上传到 CodeCommit 存储库，创建 S3 存储桶，然后配置存储桶以进行托管。接下来，您可以使用 CodePipeline 控制台创建管道并指定 Amazon S3 部署配置。
+ [Amazon S3 源操作参考](action-reference-S3.md)— 本操作参考提供了 Amazon S3 源操作的参考信息和示例 CodePipeline。
# Amazon S3 源操作参考
将新对象上传到配置的存储桶和对象键时触发管道。
**注意**
本参考主题介绍了 Amazon S3 源操作， CodePipeline 其中源位置是为版本控制配置的 Amazon S3 存储桶。有关中 Amazon S3 部署操作的参考信息 CodePipeline，请参阅[Amazon S3 部署操作参考](action-reference-S3Deploy.md)。
您可以创建一个 Amazon S3 桶，用作应用程序文件的源位置。
**注意**
在您创建源存储桶时，请确保在存储桶上启用版本控制。如果您要使用现有 Amazon S3 桶，请参阅[使用版本控制](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html)，以在现有的桶上启用版本控制。
如果您使用控制台创建或编辑管道，则 CodePipeline 会创建一个 EventBridge 规则，该规则在 S3 源存储桶发生更改时启动您的管道。
**注意**
对于 Amazon ECR、Amazon S3 或 CodeCommit 源，您还可以使用输入转换条目创建源替换，以便`revisionValue`在 EventBridge 管道事件中使用 in，其中派生自对象密钥、提交或图像 ID 的源事件变量。`revisionValue`有关更多信息，请参阅[Amazon ECR 源操作和 EventBridge 资源](create-cwe-ecr-source.md)、[连接到启用事件源的 Amazon S3 源操作](create-S3-source-events.md)或[CodeCommit 源操作和 EventBridge](triggering.md)下的流程中包含的输入转换条目的可选步骤。
您必须事先创建 Amazon S3 源桶并将源文件作为单个 ZIP 文件上传，然后才能通过 Amazon S3 操作连接管道。
**注意**
当 Amazon S3 是您的管道的源提供程序时，您可以将一个或多个源文件压缩到单个 .zip 文件中，然后将 .zip 文件上传到源桶。您也可以上传单个解压缩的文件；但是，需要 .zip 文件的下游操作将失败。
**Topics**
+ [操作类型](#action-reference-S3-type)
+ [配置参数](#action-reference-S3-config)
+ [输入构件](#action-reference-S3-input)
+ [输出构件](#action-reference-S3-output)
+ [输出变量](#action-reference-S3-variables)
+ [服务角色权限：S3 源操作](#edit-role-s3source)
+ [操作声明](#action-reference-S3-example)
+ [另请参阅](#action-reference-S3-links)
## 操作类型
+ 类别：`Source`
+ 拥有者：`AWS`
+ 提供方：`S3`
+ 版本：`1`
## 配置参数
**S3Bucket**
是否必需：是
要在其中检测源更改的 Amazon S3 桶的名称。
**S3 ObjectKey**
是否必需：是
要在其中检测源更改的 Amazon S3 对象键的名称。
**AllowOverrideForS3ObjectKey**
必需：否
`AllowOverrideForS3ObjectKey` 控制 `StartPipelineExecution` 的源覆盖是否可以覆盖源操作中已配置的 `S3ObjectKey`。有关使用 S3 对象键进行源覆盖的更多信息，请参阅[使用源修订覆盖启动管道](pipelines-trigger-source-overrides.md)。
如果省略`AllowOverrideForS3ObjectKey`，则 CodePipeline 默认能够通过将此参数设置为， ObjectKey 在源操作中覆盖 S3。`false`
此参数的有效值：
+ `true`：如果设置了此项，则在管道执行过程中，可以通过源修订覆盖来覆盖预配置的 S3 对象键。
**注意**
如果您打算允许所有 CodePipeline 用户在开始新的管道执行时覆盖预先配置的 S3 对象密钥，则必须`AllowOverrideForS3ObjectKey`将`true`设置为。
+ `false`:
如果已设置， CodePipeline 则不允许使用源修订版本覆盖覆盖 S3 对象密钥。这也是此参数的默认值。
**PollForSourceChanges**
必需：否
`PollForSourceChanges`控制是否对 Amazon S3 源存储桶进行 CodePipeline 轮询以了解源代码更改。我们建议您改用 “ CloudWatch 事件” 和 CloudTrail “检测源更改”。有关配置 CloudWatch 事件的更多信息，请参阅[使用 S3 源和跟 CloudTrail 踪 (CLI) 迁移轮询管道](update-change-detection.md#update-change-detection-cli-S3)或[使用 S3 源和 CloudTrail 跟踪（CloudFormation 模板）迁移轮询管道](update-change-detection.md#update-change-detection-cfn-s3)。
如果要配置 CloudWatch 事件，则必须将设置为`PollForSourceChanges``false`以避免重复的管道执行。
此参数的有效值：
+ `true`: 如果已设置，则会对您的来源位置进行 CodePipeline 轮询以了解源位置是否有更改。
**注意**
如果省略`PollForSourceChanges`，则 CodePipeline 默认为对源位置进行轮询以查看源更改。如果包括 `PollForSourceChanges` 并将其设置为 `true`，则此行为相同。
+ `false`: 如果已设置，则 CodePipeline 不对源位置进行轮询以了解源位置是否有更改。如果您打算配置 CloudWatch 事件规则以检测源更改，请使用此设置。
## 输入构件
+ **构件数：**`0`
+ **描述：**输入构件不适用于此操作类型。
## 输出构件
+ **构件数：**`1`
+ **描述：**提供在源存储桶中配置为连接到管道的可用构件。从桶中生成的构件是 Amazon S3 操作的输出构件。Amazon S3 对象元数据（ETag 和版本 ID）显示为触发管道执行的源修订版。 CodePipeline
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关中变量的更多信息 CodePipeline，请参阅[变量参考](reference-variables.md)。
**BucketName**
与触发管道的源更改相关的 Amazon S3 存储桶的名称。
**ETag**
与触发管道的源更改相关的对象的实体标签。 ETag 是对象的 MD5 哈希值。 ETag 仅反映对象内容的更改，而不反映其元数据的更改。
**ObjectKey**
与触发管道的源更改相关的 Amazon S3 对象键的名称。
**VersionId**
与触发管道的源更改相关的对象版本的版本 ID。
## 服务角色权限：S3 源操作
对于 S3 源操作支持，将以下内容添加到策略语句中：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::[[S3Bucket]]",
"arn:aws:s3:::[[S3Bucket]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
## 操作声明
------
#### [ YAML ]
```
Name: Source
Actions:
- RunOrder: 1
OutputArtifacts:
- Name: SourceArtifact
ActionTypeId:
Provider: S3
Owner: AWS
Version: '1'
Category: Source
Region: us-west-2
Name: Source
Configuration:
S3Bucket: amzn-s3-demo-source-bucket
S3ObjectKey: my-application.zip
PollForSourceChanges: 'false'
InputArtifacts: []
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"RunOrder": 1,
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"ActionTypeId": {
"Provider": "S3",
"Owner": "AWS",
"Version": "1",
"Category": "Source"
},
"Region": "us-west-2",
"Name": "Source",
"Configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"S3ObjectKey": "my-application.zip",
"PollForSourceChanges": "false"
},
"InputArtifacts": []
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)— 本教程提供了示例应用程序规范文件以及示例 CodeDeploy应用程序和部署组。使用本教程可创建具有 Amazon S3 源的管道，用于向 Amazon EC2 实例进行部署。
# AWS AppConfig 部署操作参考
AWS AppConfig 的能力是 AWS Systems Manager。 AppConfig 支持对任何规模的应用程序进行受控部署，并包括内置的验证检查和监控。您可以 AppConfig 与 Amazon EC2 实例上托管的应用程序 AWS Lambda、容器、移动应用程序或物联网设备一起使用。
`AppConfig`部署 AWS CodePipeline 操作是一种将存储在管道源位置的配置部署到指定的 AppConfig *应用程序*、*环境*和*配置*文件中的操作。它使用 AppConfig *部署策略*中定义的首选项。
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`AppConfig`
+ 版本：`1`
## 配置参数
**应用程序**
是否必需：是
AWS AppConfig 应用程序的 ID，其中包含您的配置和部署的详细信息。
**环境**
是否必需：是
部署配置的 AWS AppConfig 环境的 ID。
**ConfigurationProfile**
是否必需：是
要部署的 AWS AppConfig 配置文件的 ID。
**InputArtifactConfigurationPath**
是否必需：是
要部署的输入构件中的配置数据的文件路径。
**DeploymentStrategy**
必需：否
用于 AWS AppConfig 部署的部署策略。
## 输入构件
+ **构件数：**`1`
+ **描述：**部署操作的输入构件。
## 输出构件
不适用。
## 服务角色权限：`AppConfig` 操作
CodePipeline 运行操作时， CodePipeline 服务角色策略需要以下权限，这些权限的范围适当地缩小到资源级别，以便以最低权限保持访问权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appconfig:StartDeployment",
"appconfig:StopDeployment",
"appconfig:GetDeployment"
],
"Resource": [
"arn:aws:appconfig:*:111122223333:application/[[Application]]",
"arn:aws:appconfig:*:111122223333:application/[[Application]]/*",
"arn:aws:appconfig:*:111122223333:deploymentstrategy/*"
],
"Effect": "Allow"
}
]
}
```
------
## 操作配置示例
------
#### [ YAML ]
```
name: Deploy
actions:
- name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: AppConfig
version: '1'
runOrder: 1
configuration:
Application: 2s2qv57
ConfigurationProfile: PvjrpU
DeploymentStrategy: frqt7ir
Environment: 9tm27yd
InputArtifactConfigurationPath: /
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-west-2
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actions": [
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "AppConfig",
"version": "1"
},
"runOrder": 1,
"configuration": {
"Application": "2s2qv57",
"ConfigurationProfile": "PvjrpU",
"DeploymentStrategy": "frqt7ir",
"Environment": "9tm27yd",
"InputArtifactConfigurationPath": "/"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-west-2",
"namespace": "DeployVariables"
}
]
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS AppConfig](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig.html)— 有关 AWS AppConfig 部署的信息，请参阅《*AWS Systems Manager 用户指南》*。
+ [教程：创建 AWS AppConfig 用作部署提供者的管道](tutorials-AppConfig.md)— 本教程将帮助您开始设置简单的部署配置文件和 AppConfig 资源，并向您展示如何使用控制台创建带有 AWS AppConfig 部署操作的管道。
# CloudFormation 部署操作参考
在 CloudFormation 堆栈上执行操作。堆栈是您可以作为一个单元管理的 AWS 资源集合。堆栈中的资源均由堆栈的 CloudFormation 模板定义。更改集会创建比较，您可以查看比较而不会更改原始堆栈。有关可以对堆栈和更改集执行的 CloudFormation 操作类型的信息，请参阅`ActionMode`参数。
要为堆栈操作失败的 CloudFormation 操作构造错误消息， CodePipeline 请调用 CloudFormation `DescribeStackEvents` API。如果操作 IAM 角色有权访问该 API，则有关第一个失败资源的详细信息将包含在 CodePipeline 错误消息中。否则，如果角色策略没有相应的权限，则 CodePipeline 会忽略访问该 API，而是显示一条通用的错误消息。为此，必须将 `cloudformation:DescribeStackEvents` 权限添加到管道的服务角色或其他 IAM 角色中。
如果您不希望资源详细信息出现在管道错误消息中，可以通过删除 `cloudformation:DescribeStackEvents` 权限为操作 IAM 角色撤销此权限。
**Topics**
+ [操作类型](#action-reference-CloudFormation-type)
+ [配置参数](#action-reference-CloudFormation-config)
+ [输入构件](#action-reference-CloudFormation-input)
+ [输出构件](#action-reference-CloudFormation-output)
+ [输出变量](#action-reference-CloudFormation-variables)
+ [服务角色权限： CloudFormation 操作](#edit-role-cloudformation)
+ [操作声明](#action-reference-CloudFormation-example)
+ [另请参阅](#action-reference-CloudFormation-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`CloudFormation`
+ 版本：`1`
## 配置参数
**ActionMode**
是否必需：是
`ActionMode`是对堆栈或更改集 CloudFormation 执行的操作的名称。提供以下操作模式：
+ `CHANGE_SET_EXECUTE` 会基于一组指定资源更新执行资源堆栈的更改集。通过此操作， CloudFormation 开始更改堆栈。
+ `CHANGE_SET_REPLACE` 根据您提交的堆栈名称和模板创建更改集（如果更改集不存在）。如果更改集存在，则将其 CloudFormation 删除，然后创建一个新的变更集。
+ `CREATE_UPDATE` 会在堆栈不存在时创建堆栈。如果堆栈存在，则 CloudFormation 更新堆栈。使用此操作更新现有堆栈。不同的是`REPLACE_ON_FAILURE`，如果堆栈存在且处于故障状态，则 CodePipeline 不会删除和替换堆栈。
+ `DELETE_ONLY` 删除堆栈。如果您指定的堆栈不存在，操作将成功完成，而不会删除堆栈。
+ `REPLACE_ON_FAILURE` 会在堆栈不存在时创建堆栈。如果堆栈存在且处于失败状态，则 CloudFormation 删除该堆栈，然后创建一个新堆栈。如果堆栈未处于故障状态，则对其 CloudFormation 进行更新。
CloudFormation中显示以下任意状态类型时，堆栈处于故障状态：
+ `ROLLBACK_FAILED`
+ `CREATE_FAILED`
+ `DELETE_FAILED`
+ `UPDATE_ROLLBACK_FAILED`
使用自操作可自动替换出现故障的堆栈，而无需对其进行恢复或故障排除。
**重要**
我们建议您仅将 `REPLACE_ON_FAILURE` 用于测试目的，因为它可能会删除您的堆栈。
**StackName**
是否必需：是
`StackName` 是现有堆栈的名称或要创建的堆栈的名称。
**功能**
必需：条件
使用 `Capabilities` 即确认此模板可能具备创建和更新一些资源的功能，并且这些功能由模板资源的类型决定。
如果您的堆栈模板中有 IAM 资源或者您直接从包含宏的模板创建堆栈，则此属性是必需的。为了使 CloudFormation 操作以这种方式成功运行，您必须明确确认您希望它使用以下功能之一执行操作：
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
+ `CAPABILITY_AUTO_EXPAND`
您可以通过在功能之间添加逗号（无空格）的方式指定多个功能。[操作声明](#action-reference-CloudFormation-example)中的示例显示了同时具有 CAPABILITY\$1IAM 和 CAPABILITY\$1AUTO\$1EXPAND 属性的条目。
有关更多信息`Capabilities`，请参阅《*AWS CloudFormation API 参考*》[UpdateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html)中下方的属性。
**ChangeSetName**
必需：条件
`ChangeSetName` 是现有更改集的名称或要为指定堆栈创建的新更改集的名称。
以下操作模式需要此属性：CHANGE\$1SET\$1REPLACE 和 CHANGE\$1SET\$1EXECUTE。对于所有其他操作模式，将忽略此属性。
**RoleArn**
必需：条件
`RoleArn` 是 CloudFormation 在对指定堆栈中的资源执行操作时代入的 IAM 服务角色的 ARN。在执行更改集时，`RoleArn` 不适用。如果您不使用创建 CodePipeline 更改集，请确保更改集或堆栈具有关联的角色。
按照操作声明 `RoleArn` 中的配置，此角色必须与正在运行的操作的角色位于同一个账户。
以下操作模式需要此属性：
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ DELETE\$1ONLY
+ CHANGE\$1SET\$1REPLACE
CloudFormation 将获得模板的 S3 签名 URL；因此，这`RoleArn`不需要访问工件存储桶的权限。但是，为了生成签名 URL，操作 `RoleArn` *确实* 需要用于访问构件桶的权限。
**TemplatePath**
必需：条件
`TemplatePath`表示 CloudFormation 模板文件。您需在针对此操作的输入构件中包含该文件。文件名称遵循以下格式：
`Artifactname::TemplateFileName`
`Artifactname` 是输入构件在 CodePipeline 中显示的名称。例如，源阶段利用构件名称 `SourceArtifact` 和文件名 `template-export.json` 创建 `TemplatePath` 名称，如以下示例所示：
```
"TemplatePath": "SourceArtifact::template-export.json"
```
以下操作模式需要此属性：
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ CHANGE\$1SET\$1REPLACE
对于所有其他操作模式，将忽略此属性。
包含 CloudFormation 模板正文的模板文件的最小长度为 1 字节，最大长度为 1 MB。对于中的 CloudFormation 部署操作 CodePipeline，最大输入项目大小始终为 256 MB。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)和 [CloudFormation 限制](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html)。
**OutputFileName**
必需：否
`OutputFileName`用于指定输出文件名，例如`CreateStackOutput.json`，该文件名 CodePipeline 将添加到该操作的管道输出对象中。JSON 文件包含 CloudFormation 堆栈中该`Outputs`部分的内容。
如果不指定名称，则 CodePipeline 不会生成输出文件或工件。
**ParameterOverrides**
必需：否
参数在堆栈模板中定义，并允许您在堆栈创建或更新时为这些参数提供值。您可以使用 JSON 对象设置模板中的参数值。（这些值会覆盖在模板配置文件中设置的值。） 有关使用参数覆盖的更多信息，请参阅[配置属性（JSON 对象）](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html#w4363ab1c13c13b9)。
对于大多数参数值，建议您使用模板配置文件。仅对在管道运行前未知的值使用参数覆盖。有关更多信息，请参阅《*AWS CloudFormation 用户指南》*中的在[ CodePipeline 管道中使用参数覆盖函数](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html)。
所有参数名称必须位于堆栈模板中。
**TemplateConfiguration**
必需：否
`TemplateConfiguration` 是模板配置文件。您需在针对此操作的输入构件中包含该文件。它可包含模板参数值和堆栈策略。有关模板配置文件格式的更多信息，请参阅 [AWS CloudFormation 构件](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)。
模板配置文件名遵循以下格式：
`Artifactname::TemplateConfigurationFileName`
`Artifactname` 是输入构件在 CodePipeline 中显示的名称。例如，源阶段利用构件名称 `SourceArtifact` 和文件名 `test-configuration.json` 创建 `TemplateConfiguration` 名称，如以下示例所示：
```
"TemplateConfiguration": "SourceArtifact::test-configuration.json"
```
## 输入构件
+ **构件数：**`0 to 10`
+ **描述：**作为输入，该 CloudFormation 操作可以选择接受用于以下目的的构件：
+ 提供要执行的堆栈模板文件。（请参阅 `TemplatePath` 参数。）
+ 提供要使用的模板配置文件。（请参阅 `TemplateConfiguration` 参数。） 有关模板配置文件格式的更多信息，请参阅 [AWS CloudFormation 构件](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)。
+ 为要作为堆栈一部分部署的 Lambda 函数提供构件。 CloudFormation
## 输出构件
+ **构件数：**`0 to 1`
+ **描述：**如果指定了 `OutputFileName` 参数，则此操作生成输出构件，其中包含具有指定名称的 JSON 文件。JSON 文件包含来自 CloudFormation 堆栈的输出部分中的内容。
有关您可为 CloudFormation 操作创建的输出部分的更多信息，请参阅[输出](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
对于 CloudFormation 操作，变量由堆栈模板`Outputs`部分中指定的任何值生成。请注意，生成输出的唯一 CloudFormation操作模式是那些导致创建或更新堆栈的操作模式，例如堆栈创建、堆栈更新和更改集执行。生成变量的相应操作模式包括：
+ `CHANGE_SET_EXECUTE`
+ `CHANGE_SET_REPLACE`
+ `CREATE_UPDATE`
+ `REPLACE_ON_FAILURE`
有关更多信息，请参阅 [变量参考](reference-variables.md)。有关介绍如何在使用 CloudFormation输出变量的管道中使用 CloudFormation 部署操作创建管道的教程，请参阅[教程：创建使用 AWS CloudFormation 部署操作中的变量的管道](tutorials-cloudformation-action.md)。
## 服务角色权限： CloudFormation 操作
CodePipeline 运行操作时， CodePipeline 服务角色策略需要以下权限，这些权限的范围适当地缩小到管道资源 ARN，以便以最低权限保持访问权限。例如，将以下内容添加到策略语句中：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCFNStackAccess",
"Effect": "Allow",
"Action": [
"cloudformation:CreateStack",
"cloudformation:UpdateStack",
"cloudformation:DeleteStack",
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackResources",
"cloudformation:DescribeStackEvents",
"cloudformation:GetTemplate",
"cloudformation:DescribeChangeSet",
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:ExecuteChangeSet"
],
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/[[cfnDeployStackNames]]/*"
]
},
{
"Sid": "ValidateTemplate",
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "AllowIAMPassRole",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/[[cfnExecutionRoles]]"
],
"Condition": {
"StringEqualsIfExists": {
"iam:PassedToService": [
"cloudformation.amazonaws.com"
]
}
}
}
]
}
```
------
请注意，该 `cloudformation:DescribeStackEvents` 权限是可选的。它允许 CloudFormation 操作显示更详细的错误消息。如果您不希望资源详细信息出现在管道错误消息中，可以撤销 IAM 角色的此权限。
## 操作声明
------
#### [ YAML ]
```
Name: ExecuteChangeSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormation
Version: '1'
RunOrder: 2
Configuration:
ActionMode: CHANGE_SET_EXECUTE
Capabilities: CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
ChangeSetName: pipeline-changeset
ParameterOverrides: '{"ProjectId": "my-project","CodeDeployRole": "CodeDeploy_Role_ARN"}'
RoleArn: CloudFormation_Role_ARN
StackName: my-project--lambda
TemplateConfiguration: 'my-project--BuildArtifact::template-configuration.json'
TemplatePath: 'my-project--BuildArtifact::template-export.yml'
OutputArtifacts: []
InputArtifacts:
- Name: my-project-BuildArtifact
```
------
#### [ JSON ]
```
{
"Name": "ExecuteChangeSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormation",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ActionMode": "CHANGE_SET_EXECUTE",
"Capabilities": "CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND",
"ChangeSetName": "pipeline-changeset",
"ParameterOverrides": "{\"ProjectId\": \"my-project\",\"CodeDeployRole\": \"CodeDeploy_Role_ARN\"}",
"RoleArn": "CloudFormation_Role_ARN",
"StackName": "my-project--lambda",
"TemplateConfiguration": "my-project--BuildArtifact::template-configuration.json",
"TemplatePath": "my-project--BuildArtifact::template-export.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-project-BuildArtifact"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [配置属性参考](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html) —《*AWS CloudFormation 用户指南*》中的本参考章节提供了有关这些 CodePipeline 参数的更多描述和示例。
+ [AWS CloudFormation API 参考](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/) — *AWS CloudFormation API 参考*中的[CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)参数描述了 CloudFormation 模板的堆栈参数。
# CloudFormation StackSets 部署操作参考
CodePipeline 提供了在 CI/CD 流程中执行 CloudFormation StackSets 操作的能力。您可以使用堆栈集通过单个 CloudFormation 模板在跨 AWS 区域的 AWS 账户中创建堆栈。每个堆栈中包含的所有资源均由堆栈集的 CloudFormation 模板定义。在创建堆栈集时，您可指定要使用的模板以及模板所需的任何参数和功能。
有关概念的更多信息 CloudFormation StackSets，请参阅《*AWS CloudFormation 用户指南*》中的[StackSets 概念](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html)。
您可以 CloudFormation StackSets 通过两种不同的操作类型将您的管道与之集成，这两种操作类型可以一起使用：
+ `CloudFormationStackSet` 操作会通过存储在管道源位置的模板，创建或更新堆栈集或堆栈实例。每次创建或更新堆栈集时，它都会开始向指定的实例部署这些更改。在控制台中，您可以在创建或编辑管道时选择 **CloudFormation Stack Set** 操作提供者。
+ `CloudFormationStackInstances` 操作会将 `CloudFormationStackSet` 操作的更改部署到指定的实例，创建新的堆栈实例，并定义对指定实例的参数覆盖。在控制台中，编辑现有管道时，您可以选择**CloudFormation 堆栈实例**操作提供者。
您可以使用这些操作部署到目标 AWS 客户或目标 Organizati AWS ons 组织单位 IDs。
**注意**
要部署到目标 AWS Organizations 账户或组织单位 IDs 并使用服务管理权限模型，必须启用 AWS CloudFormation StackSets 和 AWS 组织之间的可信访问权限。有关更多信息，请参阅使用[AWS CloudFormation 堆栈集启用可信访问](https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-cloudformation.html#integrate-enable-ta-cloudformation)。
**Topics**
+ [CloudFormation StackSets 动作是如何运作的](#action-reference-StackSets-concepts)
+ [如何在管道中构造 StackSets 操作](#action-reference-StackSets-bestpractices)
+ [`CloudFormationStackSet` 操作](#action-reference-StackSet)
+ [动 CloudFormationStackInstances 作](#action-reference-StackInstances)
+ [服务角色权限：`CloudFormationStackSet` 操作](#edit-role-cfn-stackset)
+ [服务角色权限：`CloudFormationStackInstances` 操作](#edit-role-cfn-stackinstances)
+ [堆栈集操作的权限模型](#action-reference-StackSets-permissions)
+ [模板参数数据类型](#action-reference-StackSets-datatypes)
+ [另请参阅](#action-reference-CloudFormation-links)
## CloudFormation StackSets 动作是如何运作的
`CloudFormationStackSet` 操作会根据操作是否是首次运行，创建或更新资源。
`CloudFormationStackSet` 操作会*创建* 或*更新* 堆栈集，并将这些更改部署到指定的实例。
**注意**
如果您使用此操作进行更新，包括添加堆栈实例，则会先部署新实例，最后完成更新。新实例会先收到旧版本，然后更新将应用于所有实例。
+ *创建*：如果未指定实例且堆栈集不存在，则该**CloudFormationStackSet**操作将创建堆栈集而不创建任何实例。
+ *更新*：对已创建的堆栈集运行**CloudFormationStackSet**操作时，该操作会更新堆栈集。如果不指定实例且堆栈集已存在，则会更新所有实例。如果使用此操作来更新特定实例，则所有剩余的实例都将变为已过时状态。
您可以使用该**CloudFormationStackSet**操作通过以下方式更新堆栈集。
+ 更新部分或全部实例上的模板。
+ 更新部分或全部实例上的参数。
+ 更新堆栈集的执行角色（这必须与管理员角色中指定的执行角色相匹配）。
+ 更改权限模型（仅在未创建实例的情况下）。
+ 启用/禁用 `AutoDeployment`（如果堆栈集权限模型为 `Service Managed`）。
+ 如果堆栈集权限模型为 `Service Managed`，则在成员账户中充当委派管理员。
+ 更新管理员角色。
+ 更新堆栈集的描述。
+ 将部署目标添加到堆栈集更新中，以便创建新的堆栈实例。
`CloudFormationStackInstances` 操作会创建新的堆栈实例或更新已过时的堆栈实例。更新堆栈集后，实例将变为过时状态，但并非其中的所有实例都会更新。
+ *创建*：如果堆栈已经存在，则 `CloudFormationStackInstances` 操作仅更新实例，不会创建堆栈实例。
+ *更新*：执行 `CloudFormationStackSet` 操作后，如果仅部分实例中更新了模板或参数，则其余实例将被标记为 `OUTDATED`。在随后的管道阶段中，`CloudFormationStackInstances` 会分批更新堆栈集中的其余实例，从而将所有实例标记为 `CURRENT`。此操作还可用于在新实例或现有实例上添加其他实例或覆盖参数。
作为更新的一部分，`CloudFormationStackSet` 和 `CloudFormationStackInstances` 操作可以指定新的部署目标，从而创建新的堆栈实例。
作为更新的一部分，`CloudFormationStackSet` 和 `CloudFormationStackInstances` 操作不会删除堆栈集、实例或资源。当操作更新堆栈但不指定更新所有实例时，将从更新中移除未指定进行更新的实例，并将其设置为 `OUTDATED` 状态。
在部署期间，如果实例部署失败，则堆栈实例也可能显示 `OUTDATED` 状态。
## 如何在管道中构造 StackSets 操作
作为最佳实践，您应对管道进行构建，以便创建堆栈集并且先向子集或单个实例进行部署。在测试您的部署并查看所生成的堆栈集后，再添加 `CloudFormationStackInstances` 操作以创建和更新剩余的实例。
使用控制台或 CLI 创建所建议的管道结构，如下所示：
1. 创建具有源操作（必需）和 `CloudFormationStackSet` 操作（作为部署操作）的管道。运行您的管道。
1. 当您的管道首次运行时，`CloudFormationStackSet` 操作会*创建* 您的堆栈集和至少一个初始实例。验证是否创建堆栈集，检查是否向您的初始实例进行部署。例如，为账户 Account-A 创建初始堆栈集，其中 `us-east-1` 为指定的区域，将会使用堆栈集创建以下堆栈实例：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/action-reference-StackSets.html)
1. 编辑您的管道，将其`CloudFormationStackInstances`作为第二个部署操作添加到您指定目标的 create/update 堆栈实例中。例如，为账户 `Account-A` 创建堆栈实例，其中指定 `us-east-2` 和 `eu-central-1` 区域，将会创建剩余的堆栈实例，并且初始实例仍会进行更新，如下所示：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/action-reference-StackSets.html)
1. 根据需要运行管道以更新您的堆栈集，并更新或创建堆栈实例。
在已经从操作配置中移除部署目标的情况下，当您启动堆栈更新时，未指定进行更新的堆栈实例将从部署中移除，并且变为已过时状态。例如，为账户 `Account-A` 更新堆栈实例，其中 `us-east-2` 区域从操作配置中移除，则会创建剩余的堆栈实例，并将移除的实例设置为已过时，如下所示：
****
| 堆栈实例 | Region | Status |
| --- | --- | --- |
| StackInstanceID-1 | us-east-1 | CURRENT |
| StackInstanceID-2 | us-east-2 | OUTDATED |
| StackInstanceID-3 | eu-central-1 | CURRENT |
有关部署堆栈集的最佳实践的更多信息，请参阅*《AWS CloudFormation 用户指南》 StackSets *中的[最佳实践](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html)。
## `CloudFormationStackSet` 操作
此操作会通过存储在管道源位置的模板，创建或更新堆栈集。
在定义堆栈集后，您可以在配置参数中指定的目标账户和区域，创建、更新或删除堆栈。在创建、更新或删除堆栈时，您可以指定其他首选项，如执行操作的区域顺序、容错百分比（超过之后会导致堆栈操作停止），以及在其中对堆栈并行执行操作的账户的数量。
堆栈集是一种区域性资源。如果您在一个 AWS 区域中创建堆栈集，则无法从其他区域访问该堆栈集。
当此操作用作对堆栈集的更新操作时，如果不部署到至少一个堆栈实例，则不允许对堆栈进行更新。
**Topics**
+ [操作类型](#action-reference-StackSet-type)
+ [配置参数](#action-reference-StackSet-config)
+ [输入构件](#action-reference-StackSet-input)
+ [输出构件](#action-reference-StackSet-output)
+ [输出变量](#action-reference-StackSet-variables)
+ [**CloudFormationStackSet**操作配置示例](#action-reference-StackSet-example)
### 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`CloudFormationStackSet`
+ 版本：`1`
### 配置参数
**StackSetName**
是否必需：是
要与堆栈集关联的名称。此名称在创建它的区域中必须唯一。
名称中只能包含字母数字字符和连字符。它必须以字母字符开头，且不得超过 128 个字符。
**说明**
必需：否
堆栈集的描述。您可以使用它来描述堆栈集的用途或其他相关信息。
**TemplatePath**
是否必需：是
定义堆栈集中资源的模板的位置。这必须指向最大大小为 460,800 字节的模板。
按照格式 `"InputArtifactName::TemplateFileName"` 输入源构件名称和模板文件的路径，如以下示例所示。
```
SourceArtifact::template.txt
```
**参数**
必需：否
部署期间会进行更新的堆栈集模板参数的列表。
您可以通过文本列表或文件路径的形式提供参数：
+ 您可以使用以下简写语法格式输入参数：`ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string`。有关这些数据类型的更多信息，请参阅[模板参数数据类型](#action-reference-StackSets-datatypes)。
下面的示例显示了一个名为 `BucketName` 的参数，其值为 `amzn-s3-demo-source-bucket`。
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
以下示例显示了一个具有多个参数的条目：
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ 您可以按照 `"InputArtifactName::ParametersFileName"` 格式，输入包含模板参数覆盖列表的文件的位置，如以下示例所示。
```
SourceArtifact::parameters.txt
```
以下示例显示 `parameters.txt` 的文件内容。
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
**功能**
必需：否
表示模板可以创建和更新资源，具体取决于模板中的资源类型。
如果您的堆栈模板中有 IAM 资源或者您直接从包含宏的模板创建堆栈，则必须使用此属性。要使 CloudFormation 操作以这种方式成功运行，必须使用以下功能之一：
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
您可以使用逗号指定多项功能，各项功能之间不留空格。[**CloudFormationStackSet**操作配置示例](#action-reference-StackSet-example)中的示例展示了一个具有多项功能的条目。
**PermissionModel**
必需：否
确定如何创建和管理 IAM 角色。如果未指定该字段，则使用默认值。有关信息，请参阅[堆栈集操作的权限模型](#action-reference-StackSets-permissions)。
有效值为：
+ `SELF_MANAGED`（默认）：您必须创建管理员角色和执行角色才能向目标账户进行部署。
+ `SERVICE_MANAGED`： CloudFormation StackSets 自动创建部署到 Organizations 管理的账户所需的 AWS IAM 角色。这要求账户必须是组织的成员。
只有当堆栈集中不存在任何堆栈实例时，才能更改此参数。
****AdministrationRoleArn****
由于跨多个账户 CloudFormation StackSets 执行操作，因此必须先在这些账户中定义必要的权限，然后才能创建堆栈集。
必需：否
此参数对于 SELF\$1MANAGED 权限模型来说是可选的，不用于 SERVICE\$1MANAGED 权限模型。
管理员账户中用于执行堆栈集操作的 IAM 角色的 ARN。
名称中可以包含字母数字字符，以及以下任意字符：\$1\$1=,.@-，不能含有空格。名称不区分大小写。此角色名称的最小长度必须为 20 个字符，最大长度为 2048 个字符。角色名称在账户中必须是唯一的。此处指定的角色名称必须是现有的角色名称。如果不指定角色名称，则它将被设置为 AWSCloudFormationStackSetAdministrationRole。如果指定 ServiceManaged，则不得定义角色名称。
****ExecutionRoleName****
由于跨多个账户 CloudFormation StackSets 执行操作，因此必须先在这些账户中定义必要的权限，然后才能创建堆栈集。
必需：否
对于 SELF\$1MANAGED 权限模型，此参数为可选参数，而对于 SERVICE\$1MANAGED 权限模型，则不使用此参数。
目标账户中用于执行堆栈集操作的 IAM 角色的名称。名称中可以包含字母数字字符，以及以下任意字符：\$1\$1=,.@-，不能含有空格。名称不区分大小写。此角色名称的最小长度必须为 1 个字符，最大长度为 64 个字符。角色名称在账户中必须是唯一的。此处指定的角色名称必须是现有的角色名称。如果要使用自定义执行角色，请不要指定此角色。如果不指定角色名称，则它将被设置为 `AWSCloudFormationStackSetExecutionRole`。如果将 Service\$1Managed 设置为 true，则不得定义角色名称。
****OrganizationsAutoDeployment****
必需：否
对于 SERVICE\$1MANAGED 权限模型，此参数为可选参数，而对于 SELF\$1MANAGED 权限模型，则不使用此参数。
描述是否 CloudFormation StackSets 自动部署到已添加到目标 AWS 组织或组织单位 (OU) 的 Organizations 帐户。如果指定 `OrganizationsAutoDeployment`，则请勿指定 `DeploymentTargets` 和 `Regions`。
如果不为 `OrganizationsAutoDeployment` 提供输入，则默认值为 `Disabled`。
有效值为：
+ `Enabled`。必需：否。
StackSets 自动将其他堆栈实例部署到指定区域的目标 AWS 组织或组织单位 (OU) 的 Organizations 账户。如果账户已从目标组织或 OU 中移除，则会从指定区域的账户中 CloudFormation StackSets 删除堆栈实例。
+ `Disabled`。必需：否。
StackSets 不会自动将其他堆栈实例部署到指定区域的目标 AWS 组织或组织单位 (OU) 的 Organizations 账户。
+ `EnabledWithStackRetention`。必需：否。
从目标组织或 OU 中移除账户时，会保留堆栈资源。
****DeploymentTargets****
必需：否
对于 SERVICE\$1MANAGED 权限模型，您可以 IDs 为部署目标提供组织根 ID 或组织单位。对于 SELF\$1MANAGED 权限模型，您只能提供账户。
选择此参数后，还必须选择**区域**。
应 IDs 在其中创建/更新堆栈集实例的 AWS 账户或组织单位列表。
+ **Accounts**：
您可以通过文本列表或文件路径的形式提供账户：
+ *文本*：使用简写语法格式 `account_ID,account_ID` 输入参数，如以下示例所示。
```
111111222222,333333444444
```
+ *文件路径：*文件的位置，其中包含应在其中创建/更新堆栈集实例的 AWS 账户列表，格式为。`InputArtifactName::AccountsFileName`如果您使用文件路径来指定**账户**或 **OrganizationalUnitIds**，则文件格式必须采用 JSON 格式，如以下示例所示。
```
SourceArtifact::accounts.txt
```
以下示例显示 `accounts.txt` 的文件内容。
```
[
"111111222222"
]
```
以下示例显示了列出多个账户时 `accounts.txt` 的文件内容：
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**注意**
对于 SERVICE\$1MANAGED 权限模型，此参数为可选参数，而对于 SELF\$1MANAGED 权限模型，则不使用此参数。如果您选择，请不要使用此选项**OrganizationsAutoDeployment**。
更新关联堆栈实例的 AWS 组织单位。
您可以以文字列表或文件路径的 IDs 形式提供组织单位：
+ *文本*：输入用逗号分隔的字符串数组，如以下示例所示。
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *文件路径：*文件的位置，其中包含要 OrganizationalUnitIds 在其中创建或更新堆栈集实例的列表。如果您使用文件路径来指定**账户**或 **OrganizationalUnitIds**，则文件格式必须采用 JSON 格式，如以下示例所示。
按照 `InputArtifactName::OrganizationalUnitIdsFileName` 格式输入文件路径。
```
SourceArtifact::OU-IDs.txt
```
以下示例显示 `OU-IDs.txt` 的文件内容：
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****区域****
必需：否
选择此参数后，还必须选择**DeploymentTargets**。
创建或更新堆栈集实例的 AWS 区域列表。区域将按照输入顺序进行更新。
按照以下示例所示的格式`Region1,Region2`输入有效 AWS 区域列表。
```
us-west-2,us-east-1
```
****FailureTolerancePercentage****
必需：否
在该区域 CloudFormation 停止该堆栈操作之前，每个区域中该堆栈操作可能失败的账户百分比。如果操作在某个区域中停止，则 CloudFormation 不会在后续区域中尝试该操作。根据指定的百分比计算账户数量时，*向下 CloudFormation *舍入到下一个整数。
****MaxConcurrentPercentage****
必需：否
一次执行此操作的账户数的最大百分比。根据指定的百分比计算账户数量时，*向下 CloudFormation *舍入到下一个整数。如果向下舍入结果为零，则改为将数字 CloudFormation 设置为一。尽管您使用此设置来指定*最大值*，但对于大型部署，并行执行的实际账户的数量可能会因服务节流而减少。
**RegionConcurrencyType**
必需：否
您可以通过配置区域并发部署参数，指定堆栈集应该按照顺序方式还是并行方式跨 AWS 区域 进行部署。如果将区域并发性指定为 AWS 区域 并行部署多个堆栈，则可以缩短总体部署时间。
+ *并行*：只要区域的部署失败次数不超过指定的容错值，就会同时执行堆栈集部署。
+ *顺序*：只要区域的部署失败次数不超过指定的容错值，就会一次执行一个堆栈集部署。顺序部署是默认选项。
**ConcurrencyMode**
必需：否
并发模式允许您选择并发级别在堆栈集操作期间的行为方式，无论是严格容错还是软容错。**严格容错**会降低堆栈集操作失败时的部署速度，因为每次失败都会降低并发数。S@@ **oft Fail** ure Tolerance 优先考虑部署速度，同时仍能利用 CloudFormation 安全功能。
+ `STRICT_FAILURE_TOLERANCE`：此选项可动态降低并发级别，确保失败账户的数量永远不会超过特定的容错值。这是默认行为。
+ `SOFT_FAILURE_TOLERANCE`：此选项将容错与实际并发数分离。这允许堆栈集操作在一个设定的并发级别上运行，而不管失败次数是多少。
**CallAs**
必需：否
对于 `SERVICE_MANAGED` 权限模型，此参数为可选参数，而对于 `SELF_MANAGED` 权限模型，则不使用此参数。
指定您是在组织的管理账户中充当账户管理员还是在成员账户中充当委派管理员。
如果此参数设置为 `DELEGATED_ADMIN`，请确保管道 IAM 角色具有 `organizations:ListDelegatedAdministrators` 权限。否则，操作将在运行时失败，并出现类似以下内容的错误：`Account used is not a delegated administrator`。
+ `SELF`：在登录到管理账户时，堆栈集部署将使用服务托管式权限。
+ `DELEGATED_ADMIN`：在登录到委派管理员账户时，堆栈集部署将使用服务托管式权限。
### 输入构件
您必须至少包括一个输入构件，其中包含 `CloudFormationStackSet` 操作中堆栈集的模板。对于部署目标、账户和参数列表，您可以包含更多输入构件。
+ **构件数：**`1 to 3`
+ **描述：**您可以包含构件以提供：
+ 堆栈模板文件。（请参阅 `TemplatePath` 参数。）
+ 参数文件。（请参阅 `Parameters` 参数。）
+ 账户文件。（请参阅 `DeploymentTargets` 参数。）
### 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
### 输出变量
如果配置此操作，它会生成一些变量，可供管道中下游操作的操作配置引用。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
+ **StackSetId**: 堆栈集的 ID。
+ **OperationId**: 堆栈集操作的 ID。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
### **CloudFormationStackSet**操作配置示例
以下示例显示了操作的**CloudFormationStackSet**操作配置。
#### 自行管理权限模型的示例
以下示例显示了输入的部署目标为 AWS 账户 ID 的**CloudFormationStackSet**操作。
------
#### [ YAML ]
```
Name: CreateStackSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
DeploymentTargets: '111111222222'
FailureTolerancePercentage: '20'
MaxConcurrentPercentage: '25'
PermissionModel: SELF_MANAGED
Regions: us-east-1
StackSetName: my-stackset
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "CreateStackSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"DeploymentTargets": "111111222222",
"FailureTolerancePercentage": "20",
"MaxConcurrentPercentage": "25",
"PermissionModel": "SELF_MANAGED",
"Regions": "us-east-1",
"StackSetName": "my-stackset",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
```
------
#### 服务管理权限模型的示例
以下示例显示了服务托管权限模型的**CloudFormationStackSet**操作，其中启用了自动部署到 Organizations AWS 的选项，同时保留堆栈。
------
#### [ YAML ]
```
Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
Capabilities: 'CAPABILITY_IAM,CAPABILITY_NAMED_IAM'
OrganizationsAutoDeployment: EnabledWithStackRetention
PermissionModel: SERVICE_MANAGED
StackSetName: stacks-orgs
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"Capabilities": "CAPABILITY_IAM,CAPABILITY_NAMED_IAM",
"OrganizationsAutoDeployment": "EnabledWithStackRetention",
"PermissionModel": "SERVICE_MANAGED",
"StackSetName": "stacks-orgs",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1",
"Namespace": "DeployVariables"
}
```
------
## 动 CloudFormationStackInstances 作
此操作会创建新实例并将堆栈集部署到指定的实例。堆栈实例 是对区域内的目标账户中的堆栈的引用。堆栈实例可在没有堆栈的情况下存在；例如，如果堆栈创建不成功，则堆栈实例将显示堆栈创建失败的原因。一个堆栈实例仅与一个堆栈集关联。
初始创建堆栈集后，您可以使用 `CloudFormationStackInstances` 添加新的堆栈实例。创建或更新堆栈集实例操作期间，可以在堆栈实例级别覆盖模板参数值。
每个堆栈集都有一个模板和一组模板参数。更新模板或模板参数时，您应对整个堆栈集更新它们。然后，所有实例状态都将被设置为 `OUTDATED`，直到将更改部署到该实例为止。
要覆盖特定实例上的参数值，例如，如果模板包含一个值为 `prod` 的 `stage` 参数，则可以将该参数的值覆盖为 `beta` 或 `gamma`。
**Topics**
+ [操作类型](#action-reference-StackInstances-type)
+ [配置参数](#action-reference-StackInstances-config)
+ [输入构件](#action-reference-StackInstances-input)
+ [输出构件](#action-reference-StackInstances-output)
+ [输出变量](#action-reference-StackInstances-variables)
+ [操作配置示例](#action-reference-StackInstances-example)
### 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`CloudFormationStackInstances`
+ 版本：`1`
### 配置参数
**StackSetName**
是否必需：是
要与堆栈集关联的名称。此名称在创建它的区域中必须唯一。
名称中只能包含字母数字字符和连字符。它必须以字母字符开头，且不得超过 128 个字符。
****DeploymentTargets****
必需：否
对于 SERVICE\$1MANAGED 权限模型，您可以 IDs 为部署目标提供组织根 ID 或组织单位。对于 SELF\$1MANAGED 权限模型，您只能提供账户。
选择此参数后，还必须选择**区域**。
应 IDs 在其中创建/更新堆栈集实例的 AWS 账户或组织单位列表。
+ **Accounts**：
您可以通过文本列表或文件路径的形式提供账户：
+ *文本*：使用简写语法格式 `account_ID,account_ID` 输入参数，如以下示例所示。
```
111111222222,333333444444
```
+ *文件路径：*文件的位置，其中包含应在其中创建/更新堆栈集实例的 AWS 账户列表，格式为。`InputArtifactName::AccountsFileName`如果您使用文件路径来指定**账户**或 **OrganizationalUnitIds**，则文件格式必须采用 JSON 格式，如以下示例所示。
```
SourceArtifact::accounts.txt
```
以下示例显示 `accounts.txt` 的文件内容：
```
[
"111111222222"
]
```
以下示例显示了列出多个账户时 `accounts.txt` 的文件内容：
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**注意**
对于 SERVICE\$1MANAGED 权限模型，此参数为可选参数，而对于 SELF\$1MANAGED 权限模型，则不使用此参数。如果您选择，请不要使用此选项**OrganizationsAutoDeployment**。
更新关联堆栈实例的 AWS 组织单位。
您可以以文字列表或文件路径的 IDs 形式提供组织单位。
+ *文本*：输入用逗号分隔的字符串数组，如以下示例所示。
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *文件路径：*文件的位置，其中包含要 OrganizationalUnitIds 在其中创建或更新堆栈集实例的列表。如果您使用文件路径来指定**账户**或 **OrganizationalUnitIds**，则文件格式必须采用 JSON 格式，如以下示例所示。
按照 `InputArtifactName::OrganizationalUnitIdsFileName` 格式输入文件路径。
```
SourceArtifact::OU-IDs.txt
```
以下示例显示 `OU-IDs.txt` 的文件内容：
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****区域****
是否必需：是
选择此参数后，还必须选择**DeploymentTargets**。
创建或更新堆栈集实例的 AWS 区域列表。区域将按照输入顺序进行更新。
以:的格式输入有效 AWS 区域列表`Region1,Region2`，如以下示例所示。
```
us-west-2,us-east-1
```
**ParameterOverrides**
必需：否
要在所选堆栈实例中覆盖的堆栈集参数的列表。被覆盖的参数值会应用于指定账户和区域中的所有堆栈实例。
您可以通过文本列表或文件路径的形式提供参数：
+ 您可以使用以下简写语法格式输入参数：`ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string`。有关这些数据类型的更多信息，请参阅[模板参数数据类型](#action-reference-StackSets-datatypes)。
下面的示例显示了一个名为 `BucketName` 的参数，其值为 `amzn-s3-demo-source-bucket`。
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
以下示例显示了一个具有多个参数的条目。
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ 您可以按照 `InputArtifactName::ParameterOverridessFileName` 格式，输入包含模板参数覆盖列表的文件的位置，如以下示例所示。
```
SourceArtifact::parameter-overrides.txt
```
以下示例显示 `parameter-overrides.txt` 的文件内容。
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
****FailureTolerancePercentage****
必需：否
在该区域 CloudFormation 停止该堆栈操作之前，每个区域中该堆栈操作可能失败的账户百分比。如果操作在某个区域中停止，则 CloudFormation 不会在后续区域中尝试该操作。根据指定的百分比计算账户数量时，*向下 CloudFormation *舍入到下一个整数。
****MaxConcurrentPercentage****
必需：否
一次执行此操作的账户数的最大百分比。根据指定的百分比计算账户数量时，*向下 CloudFormation *舍入到下一个整数。如果向下舍入结果为零，则改为将数字 CloudFormation 设置为一。尽管您指定*最大值*，但对于大型部署，并行执行的实际账户的数量可能会因服务节流而减少。
**RegionConcurrencyType**
必需：否
您可以通过配置区域并发部署参数，指定堆栈集应该按照顺序方式还是并行方式跨 AWS 区域 进行部署。如果将区域并发性指定为 AWS 区域 并行部署多个堆栈，则可以缩短总体部署时间。
+ *并行*：只要区域的部署失败次数不超过指定的容错值，就会同时执行堆栈集部署。
+ *顺序*：只要区域的部署失败次数不超过指定的容错值，就会一次执行一个堆栈集部署。顺序部署是默认选项。
**ConcurrencyMode**
必需：否
并发模式允许您选择并发级别在堆栈集操作期间的行为方式，无论是严格容错还是软容错。**严格容错**会降低堆栈集操作失败时的部署速度，因为每次失败都会降低并发数。S@@ **oft Fail** ure Tolerance 优先考虑部署速度，同时仍能利用 CloudFormation 安全功能。
+ `STRICT_FAILURE_TOLERANCE`：此选项可动态降低并发级别，确保失败账户的数量永远不会超过特定的容错值。这是默认行为。
+ `SOFT_FAILURE_TOLERANCE`：此选项将容错与实际并发数分离。这允许堆栈集操作在一个设定的并发级别上运行，而不管失败次数是多少。
**CallAs**
必需：否
对于 `SERVICE_MANAGED` 权限模型，此参数为可选参数，而对于 `SELF_MANAGED` 权限模型，则不使用此参数。
指定您是在组织的管理账户中充当账户管理员还是在成员账户中充当委派管理员。
如果此参数设置为 `DELEGATED_ADMIN`，请确保管道 IAM 角色具有 `organizations:ListDelegatedAdministrators` 权限。否则，操作将在运行时失败，并出现类似以下内容的错误：`Account used is not a delegated administrator`。
+ `SELF`：在登录到管理账户时，堆栈集部署将使用服务托管式权限。
+ `DELEGATED_ADMIN`：在登录到委派管理员账户时，堆栈集部署将使用服务托管式权限。
### 输入构件
`CloudFormationStackInstances` 可以包含列出部署目标和参数的构件。
+ **构件数：**`0 to 2`
+ **描述：**作为输入，堆栈集操作可以选择接受构件以用于下列用途：
+ 提供参数文件以供使用。（请参阅 `ParameterOverrides` 参数。）
+ 提供目标账户文件以供使用。（请参阅 `DeploymentTargets` 参数。）
### 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
### 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
+ **StackSetId**: 堆栈集的 ID。
+ **OperationId**: 堆栈集操作的 ID。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
### 操作配置示例
以下示例显示了操作的**CloudFormationStackInstances**操作配置。
#### 自行管理权限模型的示例
以下示例显示了一个**CloudFormationStackInstances**操作，其中输入的部署目标是 AWS 账户 ID `111111222222`。
------
#### [ YAML ]
```
Name: my-instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: '111111222222'
Regions: 'us-east-1,us-east-2,us-west-1,us-west-2'
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "my-instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "111111222222",
"Regions": "us-east-1,us-east-2,us-west-1,us-west-2",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
}
```
------
#### 服务管理权限模型的示例
以下示例显示了服务管理权限模型的**CloudFormationStackInstances**操作，其中部署目标是 Organizations AWS 组织单位 ID `ou-1111-1example`。
------
#### [ YAML ]
```
Name: Instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: ou-1111-1example
Regions: us-east-1
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
```
------
#### [ JSON ]
```
{
"Name": "Instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "ou-1111-1example",
"Regions": "us-east-1",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1"
}
```
------
## 服务角色权限：`CloudFormationStackSet` 操作
对于 CloudFormation StackSets 操作，需要以下最低权限。
对于 `CloudFormationStackSet` 操作，请将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackSet",
"cloudformation:UpdateStackSet",
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation",
"cloudformation:DescribeStackSet",
"cloudformation:ListStackInstances"
],
"Resource": "resource_ARN"
},
```
## 服务角色权限：`CloudFormationStackInstances` 操作
对于 `CloudFormationStackInstances` 操作，请将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation"
],
"Resource": "resource_ARN"
},
```
## 堆栈集操作的权限模型
由于跨多个账户 CloudFormation StackSets 执行操作，因此必须先在这些账户中定义必要的权限，然后才能创建堆栈集。您可以通过自管理权限或服务管理权限来定义权限。
使用自我管理权限，您可以创建所需的两个 IAM 角色：一个是管理员角色，例如定义堆栈集的账户 AWSCloudFormationStackSetAdministrationRole 中的，另一个是执行角色，例如部署堆栈集实例的每个账户 AWSCloudFormationStackSetExecutionRole 中的。 StackSets 使用此权限模型， StackSets 可以部署到用户有权创建 IAM 角色的任何 AWS 账户。有关更多信息，请参阅 *AWS CloudFormation 用户指南* 中的[创建自管理权限](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html)。
**注意**
由于跨多个账户 CloudFormation StackSets 执行操作，因此必须先在这些账户中定义必要的权限，然后才能创建堆栈集。
借助服务管理权限，您可以将堆栈实例部署到由 Organizations 管理的账户 AWS 。使用此权限模型，您无需创建必要的 IAM 角色，因为您可以代表您 StackSets 创建 IAM 角色。使用此模型，您还可以启用向将来添加到组织的账户自动部署的功能。请参阅《*AWS CloudFormation 用户指南》*中的 “[通过 Org AWS anizations 启用可信访问](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-enable-trusted-access.html)”。
## 模板参数数据类型
堆栈集操作中使用的模板参数包括以下数据类型。有关更多信息，请参阅 [DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html)。
ParameterKey
+ 描述：与参数关联的键。如果您没有为特定参数指定键和值，则 AWS CloudFormation 使用模板中指定的默认值。
+ 示例：
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
ParameterValue
+ 描述：与参数关联的输入值。
+ 示例：
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
UsePreviousValue
+ 在堆栈更新期间，使用堆栈对给定参数键使用的现有参数值。如果指定 `true`，请勿指定参数值。
+ 示例：
```
"ParameterKey=Asset1,UsePreviousValue=true"
```
每个堆栈集都有一个模板和一组模板参数。更新模板或模板参数时，您应对整个堆栈集更新它们。然后，所有实例状态都将被设置为 OUTDATED，直到将更改部署到该实例为止。
要覆盖特定实例上的参数值，例如，如果模板包含一个值为 `prod` 的 `stage` 参数，则可以将该参数的值覆盖为 `beta` 或 `gamma`。
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [参数类型](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#parameters-section-structure-properties-type) —《*AWS CloudFormation 用户指南》*中的本参考章节提供了 CloudFormation 模板参数的更多描述和示例。
+ 最佳实践：有关部署堆栈集的最佳实践的更多信息，请参阅 *AWS CloudFormation 用户指南* 中的 [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html)。
+ [AWS CloudFormation API 参考](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/) — 您可以参考 *AWS CloudFormation API 参考*中的以下 CloudFormation 操作，了解有关堆栈集操作中使用的参数的更多信息：
+ 该[CreateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackSet.html)操作会创建堆栈集。
+ 该[UpdateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html)操作更新指定账户和区域中的堆栈集和关联堆栈实例。即使通过更新堆栈集创建的堆栈集操作失败（完全失败或部分失败，低于或高于指定的容错值），也会使用这些更改来更新堆栈集。对指定堆栈集的后续 CreateStackInstances 调用使用更新的堆栈集。
+ 该[CreateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackInstances.html)操作在自行管理的权限模型上为所有指定账户中的所有指定区域创建堆栈实例，或者在服务管理的权限模型上为所有指定部署目标中的所有指定区域创建堆栈实例。您可以覆盖通过此操作创建的实例的参数。如果实例已经存在，则使用相同的输入参数 UpdateStackInstances 进行 CreateStackInstances 调用。当您使用此操作创建实例时，不会更改其他堆栈实例的状态。
+ 该[UpdateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackInstances.html)操作使堆栈实例与在自管理权限模型上所有指定账户中的所有指定区域或服务托管权限模型上的所有指定部署目标内的所有指定部署目标中的堆栈集保持同步。您可以覆盖通过此操作更新的实例的参数。当您使用此操作更新实例子集时，不会更改其他堆栈实例的状态。
+ 该[DescribeStackSetOperation](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSetOperation.html)操作返回指定堆栈集操作的描述。
+ 该[DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSet.html)操作返回指定堆栈集的描述。
# AWS CodeBuild 生成和测试操作参考
允许您将构建和测试作为管道的一部分来运行。运行 CodeBuild 生成或测试操作时，buildspec 中指定的命令将在 CodeBuild 容器内运行。所有被指定为 CodeBuild 操作输入工件的工件都可以在运行命令的容器中找到。 CodeBuild 可以提供生成或测试操作。有关更多信息，请参阅 [AWS CodeBuild 《用户指南》](https://docs.aws.amazon.com/codebuild/latest/userguide/)。
当您在控制台中使用 CodePipeline 向导创建构建项目时， CodeBuild 生成项目会显示源提供者是 CodePipeline。在 CodeBuild控制台中创建构建项目时，您无法指定 CodePipeline 为源代码提供者，但是向管道中添加生成操作会调整 CodeBuild 控制台中的源代码。有关更多信息，请参阅《AWS CodeBuild API Reference》**中的 [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html)。
**Topics**
+ [操作类型](#action-reference-CodeBuild-type)
+ [配置参数](#action-reference-CodeBuild-config)
+ [输入构件](#action-reference-CodeBuild-input)
+ [输出构件](#action-reference-CodeBuild-output)
+ [输出变量](#action-reference-CodeBuild-variables)
+ [服务角色权限： CodeBuild 操作](#edit-role-codebuild)
+ [操作声明（CodeBuild 示例）](#action-reference-CodeBuild-example)
+ [另请参阅](#action-reference-CodeBuild-links)
## 操作类型
+ 类别：`Build` 或 `Test`
+ 拥有者：`AWS`
+ 提供方：`CodeBuild`
+ 版本：`1`
## 配置参数
**ProjectName**
是否必需：是
`ProjectName`是中构建项目的名称 CodeBuild。
**PrimarySource**
必需：条件
`PrimarySource`参数的值必须是操作的其中一个输入项目的名称。 CodeBuild 查找 buildspec 文件并在包含此工件解压缩版本的目录中运行 buildspec 命令。
如果为一个 CodeBuild 操作指定了多个输入构件，则此参数是必需的。当操作仅有一个源构件时，`PrimarySource` 构件默认为该构件。
**BatchEnabled**
必需：否
`BatchEnabled` 参数的布尔值允许操作在同一个构建执行中运行多个构建。
启用此选项后，`CombineArtifacts` 选项将变为可用。
有关启用批量构建的管道示例，请参阅[CodePipeline 集成 CodeBuild 和批量构建](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-batch.html)。
**BuildspecOverride**
必需：否
内联 buildspec 定义或覆盖构建项目中定义的最新声明的 buildspec 文件声明（仅限此构建）。在项目中定义的 buildspec 保持不变。
如果此值已设置，则可能是以下任意一种：
+ 内联 buildspec 定义。有关更多信息，请参阅 [Buildspec 语法](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-syntax)中的语法参考。
+ 指向相对于内置 `CODEBUILD_SRC_DIR` 环境变量的值的替代 buildspec 文件的路径，或者是指向 S3 存储桶的路径。存储桶必须与构建项目位于同一 AWS 区域 中。使用其 ARN 指定 buildspec 文件（例如，`arn:aws:s3:::my-codebuild-sample2/buildspec.yml`）。如果此值未提供或设置为空字符串，源代码必须在其根目录中包含 buildspec 文件。有关添加路径的更多信息，请参阅 [Buildspec 文件名和存储位置](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-name-storage)。
由于此属性允许您更改将在容器中运行的构建命令，因此您应该注意，能够调用此 API 并设置此参数的 IAM 主体可以覆盖默认设置。此外，我们鼓励您使用值得信赖的 buildspec 位置，例如源存储库或 Amazon S3 存储桶中的文件。
**CombineArtifacts**
必需：否
`CombineArtifacts` 参数的布尔值将来自一个批量构建的所有构建构件合并为单个构件文件，将其用于构建操作。
要使用此选项，必须启用 `BatchEnabled` 参数。
**EnvironmentVariables**
必需：否
此参数的值用于为管道中的 CodeBuild 操作设置环境变量。`EnvironmentVariables` 参数的值采用环境变量对象的 JSON 数组形式。请参阅[操作声明（CodeBuild 示例）](#action-reference-CodeBuild-example)中的示例参数。
每个对象有三个均为字符串的部分：
+ `name`：环境变量的名称或键。
+ `value`：环境变量的值。使用`PARAMETER_STORE`或`SECRETS_MANAGER`类型时，此值必须分别是您已经存储在 Sy AWS stems Manager 参数存储中的参数的名称或已经存储在 Secrets Manager 中的 AWS 密钥。
**注意**
我们强烈不鼓励使用环境变量来存储敏感值，尤其是 AWS 证书。使用 CodeBuild 控制台或 AWS CLI 时，环境变量将以纯文本形式显示。对于敏感值，我们建议您改用 `SECRETS_MANAGER` 类型。
+ `type`：（可选）环境变量的类型。有效值为 `PARAMETER_STORE`、`SECRETS_MANAGER` 或 `PLAINTEXT`。如果未指定，则此值默认为 `PLAINTEXT`。
`type`为环境变量配置输入`name``value`、和时，尤其是在环境变量包含 CodePipeline 输出变量语法的情况下，请不要超过配置值字段的 1000 个字符限制。如果超过此限制，将会返回验证错误。
有关更多信息，请参阅 AWS CodeBuild API 参考[ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)中的。有关带有可解析为 GitHub 分支名称的环境变量的 CodeBuild 操作示例，请参阅[示例：使用带有 CodeBuild 环境 BranchName 变量的变量](actions-variables.md#actions-variables-examples-env-branchname)。
## 输入构件
+ **构件数：**`1 to 5`
+ **描述：查** CodeBuild 找 buildspec 文件并从主源构件的目录中运行 buildspec 命令。如果指定了单个输入源，或者为操作指定了多个输入源，则必须使用中的 CodeBuild `PrimarySource`操作配置参数来设置单个对象或主对象（如果是多个输入源） CodePipeline。
各个输入构件会解压缩到各自的目录，其位置存储在环境变量中。主源构件的目录通过 `$CODEBUILD_SRC_DIR` 提供。所有其他输入构件的目录通过 `$CODEBUILD_SRC_DIR_yourInputArtifactName` 提供。
**注意**
在 CodeBuild 项目中配置的构件将成为管道中 CodeBuild 操作使用的输入构件。
## 输出构件
+ **构件数：**`0 to 5`
+ **描述：**它们可用于使在 CodeBuild buildspec 文件中定义的工件可供管道中的后续操作使用。在仅定义了一个输出构件时，此构件可以直接在 buildspec 文件的 `artifacts` 部分下定义。在指定了多个输出构件时，引用的所有构件都必须在 buildspec 文件中定义为辅助构件。中的输出工件名称 CodePipeline 必须与 buildspec 文件中的工件标识符匹配。
**注意**
在 CodeBuild 项目中配置的构件将成为管道操作中的 CodePipeline 输入构件。
如果为批量构建选择了 `CombineArtifacts` 参数，则输出构件位置将包含在同一执行中运行的多个构建的合并构件。
## 输出变量
此操作将生成在构建中导出的所有环境变量作为变量。有关如何导出环境变量的更多详细信息，请参阅 *AWS CodeBuild API 指南[ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)*中的。
有关在中使用 CodeBuild 环境变量的更多信息 CodePipeline，请参阅中的示例[CodeBuild 操作输出变量](reference-variables.md#reference-variables-list-configured-codebuild)。有关可在中使用的环境变量的列表 CodeBuild，请参阅《*AWS CodeBuild 用户指南》*[中的构建环境中的环境变量](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html)。
## 服务角色权限： CodeBuild 操作
如需 CodeBuild 支持，请在您的政策声明中添加以下内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"codebuild:BatchGetBuilds",
"codebuild:StartBuild",
"codebuild:BatchGetBuildBatches",
"codebuild:StartBuildBatch"
],
"Resource": [
"arn:aws:codebuild:*:111122223333:project/[[ProjectName]]"
],
"Effect": "Allow"
}
]
}
```
------
## 操作声明（CodeBuild 示例）
------
#### [ YAML ]
```
Name: Build
Actions:
- Name: PackageExport
ActionTypeId:
Category: Build
Owner: AWS
Provider: CodeBuild
Version: '1'
RunOrder: 1
Configuration:
BatchEnabled: 'true'
CombineArtifacts: 'true'
ProjectName: my-build-project
PrimarySource: MyApplicationSource1
EnvironmentVariables: '[{"name":"TEST_VARIABLE","value":"TEST_VALUE","type":"PLAINTEXT"},{"name":"ParamStoreTest","value":"PARAMETER_NAME","type":"PARAMETER_STORE"}]'
OutputArtifacts:
- Name: MyPipeline-BuildArtifact
InputArtifacts:
- Name: MyApplicationSource1
- Name: MyApplicationSource2
```
------
#### [ JSON ]
```
{
"Name": "Build",
"Actions": [
{
"Name": "PackageExport",
"ActionTypeId": {
"Category": "Build",
"Owner": "AWS",
"Provider": "CodeBuild",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BatchEnabled": "true",
"CombineArtifacts": "true",
"ProjectName": "my-build-project",
"PrimarySource": "MyApplicationSource1",
"EnvironmentVariables": "[{\"name\":\"TEST_VARIABLE\",\"value\":\"TEST_VALUE\",\"type\":\"PLAINTEXT\"},{\"name\":\"ParamStoreTest\",\"value\":\"PARAMETER_NAME\",\"type\":\"PARAMETER_STORE\"}]"
},
"OutputArtifacts": [
{
"Name": "MyPipeline-BuildArtifact"
}
],
"InputArtifacts": [
{
"Name": "MyApplicationSource1"
},
{
"Name": "MyApplicationSource2"
}
]
}
]
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS CodeBuild 用户指南](https://docs.aws.amazon.com/codebuild/latest/userguide/)-有关带有 CodeBuild 操作的管道示例，请参阅[ CodePipeline 与一起使用 CodeBuild 来测试代码和运行构建](https://docs.aws.amazon.com/codebuild/latest/userguide/how-to-create-pipeline.html)。有关具有多个输入和输出 CodeBuild 构件的项目的示例，请参阅[与 CodeBuild 多个输入源CodePipeline集成和输出构件示例](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-multi-input-output.html)以及[多个输入源和输出构件示例](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html)。
+ [教程：创建用于构建和测试您的 Android 应用程序的管道 AWS Device Farm](tutorials-codebuild-devicefarm.md)— 本教程提供了一个示例 buildspec 文件和示例应用程序，用于创建管道，其中包含使用和构建和测试 Android 应用程序的 GitHub CodeBuild 源代码。 AWS Device Farm
+ 的@@ [编译规范参考 CodeBuild — 本参考主题提供了用于](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)理解 b CodeBuild uildspec 文件的定义和示例。有关可在中使用的环境变量的列表 CodeBuild，请参阅《*AWS CodeBuild 用户指南》*[中的构建环境中的环境变量](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html)。
# AWS CodePipeline 调用操作参考
您可以使用 CodePipeline invoke 操作来简化触发下游管道执行以及在管道之间传递管道变量和源版本的过程。
**注意**
此操作仅支持 V2 类型管道。
**Topics**
+ [操作类型](#action-reference-PipelineInvoke-type)
+ [配置参数](#action-reference-PipelineInvoke-parameters)
+ [输入构件](#action-reference-PipelineInvoke-input)
+ [输出构件](#action-reference-PipelineInvoke-output)
+ [CodePipeline 调用操作的服务角色策略权限](#action-reference-PipelineInvoke-permissions-action)
+ [操作声明](#action-reference-PipelineInvoke-example)
+ [另请参阅](#action-reference-PipelineInvoke-links)
## 操作类型
+ 类别：`Invoke`
+ 拥有者：`AWS`
+ 提供方：`CodePipeline`
+ 版本：`1`
## 配置参数
**PipelineName**
是否必需：是
运行后将启动当前目标管道的管道的名称。您必须已创建一个调用管道。当名为 `s3-pipeline-test`（调用）的管道开始执行时，该操作将启动 `my-s3-pipeline`（目标）管道。
**SourceRevisions**
必需：否
当调用管道启动目标管道时，您希望目标管道使用的源修订。例如，S3 源操作提供输出变量，例如 S3 版本 ID 和对象密钥。您可以指定调用管道时要使用的修订值。
对于 CLI，您可以将源修订指定为序列化的 JSON 字符串。有关使用源版本覆盖的更多信息，请参阅 *CodePipeline API 指南[SourceRevisionOverride](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_SourceRevisionOverride.html)*中的。
映射使用下方示例中所示的字符串格式。
```
[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]
```
**变量**
必需：否
您希望操作支持的变量的名称和值。
对于 CLI，您可以将变量指定为序列化的 JSON 字符串。有关使用管道变量的更多信息，请参阅 *CodePipeline API 指南[PipelineVariable](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineVariable.html)*中的。
映射使用下方示例中所示的字符串格式。
```
[{"name":"VAR1","value":"VALUE1"}]
```
下图显示了添加到控制台中管道的操作示例。
![\[具有 S3 源和包含管道调用操作的构建阶段的管道\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/example-pipeline-invoke-run.png)
下图显示了操作的**编辑**页面示例。在以下示例中，名为 `s3-pipeline-test` 的管道为控制台配置了如下所示的管道调用操作。当名为 `s3-pipeline-test` 的管道完成执行后，该操作将启动 `my-s3-pipeline` 管道。该示例显示了使用指定修订值为 `zq8mjNYEexample` 的 S3\$1OBJECT\$1VERSION\$1ID 源覆盖的源修订覆盖。
![\[包含管道调用操作的新管道的编辑操作页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/example-pipeline-invoke-edit.png)
## 输入构件
+ **构件数：**`0`
+ **描述：**输入构件不适用于此操作类型。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## CodePipeline 调用操作的服务角色策略权限
CodePipeline 运行操作时， CodePipeline 服务角色策略需要权限，该`codepipeline:StartPipelineExecution`权限的范围适当地缩小到管道资源 ARN，以便以最小的权限保持访问权限。
```
{
"Sid": "StatementForPipelineInvokeAction",
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": [
"arn:aws:codepipeline:{{region}}:{{AccountId}}:{{pipelineName}}"
]
}
```
## 操作声明
------
#### [ YAML ]
```
name: Invoke-pipeline
actionTypeId:
category: Invoke
owner: AWS
provider: CodePipeline
version: '1'
runOrder: 2
configuration:
PipelineName: my-s3-pipeline
SourceRevisions: '[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]'
Variables: '[{"name":"VAR1","value":"VALUE1"}]'
```
------
#### [ JSON ]
```
{
"name": "Invoke-pipeline",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "CodePipeline",
"version": "1"
},
"runOrder": 2,
"configuration": {
"PipelineName": "my-s3-pipeline",
"SourceRevisions": "[{\"actionName\":\"Source\",\"revisionType\":\"S3_OBJECT_VERSION_ID\",\"revisionValue\":\"zq8mjNEXAMPLE"}]",
"Variables": "[{\"name\":\"VAR1\",\"value\":\"VALUE1\"}]"
}
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [使用源修订覆盖启动管道](pipelines-trigger-source-overrides.md)— 本节介绍手动或通过 EventBridge 事件输入转换器启动带有源代码版本的管道。
# CodeCommit 源操作参考
在配置的 CodeCommit 存储库和分支上进行新提交时启动管道。
如果您使用控制台创建或编辑管道，则 CodePipeline 会创建一条 EventBridge 规则，在存储库发生更改时启动管道。
**注意**
对于 Amazon ECR、Amazon S3 或 CodeCommit 源，您还可以使用输入转换条目创建源替换，以便`revisionValue`在 EventBridge 管道事件中使用 in，其中派生自对象密钥、提交或图像 ID 的源事件变量。`revisionValue`有关更多信息，请参阅[Amazon ECR 源操作和 EventBridge 资源](create-cwe-ecr-source.md)、[连接到启用事件源的 Amazon S3 源操作](create-S3-source-events.md)或[CodeCommit 源操作和 EventBridge](triggering.md)下的流程中包含的输入转换条目的可选步骤。
在通过 CodeCommit 操作连接管道之前，您必须已经创建了 CodeCommit 存储库。
检测到代码更改后，您可以使用以下选项将代码传递给后续操作：
+ **默认**-将 CodeCommit 源操作配置为输出包含提交浅表副本的 ZIP 文件。
+ **完整克隆**：配置源操作，使之输出对仓库的 Git URL 引用，以供后续操作使用。
目前，Git URL 引用只能由下游 CodeBuild 操作用于克隆存储库和关联的 Git 元数据。尝试将 Git URL 引用传递给非CodeBuild 操作会导致错误。
**Topics**
+ [操作类型](#action-reference-CodeCommit-type)
+ [配置参数](#action-reference-CodeCommit-config)
+ [输入构件](#action-reference-CodeCommit-input)
+ [输出构件](#action-reference-CodeCommit-output)
+ [输出变量](#action-reference-CodeCommit-variables)
+ [服务角色权限： CodeCommit 操作](#edit-role-codecommit)
+ [操作配置示例](#action-reference-CodeCommit-example)
+ [另请参阅](#action-reference-CodeCommit-links)
## 操作类型
+ 类别：`Source`
+ 拥有者：`AWS`
+ 提供方：`CodeCommit`
+ 版本：`1`
## 配置参数
**RepositoryName**
是否必需：是
要在其中检测源更改的存储库的名称。
**BranchName**
是否必需：是
要在其中检测源更改的分支的名称。
**PollForSourceChanges**
必需：否
`PollForSourceChanges`控制是否 CodePipeline 轮询 CodeCommit存储库以获取源代码更改。我们建议您改用 “ CloudWatch 事件” 来检测源代码的更改。有关配置 CloudWatch 事件的更多信息，请参阅[迁移轮询管道（CodeCommit 来源）(CLI)](update-change-detection.md#update-change-detection-cli-codecommit)或[迁移轮询管道（CodeCommit 来源）（CloudFormation 模板）](update-change-detection.md#update-change-detection-cfn-codecommit)。
如果要配置 CloudWatch 事件规则，则必须将设置为`PollForSourceChanges``false`以避免重复的管道执行。
此参数的有效值：
+ `true`: 如果已设置，则会 CodePipeline 轮询您的存储库以了解源代码更改。
**注意**
如果省略`PollForSourceChanges`，则 CodePipeline 默认为轮询存储库是否有源更改。如果包括 `PollForSourceChanges` 并将其设置为 `true`，则此行为相同。
+ `false`: 如果已设置，则 CodePipeline 不会轮询您的存储库以了解源代码更改。如果您打算配置 CloudWatch 事件规则以检测源更改，请使用此设置。
****OutputArtifactFormat****
必需：否
输出构件格式。值可以是 `CODEBUILD_CLONE_REF` 或 `CODE_ZIP`。如果未指定，则默认为 `CODE_ZIP`。
`CODEBUILD_CLONE_REF` 选项只能由 CodeBuild 下游操作使用。
如果选择此选项，则需要向您的 CodeBuild 服务角色添加`codecommit:GitPull`权限，如所示[为 CodeCommit 源操作添加 CodeBuild GitClone 权限](troubleshooting.md#codebuild-role-codecommitclone)。您还需要为 CodePipeline服务角色添加`codecommit:GetRepository`权限，如所示[为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。如需查看教程以了解如何使用**完整克隆**选项，请参阅[教程：使用带有 CodeCommit 管道源的完整克隆](tutorials-codecommit-gitclone.md)。
## 输入构件
+ **构件数：**`0`
+ **描述：**输入构件不适用于此操作类型。
## 输出构件
+ **构件数：**`1`
+ **描述：**此操作的输出构件是一个 ZIP 文件，其中包含在提交时，指定作为管道执行的源修订的已配置存储库和分支的内容。从存储库生成的构件是 CodeCommit 操作的输出对象。源代码提交 ID 显示 CodePipeline 为触发管道执行的源修订版。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**CommitId**
触发管道执行的 CodeCommit 提交 ID。提交 IDs 是提交的完整 SHA。
**CommitMessage**
与触发管道执行的提交相关联的描述消息（如果有）。
**RepositoryName**
触发管道的提交所在 CodeCommit 存储库的名称。
**BranchName**
进行源代码更改的 CodeCommit 存储库的分支名称。
**AuthorDate**
授权提交的日期，采用时间戳格式。
**CommitterDate**
进行提交的日期，采用时间戳格式。
## 服务角色权限： CodeCommit 操作
CodePipeline 运行操作时， CodePipeline 服务角色策略需要以下权限，这些权限的范围适当地缩小到管道资源 ARN，以便以最低权限保持访问权限。例如，将以下内容添加到策略语句中：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:CancelUploadArchive",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetRepository",
"codecommit:GetUploadArchiveStatus",
"codecommit:UploadArchive"
],
"Resource": [
"arn:aws:codecommit:*:111122223333:[[codecommitRepostories]]"
]
}
]
}
```
------
## 操作配置示例
### 默认输出构件格式的示例
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: Artifact_MyWebsiteStack
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "Artifact_MyWebsiteStack"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
### 完整克隆输出构件格式的示例
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
OutputArtifactFormat: CODEBUILD_CLONE_REF
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: SourceArtifact
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"OutputArtifactFormat": "CODEBUILD_CLONE_REF",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "SourceArtifact"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)— 本教程提供了示例应用程序规范文件以及示例 CodeDeploy 应用程序和部署组。使用本教程创建具有部署到 Amazon EC2 实例的 CodeCommit 源的管道。
# AWS CodeDeploy 部署操作参考
您可以使用 AWS CodeDeploy 操作将应用程序代码部署到您的部署队列。您的部署实例集可以由 Amazon EC2 实例和/或本地实例组成。
**注意**
本参考主题介绍 CodeDeploy 部署平台为 CodePipeline Amazon EC2 的部署操作。有关中 CodeDeploy blue/green 部署操作的 Amazon 弹性容器服务的参考信息 CodePipeline，请参阅[Amazon 弹性容器服务和 CodeDeploy 蓝绿色部署操作参考](action-reference-ECSbluegreen.md)。
**Topics**
+ [操作类型](#action-reference-CodeDeploy-type)
+ [配置参数](#action-reference-CodeDeploy-config)
+ [输入构件](#action-reference-CodeDeploy-input)
+ [输出构件](#action-reference-CodeDeploy-output)
+ [服务角色权限： AWS CodeDeploy 操作](#edit-role-codedeploy)
+ [操作声明](#action-reference-CodeDeploy-example)
+ [另请参阅](#action-reference-CodeDeploy-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`CodeDeploy`
+ 版本：`1`
## 配置参数
**ApplicationName**
是否必需：是
您在中创建的应用程序的名称 CodeDeploy。
**DeploymentGroupName**
是否必需：是
您在中创建的部署组 CodeDeploy。
## 输入构件
+ **构件数：**`1`
+ **描述：** CodeDeploy 用于确定以下内容的 AppSpec 文件：
+ 通过 Amazon S3 中的应用程序修订版在实例上安装哪些内容或 GitHub。
+ 为响应部署生命周期事件而要运行的生命周期事件挂钩。
有关该 AppSpec 文件的更多信息，请参阅[CodeDeploy AppSpec 文件参考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限： AWS CodeDeploy 操作
如需 AWS CodeDeploy 支持，请在您的政策声明中添加以下内容：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetApplication",
"codedeploy:GetDeployment",
"codedeploy:RegisterApplicationRevision",
"codedeploy:ListDeployments",
"codedeploy:ListDeploymentGroups",
"codedeploy:GetDeploymentGroup"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[codedeployApplications]]",
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[codedeployApplications]]/*"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:[[deploymentConfigs]]"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:ListDeploymentConfigs"
],
"Resource": [
"*"
]
}
]
}
```
------
## 操作声明
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeploy
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
DeploymentGroupName: my-deployment-group
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeploy",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"DeploymentGroupName": "my-deployment-group"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)— 本教程将引导您创建源存储桶、EC2 实例和 CodeDeploy 资源，以部署示例应用程序。然后，您可以使用 CodeDeploy 部署操作来构建您的管道，该操作会将 S3 存储桶中维护的代码部署到您的 Amazon EC2 实例。
+ [教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)— 本教程将引导您创建 CodeCommit 源存储库、EC2 实例和部署示例应用程序 CodeDeploy 所需的资源。然后，您可以使用部署操作来构建管道，该操作将代码从您的 CodeCommit 存储库 CodeDeploy 部署到您的 Amazon EC2 实例。
+ [CodeDeploy AppSpec 文件引用](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) —《*AWS CodeDeploy 用户指南*》中的本参考章节提供了 CodeDeploy AppSpec 文件的参考信息和示例。
# CodeStarSourceConnection 适用于 Bitbucket Cloud GitHub、、 GitHub 企业服务器、 GitLab .com 和 GitLab 自我管理操作
支持连接的源操作 AWS CodeConnections。 CodeConnections 允许您创建和管理 AWS 资源与第三方存储库（例如）之间的连接 GitHub。在第三方源代码存储库上进行新提交时启动管道。当手动执行管道或从源提供程序发送 Webhook 事件时，源操作会检索代码更改。
您可以将管道中的操作配置为使用 Git 配置，以便用触发器启动管道。要配置管道触发器配置以使用触发器进行筛选，请参阅[添加带有代码推送或拉取请求事件类型的触发器](pipelines-filter.md)中的更多详细信息。
**注意**
此功能不适用于亚太地区（香港）、亚太地区（海得拉巴）、亚太地区（雅加达）、亚太地区（墨尔本）、亚太地区（墨尔本）、亚太地区（大阪）、非洲（开普敦）、中东（巴林）、中东（阿联酋）、欧洲（西班牙）、欧洲（苏黎世）、以色列（特拉维夫） AWS GovCloud 或（美国西部）地区。要参考其他可用操作，请参阅 [产品和服务与 CodePipeline](integrations.md)。有关在欧洲地区（米兰）区域使用此操作的注意事项，请参阅[CodeStarSourceConnection 适用于 Bitbucket Cloud GitHub、、 GitHub 企业服务器、 GitLab .com 和 GitLab 自我管理操作](#action-reference-CodestarConnectionSource)中的说明。
Connections 可以将您的 AWS 资源与以下第三方存储库相关联：
+ Bitbucket Cloud（通过 CodePipeline 控制台中的 **Bitbuck** et 提供者选项或 CLI 中的`Bitbucket`提供者）
**注意**
您可以创建到 Bitbucket Cloud 存储库的连接。不支持已安装的 Bitbucket 提供程序类型（如 Bitbucket 服务器）。
+
**注意**
如果您使用的是 Bitbucket 工作区，则必须具有管理员访问权限才能创建连接。
+ GitHub 和 GitHub 企业云（通过 CodePipeline 控制台中的 **GitHub （通过 GitHub应用程序）**提供者选项或 CLI 中的`GitHub`提供商）
**注意**
如果您的仓库位于 GitHub 组织中，则必须是组织所有者才能创建连接。如果使用不位于组织中的存储库，则您必须是存储库拥有者。
+ GitHub 企业服务器（通过 CodePipeline 控制台中的**GitHub 企业服务器**提供者选项或 CLI 中的`GitHub Enterprise Server`提供者）
+ GitLab.com（通过 CodePipeline控制台中的**GitLab**提供者选项或 CLI 中的`GitLab`提供者）
**注意**
您可以创建与拥有**所有者**角色的存储库的连接 GitLab，然后可以将该连接与包含诸如之类的资源的存储库一起使用 CodePipeline。对于群组中的仓库，您无需成为群组拥有者。
+ 自行管理安装 GitLab （企业版或社区版）（通过 CodePipeline控制台中的**GitLab 自我管理**提供商选项或 CLI 中的`GitLabSelfManaged`提供商）
**注意**
每个连接都支持您在该提供方处拥有的所有存储库。您只需为每个提供方类型创建一个新连接。
借助连接，您的管道可以通过第三方提供商的安装应用来检测源更改。例如，webhook 用于订阅 GitHub 事件类型，并且可以安装在组织、存储库或 GitHub 应用程序上。您的连接会在您的 GitHub 应用程序上安装一个订阅 GitHub 推送类型事件的存储库 webhook。
检测到代码更改后，您可以使用以下选项将代码传递给后续操作：
+ 默认：与其他现有 CodePipeline 源操作一样，`CodeStarSourceConnection`可以输出包含提交浅表副本的 ZIP 文件。
+ 完整克隆：也可以对 `CodeStarSourceConnection` 进行配置，以便为后续操作输出对存储库的 URL 引用。
目前，Git URL 引用只能由下游 CodeBuild 操作用于克隆存储库和关联的 Git 元数据。尝试将 Git URL 引用传递给非CodeBuild 操作会导致错误。
CodePipeline 创建 AWS 连接时，会提示您将 Connector 安装应用程序添加到您的第三方帐户。您必须事先创建自己的第三方账户和存储库，然后才能通过 `CodeStarSourceConnection` 操作进行连接。
**注意**
要为您的角色创建或附加一项包含使用 AWS CodeStar 连接所需权限的策略，请参阅[连接权限参考](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections)。根据您的 CodePipeline 服务角色的创建时间，您可能需要更新其权限以支持 AWS CodeStar 连接。有关说明，请参阅[为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。
**注意**
要在欧洲（米兰）使用连接 AWS 区域，您必须：
安装区域特定的应用程序
启用该区域
这一特定于区域的应用程序支持欧洲地区（米兰）区域中的连接。该应用程序在第三方提供商网站上发布，与支持其他区域的连接的现有应用程序是分开的。安装此应用程序，即表示您授权第三方提供商仅与该区域的服务共享您的数据，并且您可以随时通过卸载该应用程序来撤消权限。
除非您启用区域，否则该服务不会处理或存储您的数据。启用此区域，即表示您授予我们的服务处理和存储您的数据的权限。
即使未启用该区域，如果区域特定的应用程序仍保持安装状态，第三方提供商也仍可以与我们的服务共享您的数据，因此，请务必在禁用该区域后立即卸载该应用程序。有关更多信息，请参阅[启用区域](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#rande-manage-enable)。
**Topics**
+ [操作类型](#action-reference-CodestarConnectionSource-type)
+ [配置参数](#action-reference-CodestarConnectionSource-config)
+ [输入构件](#action-reference-CodestarConnectionSource-input)
+ [输出构件](#action-reference-CodestarConnectionSource-output)
+ [输出变量](#action-reference-CodestarConnectionSource-variables)
+ [服务角色权限： CodeConnections 操作](#edit-role-connections)
+ [操作声明](#action-reference-CodestarConnectionSource-example)
+ [安装安装应用并创建连接](#action-reference-CodestarConnectionSource-auth)
+ [另请参阅](#action-reference-CodestarConnectionSource-links)
## 操作类型
+ 类别：`Source`
+ 拥有者：`AWS`
+ 提供方：`CodeStarSourceConnection`
+ 版本：`1`
## 配置参数
****ConnectionArn****
是否必需：是
为源提供程序进行配置和身份验证的连接 ARN。
****FullRepositoryId****
是否必需：是
要在其中检测源更改的存储库的拥有者和名称。
示例：`some-user/my-repo`
您必须保持该**FullRepositoryId**值的正确大小写。例如，如果您的用户名为`some-user`，存储库名称为`My-Repo`，则建议的**FullRepositoryId**值为。`some-user/My-Repo`
****BranchName****
是否必需：是
要在其中检测源更改的分支的名称。
****OutputArtifactFormat****
必需：否
指定输出构件格式。可以是 `CODEBUILD_CLONE_REF` 或 `CODE_ZIP`。如果未指定，则默认为 `CODE_ZIP`。
`CODEBUILD_CLONE_REF` 选项只能由 CodeBuild 下游操作使用。
如果选择此选项，则需要更新 CodeBuild 项目服务角色的权限，如所示[添加连接 Bitbucket、 GitHub、En GitHub terprise Server 或 GitLab .com 的 CodeBuild GitClone 权限](troubleshooting.md#codebuild-role-connections)。如需查看教程以了解如何使用**完整克隆**选项，请参阅[教程：使用带有 GitHub 管道源的完整克隆](tutorials-github-gitclone.md)。
**DetectChanges**
必需：否
指在所配置的存储库和分支上进行新提交时，会自动启动管道的控制设置。如果未指定，则默认值为 `true`，并且默认情况下不显示该字段。此参数的有效值：
+ `true`: 在新提交时 CodePipeline 自动启动您的管道。
+ `false`: CodePipeline 不会在新提交时启动您的管道。
## 输入构件
+ **构件数：**`0`
+ **描述：**输入构件不适用于此操作类型。
## 输出构件
+ **构件数：**`1`
+ **描述：**从存储库生成的构件是 `CodeStarSourceConnection` 操作的输出构件。源代码提交 ID 显示 CodePipeline 为触发管道执行的源修订版。您可以在以下文件中配置此操作的输出构件：
+ ZIP 文件，其中包含在提交时，指定作为管道执行的源修订的已配置存储库和分支的内容。
+ JSON 文件，其中包含存储库的 URL 引用，以便下游操作可以直接执行 Git 命令。
**重要**
此选项只能由 CodeBuild 下游操作使用。
如果选择此选项，则需要更新 CodeBuild 项目服务角色的权限，如所示[故障排除 CodePipeline](troubleshooting.md)。如需查看教程以了解如何使用**完整克隆**选项，请参阅[教程：使用带有 GitHub 管道源的完整克隆](tutorials-github-gitclone.md)。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
AuthorDate
授权提交的日期，采用时间戳格式。
BranchName
进行源更改的 存储库的分支名称。
CommitId
触发管道执行的 提交 ID。
CommitMessage
与触发管道执行的提交相关联的描述消息（如果有）。
ConnectionArn
为源提供程序进行配置和身份验证的连接 ARN。
FullRepositoryName
发出创建触发管道的提交的 存储库名称。
## 服务角色权限： CodeConnections 操作
对于 CodeConnections，需要以下权限才能使用使用连接的源（例如 Bitbucket Cloud）创建管道。
```
{
"Effect": "Allow",
"Action": [
"codeconnections:UseConnection"
],
"Resource": "resource_ARN"
},
```
有关连接的 IAM 权限的更多信息，请参阅[连接权限参考](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections)。
## 操作声明
在以下示例中，对于 ARN 为 `arn:aws:codestar-connections:region:account-id:connection/connection-id` 的连接，输出构件被设置为默认的 `CODE_ZIP` 压缩格式。
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: CodeStarSourceConnection
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ConnectionArn: "arn:aws:codestar-connections:region:account-id:connection/connection-id"
FullRepositoryId: "some-user/my-repo"
BranchName: "main"
OutputArtifactFormat: "CODE_ZIP"
Name: ApplicationSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "CodeStarSourceConnection"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ConnectionArn": "arn:aws:codestar-connections:region:account-id:connection/connection-id",
"FullRepositoryId": "some-user/my-repo",
"BranchName": "main",
"OutputArtifactFormat": "CODE_ZIP"
},
"Name": "ApplicationSource"
}
]
},
```
------
## 安装安装应用并创建连接
首次使用控制台向第三方存储库添加新连接时，必须授予对存储库的 CodePipeline 访问权限。您选择或创建一个安装应用程序，以帮助您连接到创建第三方代码存储库的账户。
使用 AWS CLI 或 CloudFormation 模板时，必须提供已通过安装握手的连接的连接 ARN。否则，不会触发管道。
**注意**
对于 `CodeStarSourceConnection` 源操作，您不必设置 Webhook 或默认进行轮询。连接操作会为您管理更改检测。
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS::CodeStarConnections::Connection](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html)— Connect AWS CodeStar ions 资源的 CloudFormation 模板参考提供了 CloudFormation 模板中连接的参数和示例。
+ [AWS CodeStar连接 API 参考](https://docs.aws.amazon.com/codestar-connections/latest/APIReference/Welcome.html) —《*AWS CodeStar 连接 API 参*考》提供了可用连接操作的参考信息。
+ 要查看使用连接支持的源操作来创建管道的步骤，请参阅以下内容：
+ 对于 Bitbucket Cloud，请使用控制台中的 **Bitbucket** 选项或 CLI 中的 `CodestarSourceConnection` 操作。请参阅[Bitbucket Cloud 连接](connections-bitbucket.md)。
+ 对于 GitHub 和 GitHub 企业云，请使用控制台中的**GitHub**提供者选项或 CLI 中的`CodestarSourceConnection`操作。请参阅[GitHub 连接](connections-github.md)。
+ 对于 GitHub 企业服务器，请使用控制台中的**GitHub 企业服务器**提供者选项或 CLI 中的`CodestarSourceConnection`操作。请参阅[GitHub 企业服务器连接](connections-ghes.md)。
+ 对于 GitLab .com，请使用控制台中的**GitLab**提供者选项或在 CLI 中使用`GitLab`提供程序的`CodestarSourceConnection`操作。请参阅[GitLab.com 连接](connections-gitlab.md)。
+ 要查看使用 Bitbucket 源和 CodeBuild 操作创建管道的入门教程，请参阅[连接入门](https://docs.aws.amazon.com/dtconsole/latest/userguide/getting-started-connections.html)。
+ 有关向您展示如何连接到 GitHub 存储库以及如何使用带有下游 CodeBuild 操作的 “**完全克隆**” 选项的教程，请参阅[教程：使用带有 GitHub 管道源的完整克隆](tutorials-github-gitclone.md)。
# Commands 操作参考
通过 Commands 操作，您可以在虚拟计算实例中运行 Shell 命令。运行操作时，操作配置中指定的命令会在单独的容器中运行。所有被指定为 CodeBuild 操作输入工件的工件都可以在运行命令的容器中找到。此操作允许您指定命令，而无需先创建 CodeBuild 项目。有关更多信息，请参阅《*AWS CodePipeline API 参考*》中的[ActionDeclaration](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionDeclaration.html)和[OutputArtifact](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_OutputArtifact.html)。
**重要**
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。
**注意**
Commands 操作仅适用于 V2 类型管道。
**Topics**
+ [Commands 操作的注意事项](#action-reference-Commands-considerations)
+ [服务角色策略权限](#action-reference-Commands-policy)
+ [操作类型](#action-reference-Commands-type)
+ [配置参数](#action-reference-Commands-config)
+ [输入构件](#action-reference-Commands-input)
+ [输出构件](#action-reference-Commands-output)
+ [环境变量](#action-reference-Commands-envvars)
+ [服务角色权限：Commands 操作](#edit-role-Commands)
+ [操作声明（示例）](#action-reference-Commands-example)
+ [另请参阅](#action-reference-Commands-links)
## Commands 操作的注意事项
Commands 操作的注意事项如下。
+ 命令操作使用与 CodeBuild 操作相似的 CodeBuild 资源，同时允许在虚拟计算实例中使用外壳环境命令，而无需关联或创建构建项目。
**注意**
运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。
+ 由于中的 Commands 操作会占 CodePipeline 用 CodeBuild 资源，因此该操作运行的生成将归因于中账户的生成限制 CodeBuild。Commands 操作运行的构建将计入为该账户配置的并发构建限制。
+ 根据构建，使用 “命令” 操作的 CodeBuild 构建的超时时间为 55 分钟。
+ 计算实例在中使用隔离的构建环境 CodeBuild。
**注意**
由于隔离构建环境是在账户级别使用的，因此一个实例可能会被重复用于另一个管道的执行。
+ 支持除多行格式外的所有格式。输入命令时必须使用单行格式。
+ 跨账户操作支持 Commands 操作。要添加跨账户 Commands 操作，请在操作声明中添加目标账户中的 `actionRoleArn`。
+ 对于此操作， CodePipeline 将担任管道服务角色并使用该角色允许在运行时访问资源。建议配置服务角色，以便将权限范围缩小到操作级别。
+ 中详细介绍了添加到 CodePipeline 服务角色的权限[为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。
+ 在控制台中查看日志所需的权限详见[在控制台中查看计算日志所需的权限](security-iam-permissions-console-logs.md)。
+ 与中的其他操作不同 CodePipeline，您无需在操作配置中设置字段；而是在操作配置之外设置操作配置字段。
## 服务角色策略权限
CodePipeline 运行操作时，使用管道名称 CodePipeline 创建日志组，如下所示。这样就可以使用管道名称缩小日志资源的权限范围。
```
/aws/codepipeline/MyPipelineName
```
如果您使用的是现有的服务角色，要使用 Commands 操作，需要为服务角色添加以下权限。
+ 日志：CreateLogGroup
+ 日志：CreateLogStream
+ 日志：PutLogEvents
在服务角色策略声明中，将权限范围缩小到管道级别，如下例所示。
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
```
要在控制台中使用操作详细信息对话框页面查看日志，必须在控制台角色中添加查看日志的权限。有关更多信息，请参阅[在控制台中查看计算日志所需的权限](security-iam-permissions-console-logs.md)中的控制台权限策略示例。
## 操作类型
+ 类别：`Compute`
+ 拥有者：`AWS`
+ 提供方：`Commands`
+ 版本：`1`
## 配置参数
**命令**
是否必需：是
您可以为要运行的 `Commands` 操作提供 Shell 命令。在控制台中，命令分行输入。在 CLI 中，命令以单独字符串的形式输入。
不支持多行格式，这会导致出现错误消息。在 **Commands** 字段中输入命令时必须使用单行格式。
EnvironmentType 和的 ComputeType 值与中的值相匹配 CodeBuild。我们支持一部分可用类型。有关更多信息，请参阅[构建环境计算类型](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html)。
**EnvironmentType**
必需：否
支持 Commands 操作的构建环境的 OS 映像。以下是构建环境的有效值：
+ LINUX\$1CONTAINER
+ WINDOWS\$1SERVER\$12022\$1CONTAINER
然后，选择**EnvironmentType**将允许在**ComputeType**字段中显示该操作系统的计算类型。有关可用于此操作的 CodeBuild 计算类型的更多信息，请参阅 CodeBuild 用户指南中的[构建环境计算模式和类型](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html)参考。
如果未指定，则构建环境的计算默认设置如下所示：
+ **计算类型：**BUILD\$1 \$1S GENERAL1 MALL
+ **环境类型：**LINUX\$1CONTAINER
**ComputeType**
必需：否
根据对的选择 EnvironmentType，可以提供计算类型。以下是计算的可用值；但请注意，可用选项可能因 OS 而异。
+ BUILD\$1 \$1 GENERAL1 小型
+ BUILD\$1 \$1 GENERAL1 中型
+ 构建 \$1 \$1 GENERAL1 LARGE
某些计算类型与某些环境类型不兼容。例如，WINDOWS\$1SERVER\$12022\$1CONTAINER 与 BUILD\$1 \$1SMALL 不兼容。GENERAL1使用不兼容的组合会导致操作失败并产生运行时错误。
**outputVariables**
必需：否
指定要导出的环境变量名称。有关 CodeBuild 环境变量的参考，请参阅《*CodeBuild 用户指南》*[中的构建环境中的环境变量](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html)。
**文件**
必需：否
您可以提供想要导出的文件，作为操作的输出构件。
支持的文件格式与 CodeBuild 文件模式的支持格式相同。例如，输入 `**/` 表示所有文件。有关更多信息，请参阅《*CodeBuild 用户指南》 CodeBuild*中的[构建规范参考](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.artifacts.files)。
![\[使用 Commands 操作的新管道的编辑操作页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/commands-edit-screen.png)
**VpcId**
必需：否
您的资源的 VPC ID。
**子网**
必需：否
VPC 的子网。当您的命令需要连接到 VPC 中的资源时，需要配置此字段。
**SecurityGroupIds**
必需：否
VPC 的安全组。当您的命令需要连接到 VPC 中的资源时，需要配置此字段。
以下是该操作的 JSON 示例，其中显示了环境和计算类型的配置字段，以及示例环境变量。
```
{
"name": "Commands1",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"commands": [
"ls",
"echo hello",
"echo $BEDROCK_TOKEN",
],
"configuration": {
"EnvironmentType": "LINUX_CONTAINER",
"ComputeType": "BUILD_GENERAL1_MEDIUM"
},
"environmentVariables": [
{
"name": "BEDROCK_TOKEN",
"value": "apiTokens:bedrockToken",
"type": "SECRETS_MANAGER"
}
],
"runOrder": 1
}
```
## 输入构件
+ **构件数：**`1 to 10`
## 输出构件
+ **构件数：**`0 to 1`
## 环境变量
**Key**
键值对环境变量对的键，例如 `BEDROCK_TOKEN`。
**值**
键/值对的值，例如 `apiTokens:bedrockToken`。可以使用管道操作中的输出变量或管道变量来参数化该值。
使用`SECRETS_MANAGER`类型时，此值必须是您已经存储在 Secrets Manager 中的 AWS 密钥的名称。
**Type**
指定环境变量值的使用类型。该值可以是 `PLAINTEXT` 或 `SECRETS_MANAGER`。如果值为 `SECRETS_MANAGER`，则在 `EnvironmentVariable` 值中提供密钥参考。如果未指定，则此值默认为 `PLAINTEXT`。
我们强烈不鼓励使用*纯文本*环境变量来存储敏感值，尤其是证书。 AWS 使用 CodeBuild 控制台或时 AWS CLI，*纯文本*环境变量将以纯文本形式显示。对于敏感值，我们建议您改用 `SECRETS_MANAGER` 类型。
**注意**
`type`为环境变量配置输入`name``value`、和时，尤其是在环境变量包含 CodePipeline 输出变量语法的情况下，请不要超过配置值字段的 1000 个字符限制。如果超过此限制，将会返回验证错误。
有关显示环境变量的操作声明示例，请参阅[配置参数](#action-reference-Commands-config)。
**注意**
只有 Commands 操作支持 `SECRETS_MANAGER` 类型。
Commands 操作中引用的密钥将在构建日志中进行编辑，类似于。 CodeBuild但是，对管道拥有**编辑**权限的管道用户仍然可能通过修改命令来访问这些密钥值。
要使用 SecretsManager，必须向您的管道服务角色添加以下权限：
```
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"SECRET_ARN"
]
}
```
## 服务角色权限：Commands 操作
对于 Commands 支持，将以下内容添加到策略语句中：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:iam::*:role/Service*",
"arn:aws:iam::*:role/Service*"
]
}
]
}
```
------
## 操作声明（示例）
------
#### [ YAML ]
```
name: Commands_action
actionTypeId:
category: Compute
owner: AWS
provider: Commands
version: '1'
runOrder: 1
configuration: {}
commands:
- ls
- echo hello
- 'echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}'
outputArtifacts:
- name: BuildArtifact
files:
- **/
inputArtifacts:
- name: SourceArtifact
outputVariables:
- AWS_DEFAULT_REGION
region: us-east-1
namespace: compute
```
------
#### [ JSON ]
```
{
"name": "Commands_action",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"runOrder": 1,
"configuration": {},
"commands": [
"ls",
"echo hello",
"echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}"
],
"outputArtifacts": [
{
"name": "BuildArtifact",
"files": [
"**/"
]
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"outputVariables": [
"AWS_DEFAULT_REGION"
],
"region": "us-east-1",
"namespace": "compute"
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [教程：创建使用计算运行命令的管道（V2 类型）](tutorials-commands.md) – 本教程提供了一个使用 Commands 操作的管道示例。
# AWS Device Farm 测试操作参考
在您的管道中，您可以配置用于 AWS Device Farm 在设备上运行和测试应用程序的测试操作。Device Farm 使用设备测试池和测试框架在特定设备上测试应用程序。有关 Device Farm 操作支持的测试框架类型的信息，请参阅在 Device [Farm 中 AWS 使用测试类型](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html)。
**Topics**
+ [操作类型](#action-reference-DeviceFarm-type)
+ [配置参数](#action-reference-DeviceFarm-config)
+ [输入构件](#action-reference-DeviceFarm-input)
+ [输出构件](#action-reference-DeviceFarm-output)
+ [服务角色权限： AWS Device Farm 操作](#edit-role-devicefarm)
+ [操作声明](#action-reference-DeviceFarm-example)
+ [另请参阅](#action-reference-DeviceFarm-links)
## 操作类型
+ 类别：`Test`
+ 拥有者：`AWS`
+ 提供方：`DeviceFarm`
+ 版本：`1`
## 配置参数
**AppType**
是否必需：是
您要测试的操作系统和应用程序类型。以下是有效值列表：
+ `iOS`
+ `Android`
+ `Web`
**ProjectId**
是否必需：是
Device Farm 项目 ID。
要查找您的项目 ID，请在 Device Farm 控制台中选择您的项目。在浏览器中，复制新项目的 URL。URL 包含项目 ID。项目 ID 是 URL 中位于 `projects/` 之后的值。在下面的示例中，项目 ID 为 `eec4905f-98f8-40aa-9afc-4c1cfexample`。
```
https:///devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
```
**App**
是否必需：是
您的输入构件中应用程序文件的名称和位置。例如：`s3-ios-test-1.ipa`
**TestSpec**
条件：是
测试规范定义文件在输入构件中的位置。这是自定义模式测试所必需的。
**DevicePoolArn**
是否必需：是
Device Farm 设备池 ARN。
要获取项目的可用设备池 ARNs ，包括热门设备的 ARN，请使用 CL AWS I 输入以下命令：
```
aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
```
**TestType**
是否必需：是
为您的测试指定受支持的测试框架。以下是 `TestType` 的有效值列表：
+ **APPIUM\$1JAVA\$1JUNIT**
+ **APPIUM\$1JAVA\$1TESTNG**
+ **APPIUM\$1NODE**
+ **APPIUM\$1RUBY**
+ **APPIUM\$1PYTHON**
+ **APPIUM\$1WEB\$1JAVA\$1JUNIT**
+ **APPIUM\$1WEB\$1JAVA\$1TESTNG**
+ **APPIUM\$1WEB\$1NODE**
+ **APPIUM\$1WEB\$1RUBY**
+ **APPIUM\$1WEB\$1PYTHON**
+ **BUILTIN\$1FUZZ**
+ **INSTRUMENTATION**
+ **XCTEST**
+ **XCTEST\$1UI**
CodePipeline: `WEB_PERFORMANCE_PROFILE`、`REMOTE_ACCESS_RECORD`和中的操作不支持以下测试类型`REMOTE_ACCESS_REPLAY`。
有关 Device Farm 测试类型的信息，请参阅[使用 AWS Device Farm 中的测试类型](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html)。
**RadioBluetoothEnabled**
必需：否
用于指示是否在测试开始时启用蓝牙的布尔值。
**RecordAppPerformanceData**
必需：否
用于指示是否在测试期间记录设备性能数据（如 CPU、FPS 和内存性能）的布尔值。
**RecordVideo**
必需：否
用于指示是否在测试期间录制视频的布尔值。
**RadioWifiEnabled**
必需：否
用于指示是否在测试开始时启用 Wi-Fi 的布尔值。
**RadioNfcEnabled**
必需：否
用于指示是否在测试开始时启用 NFC 的布尔值。
**RadioGpsEnabled**
必需：否
用于指示是否在测试开始时启用 GPS 的布尔值。
**测试**
必需：否
您的源位置中测试定义文件的名称和路径。路径相对于测试的输入项目的根。
**FuzzEventCount**
必需：否
模糊测试要执行的用户接口事件数，介于 1 到 10,000 之间。
**FuzzEventThrottle**
必需：否
在执行下一个用户接口事件之前，模糊测试等待的毫秒数，介于 1 到 1,000 之间。
**FuzzRandomizerSeed**
必需：否
供模糊测试用来将用户接口事件随机化的种子。对后续模糊测试使用相同的数字会使事件序列相同。
**CustomHostMachineArtifacts**
必需：否
主机上存储自定义构件的位置。
**CustomDeviceArtifacts**
必需：否
设备上存储自定义构件的位置。
**UnmeteredDevicesOnly**
必需：否
用于指示在此步骤中运行测试时是否仅使用非计量设备的布尔值。
**JobTimeoutMinutes**
必需：否
测试在超时前将在每台设备上执行的分钟数。
**纬度**
必需：否
以地理坐标系度数表示的设备的纬度。
**经度**
必需：否
以地理坐标系度数表示的设备的经度。
## 输入构件
+ **构件数：**`1`
+ **描述：**要提供给测试函数使用的一组构件。Device Farm 会查找要使用的已构建应用程序和测试定义。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限： AWS Device Farm 操作
CodePipeline 运行操作时， CodePipeline 服务角色策略需要以下权限，这些权限的范围适当地缩小到管道资源 ARN，以便以最低权限保持访问权限。例如，将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": [
"devicefarm:ListProjects",
"devicefarm:ListDevicePools",
"devicefarm:GetRun",
"devicefarm:GetUpload",
"devicefarm:CreateUpload",
"devicefarm:ScheduleRun"
],
"Resource": "resource_ARN"
},
```
## 操作声明
------
#### [ YAML ]
```
Name: Test
Actions:
- Name: TestDeviceFarm
ActionTypeId: null
category: Test
owner: AWS
provider: DeviceFarm
version: '1'
RunOrder: 1
Configuration:
App: s3-ios-test-1.ipa
AppType: iOS
DevicePoolArn: >-
arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5
ProjectId: eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE
TestType: APPIUM_PYTHON
TestSpec: example-spec.yml
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Test",
"Actions": [
{
"Name": "TestDeviceFarm",
"ActionTypeId": null,
"category": "Test",
"owner": "AWS",
"provider": "DeviceFarm",
"version": "1"
}
],
"RunOrder": 1,
"Configuration": {
"App": "s3-ios-test-1.ipa",
"AppType": "iOS",
"DevicePoolArn": "arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5",
"ProjectId": "eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE",
"TestType": "APPIUM_PYTHON",
"TestSpec": "example-spec.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [使用 Device Farm 中的测试类型](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html)：*Device Farm 开发者指南* 中的本参考章节详细描述了 Device Farm 支持的 Android、iOS 和 Web 应用程序测试框架。
+ [Device Farm 中的操作](https://docs.aws.amazon.com/devicefarm/latest/APIReference/Welcome.html)：*Device Farm API 参考* 中的 API 调用和参数可以帮助您处理 Device Farm 项目。
+ [教程：创建用于构建和测试您的 Android 应用程序的管道 AWS Device Farm](tutorials-codebuild-devicefarm.md)— 本教程提供了示例构建规范文件和示例应用程序，用于创建管道，其 GitHub 源代码用于使用和 Device Farm 构建 CodeBuild 和测试 Android 应用程序。
+ [教程：创建用于测试你的 iOS 应用的管道 AWS Device Farm](tutorials-codebuild-devicefarm-S3.md)：本教程提供了一个示例应用程序，以创建具有 Amazon S3 源的管道，用于通过 Device Farm 测试所构建的一款 iOS 应用。
# Elastic Beanstalk 部署操作参考
Elastic Beanstalk 是一个用于部署和扩展 Web 应用程序的 AWS 平台。您需要使用 Elastic Beanstalk 操作将应用程序代码部署到您的部署环境。
**Topics**
+ [操作类型](#action-reference-Beanstalk-type)
+ [配置参数](#action-reference-Beanstalk-config)
+ [输入构件](#action-reference-Beanstalk-input)
+ [输出构件](#action-reference-Beanstalk-output)
+ [服务角色权限：`ElasticBeanstalk` 部署操作](#edit-role-beanstalk)
+ [操作声明](#action-reference-Beanstalk-example)
+ [另请参阅](#action-reference-Beanstalk-links)
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`ElasticBeanstalk`
+ 版本：`1`
## 配置参数
**ApplicationName**
是否必需：是
您在 Elastic Beanstalk 中创建的应用程序的名称。
**EnvironmentName**
是否必需：是
您在 Elastic Beanstalk 中创建的环境的名称。环境是运行应用程序版本的 AWS 资源集合。每个环境一次只运行一个应用程序版本，但您可以同时在多个环境中运行相同或不同的应用程序版本。
## 输入构件
+ **构件数：**`1`
+ **描述：**操作的输入构件。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限：`ElasticBeanstalk` 部署操作
对于 Elastic Beanstalk，需要以下最低权限才能创建具有 `ElasticBeanstalk` 部署操作的管道。
```
{
"Effect": "Allow",
"Action": [
"elasticbeanstalk:*",
"ec2:*",
"elasticloadbalancing:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*"
],
"Resource": "resource_ARN"
},
```
**注意**
您应将资源策略中的通配符替换为要限制访问的账户资源。有关创建策略以授予最低权限访问权限的更多信息，请参阅 [https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)。
## 操作声明
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ElasticBeanstalk
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
EnvironmentName: my-environment
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ElasticBeanstalk",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"EnvironmentName": "my-environment"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [将 Flask 应用程序部署到 Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html)：本教程将引导您使用示例 Flask 应用程序在 Elastic Beanstalk 中创建应用程序和环境资源。然后，您可以使用 Elastic Beanstalk 部署操作来构建您的管道，该操作会将您的应用程序从源存储库部署到 Elastic Beanstalk 环境。
# Amazon Inspector `InspectorScan` 调用操作参考
Amazon Inspector 是一项漏洞管理服务，可自动发现工作负载并持续对其进行扫描，以查找软件漏洞和意外的网络暴露。中的`InspectorScan`操作 CodePipeline 可自动检测和修复开源代码中的安全漏洞。该操作是具有安全扫描功能的托管计算操作。您可以 InspectorScan 与第三方存储库（例如 GitHub 或 Bitbucket Cloud）中的应用程序源代码一起使用，也可以与容器应用程序的映像一起使用。您的操作将扫描并报告您配置的漏洞级别和警报。
**重要**
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行该操作将在 AWS CodeBuild中产生单独的费用。
**Topics**
+ [操作类型 ID](#action-reference-InspectorScan-type)
+ [配置参数](#action-reference-InspectorScan-parameters)
+ [输入构件](#action-reference-InspectorScan-input)
+ [输出构件](#action-reference-InspectorScan-output)
+ [输出变量](#w2aac56c62c19)
+ [服务角色权限：`InspectorScan` 操作](#edit-role-InspectorScan)
+ [操作声明](#w2aac56c62c23)
+ [另请参阅](#action-reference-InspectorScan-links)
## 操作类型 ID
+ 类别：`Invoke`
+ 拥有者：`AWS`
+ 提供方：`InspectorScan`
+ 版本：`1`
示例：
```
{
"Category": "Invoke",
"Owner": "AWS",
"Provider": "InspectorScan",
"Version": "1"
},
```
## 配置参数
**InspectorRunMode**
（必需）指示扫描模式的字符串。有效值为 `SourceCodeScan | ECRImageScan`。
**ECRRepository名称**
向其中推送映像的 Amazon ECR 存储库的名称。
**ImageTag**
为映像使用的标签。
此操作的参数会扫描您指定的漏洞级别。漏洞阈值有以下级别：
**CriticalThreshold **
在您的来源中发现的严重性严重漏洞的数量，超过这些漏洞 CodePipeline 将无法执行操作。
**HighThreshold **
在您的来源中发现的高严重性漏洞数量，超过这些漏洞 CodePipeline 将无法执行操作。
**MediumThreshold**
在您的来源中发现的中等严重性漏洞的数量，超过这些漏洞 CodePipeline 将无法执行操作。
**LowThreshold **
在您的来源中发现的低严重性漏洞的数量，超过这些漏洞 CodePipeline 将无法执行操作。
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/inspectorscan-edit.png)
## 输入构件
+ **构件数：**`1`
+ **描述：**用于扫描漏洞的源代码。如果扫描对象是 ECR 存储库，则不需要此输入构件。
## 输出构件
+ **构件数：**`1`
+ **描述：**以软件物料清单（SBOM）文件形式提供的漏洞详细信息。
## 输出变量
配置后，此操作会生成变量，该变量可由管道中下游操作的操作配置引用。此操作生成的变量可视为输出变量，即使操作没有命名空间也是如此。您可以使用命名空间配置操作，以使这些变量可用于下游操作的配置。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**HighestScannedSeverity **
扫描的最高严重程度的输出。有效值为 `medium | high | critical`。
## 服务角色权限：`InspectorScan` 操作
如需 `InspectorScan` 操作支持，请将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": "inspector-scan:ScanSbom",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "resource_ARN"
},
```
此外，如果尚未为命令操作添加以下权限，请向您的服务角色添加以下权限以查看 CloudWatch 日志。
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**注意**
在服务角色策略声明中使用基于资源的权限，将权限范围缩小到管道资源级别。
## 操作声明
------
#### [ YAML ]
```
name: Scan
actionTypeId:
category: Invoke
owner: AWS
provider: InspectorScan
version: '1'
runOrder: 1
configuration:
InspectorRunMode: SourceCodeScan
outputArtifacts:
- name: output
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "Scan",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "InspectorScan",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InspectorRunMode": "SourceCodeScan"
},
"outputArtifacts": [
{
"name": "output"
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
},
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ 有关 Amazon Inspector 的更多信息，请参阅《[Amazon Inspector](https://aws.amazon.com/inspector/) 用户指南》。
# AWS Lambda 调用操作参考
允许您执行 Lambda 函数以作为管道中的操作。使用作为此函数输入的事件对象，函数可以访问操作配置、输入构件位置、输出构件位置以及访问构件所需的其他信息。有关传递到 Lambda 调用函数的示例事件，请参阅[JSON 事件示例](#action-reference-Lambda-event)。在 Lambda 函数实施中，必须有对 `[PutJobSuccessResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html)` 或 `[PutJobFailureResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobFailureResult.html)` 的调用。否则，此操作的执行将挂起，直至操作超时。如果您为操作指定输出构件，则必须将其上传到 S3 存储桶作为函数实施的一部分。
**重要**
不要记录 CodePipeline 发送到 Lambda 的 JSON 事件，因为这可能会导致用户凭证记录到日志中 CloudWatch 。该 CodePipeline 角色使用 JSON 事件将临时证书传递给该`artifactCredentials`领域的 Lambda。有关示例事件，请参阅[JSON 事件示例](actions-invoke-lambda-function.md#actions-invoke-lambda-function-json-event-example)。
## 操作类型
+ 类别：`Invoke`
+ 拥有者：`AWS`
+ 提供方：`Lambda`
+ 版本：`1`
## 配置参数
**FunctionName**
是否必需：是
`FunctionName` 是在 Lambda 中创建的函数的名称。
**UserParameters**
必需：否
一个供 Lambda 函数作为输入进行处理的字符串。
## 输入构件
+ **构件数：**`0 to 5`
+ **描述：**要提供给 Lambda 函数的一组构件。
## 输出构件
+ **构件数：**`0 to 5`
+ **描述：**Lambda 函数作为输出而生成的一组构件。
## 输出变量
此操作将生成包含在 [PutJobSuccessResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html) 请求`outputVariables`部分中的所有键值对作为变量。
有关中变量的更多信息 CodePipeline，请参阅[变量参考](reference-variables.md)。
## 操作配置示例
------
#### [ YAML ]
```
Name: Lambda
Actions:
- Name: Lambda
ActionTypeId:
Category: Invoke
Owner: AWS
Provider: Lambda
Version: '1'
RunOrder: 1
Configuration:
FunctionName: myLambdaFunction
UserParameters: 'http://192.0.2.4'
OutputArtifacts: []
InputArtifacts: []
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Lambda",
"Actions": [
{
"Name": "Lambda",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Provider": "Lambda",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"FunctionName": "myLambdaFunction",
"UserParameters": "http://192.0.2.4"
},
"OutputArtifacts": [],
"InputArtifacts": [],
"Region": "us-west-2"
}
]
},
```
------
## JSON 事件示例
Lambda 操作会发送一个 JSON 事件，其中包含作业 ID、管道操作配置、输入和输出构件位置，以及构件的任何加密信息。作业辅助角色将访问这些详细信息以完成 Lambda 操作。有关更多信息，请参阅：[作业详细信息](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobDetails.html)。以下是示例事件。
```
{
"CodePipeline.job": {
"id": "11111111-abcd-1111-abcd-111111abcdef",
"accountId": "111111111111",
"data": {
"actionConfiguration": {
"configuration": {
"FunctionName": "MyLambdaFunction",
"UserParameters": "input_parameter"
}
},
"inputArtifacts": [
{
"location": {
"s3Location": {
"bucketName": "bucket_name",
"objectKey": "filename"
},
"type": "S3"
},
"revision": null,
"name": "ArtifactName"
}
],
"outputArtifacts": [],
"artifactCredentials": {
"secretAccessKey": "secret_key",
"sessionToken": "session_token",
"accessKeyId": "access_key_ID"
},
"continuationToken": "token_ID",
"encryptionKey": {
"id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"type": "KMS"
}
}
}
}
```
JSON 事件为中的 Lambda 操作提供了以下任务详情： CodePipeline
+ `id`：系统生成的唯一作业 ID。
+ `accountId`：与任务关联的 AWS 账户 ID。
+ `data`：作业辅助角色完成作业所需的其他信息。
+ `actionConfiguration`：Lambda 操作的操作参数。有关定义，请参阅[配置参数](#action-reference-Lambda-config)。
+ `inputArtifacts`：提供给操作的构件。
+ `location`：构件存储位置。
+ `s3Location`：操作的输入构件位置信息。
+ `bucketName`：操作的管道工件存储名称（例如，名为 codepipeline-us-east -2-1234567890 的 Amazon S3 存储桶）。
+ `objectKey`：应用程序的名称（例如，`CodePipelineDemoApplication.zip`）。
+ `type`：位置中构件的类型。目前，`S3` 是唯一有效的构件类型。
+ `revision`：构件的修订 ID。根据对象的类型，它可以是提交 ID (GitHub) 或修订版 ID（Amazon 简单存储服务）。有关更多信息，请参阅 [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html)。
+ `name`：要处理的构件的名称，如 `MyApp`。
+ `outputArtifacts`：操作的输出。
+ `location`：构件存储位置。
+ `s3Location`：操作的输出构件位置信息。
+ `bucketName`：操作的管道工件存储名称（例如，名为 codepipeline-us-east -2-1234567890 的 Amazon S3 存储桶）。
+ `objectKey`：应用程序的名称（例如，`CodePipelineDemoApplication.zip`）。
+ `type`：位置中构件的类型。目前，`S3` 是唯一有效的构件类型。
+ `revision`：构件的修订 ID。根据对象的类型，它可以是提交 ID (GitHub) 或修订版 ID（Amazon 简单存储服务）。有关更多信息，请参阅 [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html)。
+ `name`：构件的输出的名称，如 `MyApp`。
+ `artifactCredentials`：用于访问 Amazon S3 存储桶中输入和输出项目的 AWS 会话证书。这些凭证是临时凭证，由 AWS Security Token Service (AWS STS) 发布。
+ `secretAccessKey`：会话的秘密访问密钥。
+ `sessionToken`：令牌的会话。
+ `accessKeyId`：会话的秘密访问密钥。
+ `continuationToken`：操作生成的令牌。以后的操作使用此令牌来标识操作的正在运行的实例。操作完成时，不应提供延续令牌。
+ `encryptionKey`：用于加密工件存储区中的数据的加密密钥，例如密 AWS KMS 钥。如果未定义此密钥，将使用 Amazon Simple Storage Service 的默认密钥。
+ `id`：用于标识密钥的 ID。对于 AWS KMS 密钥，您可以使用密钥 ID、密钥 ARN 或别名 ARN。
+ `type`：加密密钥的类型，如 AWS KMS 密钥。
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS CloudFormation 用户指南](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/) [— 有关管道的 Lambda 操作和 CloudFormation 工件的更多信息，请参阅在管道中[使用参数覆盖函数](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html)、[自动部署基于 Lambda 的应用程序](https://docs.aws.amazon.com/lambda/latest/dg/automating-deployment.html)和构件。 CodePipeline AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)
+ [在中调用管道中的 AWS Lambda 函数 CodePipeline](actions-invoke-lambda-function.md)：此过程提供了一个示例 Lambda 函数，展示了如何使用控制台创建包含 Lambda 调用操作的管道。
# AWS OpsWorks 部署操作参考
您可以使用 AWS OpsWorks 操作通过管道 OpsWorks 进行部署。
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`OpsWorks`
+ 版本：`1`
## 配置参数
**App**
是否必需：是
堆 OpsWorks 栈。堆栈是应用程序基础设施的容器。
**堆栈**
是否必需：是
该 OpsWorks 应用程序。应用程序代表您要部署和运行的代码。
**层**
必需：否
堆 OpsWorks 栈。分层指定一组实例的配置和资源。
## 输入构件
+ **构件数：**`1`
+ **描述：**这是您操作的输入构件。
## 输出构件
+ **构件数：**`0 to 1`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限： AWS OpsWorks 操作
如需 AWS OpsWorks 支持，请在您的政策声明中添加以下内容：
```
{
"Effect": "Allow",
"Action": [
"opsworks:CreateDeployment",
"opsworks:DescribeApps",
"opsworks:DescribeCommands",
"opsworks:DescribeDeployments",
"opsworks:DescribeInstances",
"opsworks:DescribeStacks",
"opsworks:UpdateApp",
"opsworks:UpdateStack"
],
"Resource": "resource_ARN"
},
```
## 操作配置示例
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: OpsWorks
InputArtifacts:
- Name: myInputArtifact
Configuration:
Stack: my-stack
App: my-app
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "OpsWorks"
},
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"Configuration": {
"Stack": "my-stack",
"App": "my-app"
}
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS OpsWorks 用户指南](https://docs.aws.amazon.com/step-functions/latest/dg/)-有关使用进行部署的信息 AWS OpsWorks，请参阅《*AWS OpsWorks 用户指南》*。
# AWS Service Catalog 部署操作参考
您可以使用 AWS Service Catalog 操作通过管道部署模板。这些是您在 Service Catalog 中创建的资源模板。
## 操作类型
+ 类别：`Deploy`
+ 拥有者：`AWS`
+ 提供方：`ServiceCatalog`
+ 版本：`1`
## 配置参数
**TemplateFilePath**
是否必需：是
您的资源模板在源位置中的文件路径。
**ProductVersionName**
是否必需：是
Service Catalog 中的产品版本。
**ProductType**
是否必需：是
Service Catalog 中的产品类型。
**ProductId**
是否必需：是
Service Catalog 中的产品 ID。
**ProductVersionDescription**
必需：否
Service Catalog 中的产品版本描述。
## 输入构件
+ **构件数：**`1`
+ **描述：**这是您操作的输入构件。
## 输出构件
+ **构件数：**`0`
+ **描述：**输出构件不适用于此操作类型。
## 服务角色权限：Service Catalog 操作
对于 Service Catalog 支持，请将以下内容添加到策略语句中：
```
{
"Effect": "Allow",
"Action": [
"servicecatalog:ListProvisioningArtifacts",
"servicecatalog:CreateProvisioningArtifact",
"servicecatalog:DescribeProvisioningArtifact",
"servicecatalog:DeleteProvisioningArtifact",
"servicecatalog:UpdateProduct"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "resource_ARN"
}
```
## 按配置文件类型划分的操作配置示例
以下示例为使用 Service Catalog 的部署操作显示了一个有效的配置，用于在控制台中创建的管道（没有单独的配置文件）：
```
"configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
```
以下示例为使用 Service Catalog 的部署操作显示了一个有效的配置，用于在控制台中创建的管道（有单独的 `sample_config.json` 配置文件）：
```
"configuration": {
"ConfigurationFilePath": "sample_config.json",
"ProductId": "prod-example123456"
}
```
### 操作配置示例
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: ServiceCatalog
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
TemplateFilePath: S3_template.json
ProductVersionName: devops S3 v2
ProductType: CLOUD_FORMATION_TEMPLATE
ProductVersionDescription: Product version description
ProductId: prod-example123456
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "ServiceCatalog"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
}
```
------
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [Service Catalog 用户指南](https://docs.aws.amazon.com/servicecatalog/latest/userguide/) - 有关 Service Catalog 中的资源和模板的信息，请参阅《Service Catalog 用户指南》**。
+ [教程：创建部署到 Service Catalog 的管道](tutorials-S3-servicecatalog.md)：此教程介绍如何创建和配置一个管道将您的产品模板部署到 Service Catalog，并交付您已在源存储库中所做的更改。
# AWS Step Functions 调用操作参考
执行以下 AWS CodePipeline 操作的操作：
+ 从您的管道启动 AWS Step Functions 状态机执行。
+ 通过操作配置中的属性或位于要作为输入传递的管道构件中的文件向状态机提供初始状态。
+ （可选）设置执行 ID 前缀以便标识源自操作的执行。
+ 支持[标准和快速](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html)状态机。
**注意**
Step Functions 操作在 Lambda 上运行，因此它的构件大小配额与 Lambda 函数的构件大小配额相同。有关更多信息，请参阅《Lambda 开发人员指南》中的 [Lambda 配额](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html)。
## 操作类型
+ 类别：`Invoke`
+ 拥有者：`AWS`
+ 提供方：`StepFunctions`
+ 版本：`1`
## 配置参数
**StateMachineArn**
是否必需：是
要调用的状态机的 Amazon 资源名称 (ARN)。
**ExecutionNamePrefix**
必需：否
默认情况下，操作执行 ID 将用作状态机执行名称。如果提供了前缀，则该前缀将追加到带连字符的操作执行 ID 的前面，共同用作状态机执行名称。
```
myPrefix-1624a1d1-3699-43f0-8e1e-6bafd7fde791
```
对于快速状态机，名称应只包含 0-9、A-Z、a-z、- 和 \$1。
**InputType**
必需：否
+ **Literal (文本)**（默认值）：在指定此项时，**Input (输入)** 字段中的值将直接传递到状态机输入。
选择**文本**时**输入**字段的输入项示例：
```
{"action": "test"}
```
+ **FilePath****：由 “输入” 字段指定的输入构件中的文件内容用作状态机执行的输入。**如果设置为，**InputType**则需要输入工件**FilePath**。
选中 “输入” 字段时**输入**FilePath****的示例条目：
```
assets/input.json
```
**Input**
必需：条件
+ **文字**：当设置**InputType**为 “文**字**”（默认）时，此字段为可选字段。
如果提供此项，则 **Input (输入)** 字段将直接用作状态机执行的输入。否则，将使用空 JSON 对象 `{}` 调用状态机。
+ **FilePath**: 当设置**InputType**为时 **FilePath**，此字段为必填字段。
当设置为时 **InputType**，还需要输入工件**FilePath**。
指定的输入构件中文件的内容将用作状态机执行的输入。
## 输入构件
+ **构件数：**`0 to 1`
+ **描述：**如果设置**InputType**为 **FilePath**，则此构件是必需的，用于获取状态机执行的输入。
## 输出构件
+ **构件数：**`0 to 1`
+ **描述：**
+ **标准状态机**：如果提供此项，则使用状态机的输出填充输出构件。这是在状态机执行成功完成后从 [Step Fun DescribeExecution ctions API](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) 响应的`output`属性中获取的。
+ **快速状态机**：不受支持。
## 输出变量
此操作会生成输出变量，该变量可由管道中下游操作的操作配置引用。
有关更多信息，请参阅 [变量参考](reference-variables.md)。
**StateMachineArn**
状态机的 ARN。
**ExecutionArn**
状态机的执行的 ARN。仅标准状态机。
## 服务角色权限：`StepFunctions` 操作
对于 `StepFunctions` 操作，需要以下最低权限才能创建具有 Step Functions 调用操作的管道。
```
{
"Effect": "Allow",
"Action": [
"states:DescribeStateMachine",
"states:DescribeExecution",
"states:StartExecution"
],
"Resource": "resource_ARN"
},
```
## 操作配置示例
### 默认输入示例
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix"
}
}
```
------
### 文本输入示例
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
Input: '{"action": "test"}'
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"Input": "{\"action\": \"test\"}"
}
}
```
------
### 输入文件示例
------
#### [ YAML ]
```
Name: ActionName
InputArtifacts:
- Name: myInputArtifact
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: 'arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine'
ExecutionNamePrefix: my-prefix
InputType: FilePath
Input: assets/input.json
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"InputType": "FilePath",
"Input": "assets/input.json"
}
}
```
------
## 行为
在发布期间，使用操作配置中指定的输入 CodePipeline 执行已配置的状态机。
当设置**InputType**为 **Literal** 时，**输入**操作配置字段的内容将用作状态机的输入。如果未提供文本输入，则状态机执行将使用空的 JSON 对象 `{}`。有关在没有输入的情况下运行状态机执行的更多信息，请参阅 [Step Functions StartExecution API](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)。
设置**InputType**为时 **FilePath**，该操作将解压缩输入对象，并使用在**输入**操作配置字段中指定的文件内容作为状态机的输入。指定后 **FilePath**，“**输入**” 字段为必填字段，并且必须存在输入对象；否则，操作将失败。
在成功启动执行后，两种状态机类型（*标准* 和*快速*）的行为将不同。
### 标准状态机
如果标准状态机执行成功启动，则会 CodePipeline 轮询 `DescribeExecution` API，直到执行达到终端状态。如果执行成功完成，则操作将成功；否则，操作将失败。
如果配置了输出构件，则该构件将包含状态机的返回值。这是在状态机执行成功完成后从 [Step Fun DescribeExecution ctions API](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) 响应的`output`属性中获取的。请注意，此 API 上已强制实施输出长度限制。
#### 错误处理
+ 如果操作无法启动状态机执行，则操作执行将失败。
+ 如果在 Ste CodePipeline p Functions 操作达到超时时间（默认为 7 天）之前，状态机执行未能达到终端状态，则操作执行将失败。尽管发生此失败，状态机也可能会继续运行。有关 Step Functions 中的状态机执行超时的更多信息，请参阅[标准和快速工作流](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html)。
**注意**
您可以使用此操作请求增加账户的调用操作超时配额。但配额增加将应用到该账户的所有区域中此类型的所有操作。
+ 如果状态机执行达到 FAILED、TIMED\$1OUT 或 ABORTED 终端状态，则操作执行失败。
### 快速状态机
如果快速状态机执行已成功启动，则表示调用操作执行已成功完成。
为快速状态机配置的操作的注意事项：
+ 您无法指定输出构件。
+ 操作不会等待状态机执行完成。
+ 在中开始执行操作后 CodePipeline，即使状态机执行失败，操作也会成功执行。
#### 错误处理
+ 如果 CodePipeline 无法启动状态机执行，则操作执行失败。否则，操作将立即成功。 CodePipeline 无论状态机执行需要多长时间完成或其结果如何，操作都会成功。
## 另请参阅
下列相关资源在您使用此操作的过程中会有所帮助。
+ [AWS Step Functions 开发者指南](https://docs.aws.amazon.com/step-functions/latest/dg/) — 有关状态机、执行和状态机输入的信息，请参阅《*AWS Step Functions 开发人员指南》*。
+ [教程：在管道中使用 AWS Step Functions 调用操作](tutorials-step-functions.md)：本教程将帮助您开始使用示例标准状态机，并说明如何使用控制台通过添加 Step Functions 调用操作来更新管道。