本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 配置 Elastic Beanstalk 环境（高级）
当您创建 AWS Elastic Beanstalk 环境时，Elastic Beanstalk 会配置和配置运行和支持您的应用程序所需 AWS 的所有资源。除配置您的环境的元数据和更新行为外，您还可以通过为[配置选项](command-options.md)提供值对这些资源进行自定义。例如，您可能想要添加 Amazon SQS 队列和队列深度警报，或者您可能想要添加一个 Ama ElastiCache zon 集群。
大多数配置选项都具有默认值，Elastic Beanstalk 会自动应用这些默认值。您可以使用配置文件、保存的配置、命令行选项或通过直接调用 Elastic Beanstalk API 覆盖这些默认值。EB CLI 和 Elastic Beanstalk 控制台还对某些选项应用建议的值。
在部署应用程序版本的同时，您就可以轻松地自定义环境，只需使用源包将配置文件添加进来即可。在您的实例上自定义软件时，使用配置文件比创建自定义 AMI 更有利，因为您不需要维护一组。 AMIs
部署应用程序时，建议您自定义和配置应用程序所依赖的软件。这些文件可能是应用程序所要求的依赖项，例如 yum 存储库中的其他包，也可能是配置文件，如 httpd.conf 的替代项，用于覆盖 AWS Elastic Beanstalk默认的特定设置。
**Topics**
+ [配置选项](command-options.md)
+ [使用配置文件 (`.ebextensions`) 进行高级环境自定义](ebextensions.md)
+ [使用 Elastic Beanstalk 保存的配置](environment-configuration-savedconfig.md)
+ [环境清单 (`env.yaml`)](environment-cfg-manifest.md)
+ [在 Elastic Beanstalk 环境中使用自定义亚马逊机器映像（AMI）](using-features.customenv.md)
+ [提供静态文件](environment-cfg-staticfiles.md)
+ [为 Elastic Beanstalk 环境配置 HTTPS](configuring-https.md)
# 配置选项
Elastic Beanstalk 定义了大量配置选项，您可以使用这些选项来配置环境的行为及其包含的资源。配置选项组织到命名空间中，如 `aws:autoscaling:asg`，它定义用于环境的 Auto Scaling 组的选项。
在您创建环境时，Elastic Beanstalk 控制台和 EB CLI 设置一些配置选项，包括您显式设置的选项以及客户端定义的[建议值](#configuration-options-recommendedvalues)。此外，您还可以在已保存的配置和配置文件中设置配置选项。如果在多个位置设置了同一个选项，则使用的值由[优先顺序](#configuration-options-precedence)确定。
配置选项设置可以采用文本格式在环境创建之前进行创建并保存，在创建环境期间使用任何支持的客户端进行应用，以及在环境创建之后进行添加、修改或删除。有关可在这三个阶段的每个阶段中使用配置选项的所有方法的详细划分，请阅读以下主题：
+ [在创建环境之前设置配置选项](environment-configuration-methods-before.md)
+ [在环境创建期间设置配置选项](environment-configuration-methods-during.md)
+ [在环境创建后设置配置选项](environment-configuration-methods-after.md)
有关命名空间和选项的完整列表，包括各自的默认值和支持的值，请参阅[面向所有环境的常规选项](command-options-general.md)和[特定于平台的选项](command-options-specific.md)。
## 优先级
在创建环境期间，配置选项按照以下优先顺序（从最高到最低）从多个来源进行应用：
+ **直接应用于环境的设置** — 任何客户端（包括 Elastic Beanstalk 控制台、EB CLI 和）在 Elastic Beanstalk API 上执行创建环境或更新环境操作期间指定的设置。 AWS CLI SDKsElastic Beanstalk 控制台和 EB CLI 还会为在该级别应用的一些选项应用[建议值](#configuration-options-recommendedvalues)（除非覆盖）。
+ **保存的配置** - 不直接应用于环境的任何选项的设置都从保存的配置加载（如果指定）。
+ **配置文件（.ebextensions）** – 不直接应用于环境以及未在保存的配置中指定的任何选项的设置都从应用程序源包根文件夹处的 `.ebextensions` 文件夹中的配置文件加载。
配置文件会按字母顺序执行。例如，`.ebextensions/01run.config` 在 `.ebextensions/02do.config` 之前执行。
+ **默认值** - 如果配置选项具有默认值，则它仅当未在以上任何级别上设置选项时才应用。
如果在多个位置定义相同配置选项，则应用优先顺序最高的设置。通过保存的配置或直接应用于环境的设置来应用设置时，设置会作为环境配置的一部分进行存储。可以使用 [AWS CLI](environment-configuration-methods-after.md#configuration-options-remove-awscli) 或[使用 EB CLI](environment-configuration-methods-after.md#configuration-options-remove-ebcli) 删除这些设置。
配置文件中的设置不直接应用于环境，无法在不修改配置文件并部署新应用程序版本的情况下删除。如果删除使用其他方法之一来应用的设置，则会从源包中的配置文件加载该设置。
例如，假设在创建环境期间，您使用 Elastic Beanstalk 控制台、命令行选项或保存的配置将环境中的最小实例数设置为 5。而应用程序的源包还包含一个将最小实例数设置为 2 的配置文件。
当您创建环境时，Elastic Beanstalk 在 `MinSize` 命名空间中将 `aws:autoscaling:asg` 选项设置为 5。如果您随后从环境配置中删除该选项，则会加载配置文件的值，最小实例数设置为 2。如果您随后从源包中删除配置文件并重新部署，则 Elastic Beanstalk 使用默认设置 1。
## 建议值
Elastic Beanstalk 命令行界面（EB CLI）和 Elastic Beanstalk 控制台为某些配置选项提供了建议值。这些值可能与默认值不同，会在创建环境时在 API 级别上进行设置。建议值使 Elastic Beanstalk 可以改进默认环境配置，而无需对 API 进行无法向后兼容的更改。
例如，EB CLI 和 Elastic Beanstalk 控制台都为实例`InstanceType`类型（在命名空间中）设置了配置 EC2 选项。`aws:autoscaling:launchconfiguration`每个客户端都提供不同的方式来覆盖默认设置。在控制台中，您可以从 **Create New Environment**（创建新环境）向导的 **Configuration Details**（配置详细信息）页面上的下拉菜单中选择不同的实例类型。使用 EB CLI 时，您可以对 [`--instance_type`](eb3-create.md) 使用 **eb create** 参数。
由于建议值在 API 级别上进行设置，因此它们会覆盖您在配置文件或保存的配置设置的相同选项值。以下选项会进行设置：
**Elastic Beanstalk 控制台**
+ 命名空间: `aws:autoscaling:launchconfiguration`
选项名称：`IamInstanceProfile`、`EC2KeyName`、`InstanceType`
+ 命名空间: `aws:autoscaling:updatepolicy:rollingupdate`
选项名称：`RollingUpdateType` 和 `RollingUpdateEnabled`
+ 命名空间: `aws:elasticbeanstalk:application`
选项名称：`Application Healthcheck URL`
+ 命名空间: `aws:elasticbeanstalk:command`
选项名称：`DeploymentPolicy`、`BatchSize` 和 `BatchSizeType`
+ 命名空间: `aws:elasticbeanstalk:environment`
选项名称：`ServiceRole`
+ 命名空间: `aws:elasticbeanstalk:healthreporting:system`
选项名称：`SystemType` 和 `HealthCheckSuccessThreshold`
+ 命名空间: `aws:elasticbeanstalk:sns:topics`
选项名称：`Notification Endpoint`
+ 命名空间: `aws:elasticbeanstalk:sqsd`
选项名称：`HttpConnections`
+ 命名空间: `aws:elb:loadbalancer`
选项名称：`CrossZone`
+ 命名空间: `aws:elb:policies`
选项名称：`ConnectionDrainingTimeout` 和 `ConnectionDrainingEnabled`
**EB CLI**
+ 命名空间: `aws:autoscaling:launchconfiguration`
选项名称：`IamInstanceProfile`、`InstanceType`
+ 命名空间: `aws:autoscaling:updatepolicy:rollingupdate`
选项名称：`RollingUpdateType` 和 `RollingUpdateEnabled`
+ 命名空间: `aws:elasticbeanstalk:command`
选项名称：`BatchSize` 和 `BatchSizeType`
+ 命名空间: `aws:elasticbeanstalk:environment`
选项名称：`ServiceRole`
+ 命名空间: `aws:elasticbeanstalk:healthreporting:system`
选项名称：`SystemType`
+ 命名空间: `aws:elb:loadbalancer`
选项名称：`CrossZone`
+ 命名空间: `aws:elb:policies`
选项名称：`ConnectionDrainingEnabled`
# 在创建环境之前设置配置选项
AWS Elastic Beanstalk 支持大量[配置选项](command-options.md)，允许您修改应用于环境中资源的设置。其中一些选项具有默认值，可以覆盖这些值以自定义环境。其他选项可以进行配置以启动附加功能。
Elastic Beanstalk 支持两种用于保存配置选项设置的方法。YAML 或 JSON 格式的配置文件可以放在应用程序的源代码中（位于一个名为 `.ebextensions` 的目录中），并作为应用程序源包的一部分进行部署。您可在本地创建和管理配置文件。
保存的配置是您通过正在运行的环境或 JSON 选项文件创建并存储在 Elastic Beanstalk 中的模板。保存的现有配置也可以进行扩展以创建新配置。
**注意**
在配置文件和保存的配置中定义的设置的优先级低于在创建环境期间或在创建环境后配置的设置，包括由 Elastic Beanstalk 控制台和 [EB CLI](eb-cli3.md) 应用的建议值。有关更多信息，请参阅 [优先级](command-options.md#configuration-options-precedence)。
选项还可以在 JSON 文档中指定，并在使用 EB CLI 或 创建或更新环境时直接提供给 Elastic Beanstalk AWS CLI通过此方法直接提供给 Elastic Beanstalk 的选项会覆盖所有其他方法。
有关可用选项的完整列表，请参阅[配置选项](command-options.md)。
**Topics**
+ [配置文件（`.ebextensions`）](#configuration-options-before-ebextensions)
+ [保存的配置](#configuration-options-before-savedconfig)
+ [JSON 文档](#configuration-options-before-json)
+ [EB CLI 配置](#configuration-options-before-configyml)
## 配置文件（`.ebextensions`）
使用 `.ebextensions` 可配置使应用程序正常运行所需的选项，并为可以在更高[优先顺序](command-options.md#configuration-options-precedence)级别上进行覆盖的其他选项提供默认值。`.ebextensions` 中指定的选项的优先顺序最低，可由任何其他级别的设置进行覆盖。
要使用配置文件，请在项目源代码顶层创建一个名为 `.ebextensions` 的文件夹。添加一个扩展名为 `.config` 的文件并按以下方法指定选项：
```
option_settings:
- namespace: namespace
option_name: option name
value: option value
- namespace: namespace
option_name: option name
value: option value
```
例如，以下配置文件将应用程序健康检查 url 设置为 `/health`：
`healthcheckurl.config`
```
option_settings:
- namespace: aws:elasticbeanstalk:application
option_name: Application Healthcheck URL
value: /health
```
在 JSON 中：
```
{
"option_settings" :
[
{
"namespace" : "aws:elasticbeanstalk:application",
"option_name" : "Application Healthcheck URL",
"value" : "/health"
}
]
}
```
这会在 Elastic Beanstalk 环境中配置 Elastic Load Balancing 负载均衡器以向每个 EC2 实例的 `/health` 路径进行 HTTP 请求，从而确定它是否运行状况良好。
**注意**
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
在您的[应用程序源包](applications-sourcebundle.md)中包含 `.ebextensions` 目录，并将它部署到新的或现有的 Elastic Beanstalk 环境中。
除了 `option_settings` 之外，配置文件还支持几个部分，用于对在环境中的服务器上运行的软件和文件进行自定义。有关更多信息，请参阅[.Ebextensions](ebextensions.md)。
## 保存的配置
使用 Elastic Beanstalk 控制台、EB CLI 或 创建保存的配置，以保存在创建环境期间或在创建环境后应用于现有环境的设置 AWS CLI保存的配置属于某个应用程序，可以应用于该应用程序的新环境或现有环境。
**Topics**
+ [Elastic Beanstalk 控制台](#configuration-options-before-savedconfig-console)
+ [EB CLI](#configuration-options-before-savedconfig-ebcli)
+ [AWS CLI](#configuration-options-before-savedconfig-awscli)
### Elastic Beanstalk 控制台
**创建保存的配置（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 选择 **Actions**（操作），然后选择 **Save configuration**（保存配置）。
1. 使用屏幕上的对话框完成该操作。
保存的配置存储在 Elastic Beanstalk S3 存储桶中按照应用程序命名的文件夹中。例如，对于账号 123456789012，us-west-2 区域中名为 `my-app` 的应用程序的配置位于 `s3://elasticbeanstalk-us-west-2-123456789012/resources/templates/my-app`。
### EB CLI
[EB CLI](eb-cli3.md) 也在 [**eb config**](eb3-config.md) 下提供了子命令，用于与保存的配置进行交互：
**创建保存的配置（EB CLI）**
1. 保存所附加环境的当前配置：
```
~/project$ eb config save --cfg my-app-v1
```
EB CLI 将配置保存到 `~/project/.elasticbeanstalk/saved_configs/my-app-v1.cfg.yml`
1. 如果需要，可在本地修改保存的配置。
1. 将保存的配置上传到 S3：
```
~/project$ eb config put my-app-v1
```
### AWS CLI
使用`aws elasticbeanstalk create-configuration-template`从正在运行的环境创建保存的配置
**创建保存的配置（AWS CLI）**
1. 使用 `describe-environments` 确定 Elastic Beanstalk 环境的环境 ID：
```
$ aws elasticbeanstalk describe-environments --environment-name my-env
{
"Environments": [
{
"ApplicationName": "my-env",
"EnvironmentName": "my-env",
"VersionLabel": "89df",
"Status": "Ready",
"Description": "Environment created from the EB CLI using \"eb create\"",
"EnvironmentId": "e-vcghmm2zwk",
"EndpointURL": "awseb-e-v-AWSEBLoa-1JUM8159RA11M-43V6ZI1194.us-west-2.elb.amazonaws.com",
"SolutionStackName": "64bit Amazon Linux 2015.03 v2.0.2 running Multi-container Docker 1.7.1 (Generic)",
"CNAME": "my-env-nfptuqaper.elasticbeanstalk.com",
"Health": "Green",
"AbortableOperationInProgress": false,
"Tier": {
"Version": " ",
"Type": "Standard",
"Name": "WebServer"
},
"HealthStatus": "Ok",
"DateUpdated": "2015-10-01T00:24:04.045Z",
"DateCreated": "2015-09-30T23:27:55.768Z"
}
]
}
```
1. 使用 `create-configuration-template` 保存环境的当前配置：
```
$ aws elasticbeanstalk create-configuration-template --environment-id e-vcghmm2zwk --application-name my-app --template-name v1
```
Elastic Beanstalk 会将配置保存到 Amazon S3 中的 Elastic Beanstalk 存储桶中。
## JSON 文档
如果您使用 AWS CLI 来创建和更新环境，则还可以提供 JSON 格式的配置选项。如果您使用来创建和管理环境，则使用 JSON 格式 AWS CLI 的配置文件库会很有用。
例如，以下 JSON 文档将应用程序健康检查 url 设置为 `/health`：
**\$1/ebconfigs/healthcheckurl.json**
```
[
{
"Namespace": "aws:elasticbeanstalk:application",
"OptionName": "Application Healthcheck URL",
"Value": "/health"
}
]
```
## EB CLI 配置
除了使用 **eb config** 命令支持保存的配置以及直接环境配置之外，EB CLI 还有一个配置文件，其中包含一个名为 `default_ec2_keyname` 的选项，可以用于指定 Amazon EC2 密钥对以便对环境中的实例进行 SSH 访问。EB CLI 使用此选项在 `EC2KeyName` 命名空间中设置 `aws:autoscaling:launchconfiguration` 配置选项。
**\$1/ .yml workspace/my-app/.elasticbeanstalk/config**
```
branch-defaults:
master:
environment: my-env
develop:
environment: my-env-dev
deploy:
artifact: ROOT.war
global:
application_name: my-app
default_ec2_keyname: my-keypair
default_platform: Tomcat 8 Java 8
default_region: us-west-2
profile: null
sc: git
```
# 在环境创建期间设置配置选项
当您使用 Elastic Beanstalk 控制台、EB AWS CLI CLI、软件开发工具包或 Elastic Beanstalk API 创建 AWS Elastic Beanstalk 环境时，您可以为配置选项提供值，以自定义您的环境和在其中启动的资源。 AWS
对于一次性配置更改之外的任何更改，可以在本地、源包或 Amazon S3 中[存储配置文件](environment-configuration-methods-before.md)。
本主题介绍用于在创建环境期间设置配置选项的所有方法的过程。
**Topics**
+ [在 Elastic Beanstalk 控制台中](#configuration-options-during-console)
+ [使用 EB CLI](#configuration-options-during-ebcli)
+ [使用 AWS CLI](#configuration-options-during-awscli)
## 在 Elastic Beanstalk 控制台中
在 Elastic Beanstalk 控制台中创建 Elastic Beanstalk 环境时，您可以使用配置文件、保存的配置以及 **Create New Environment**（创建新环境）向导中的表单提供配置选项。
**Topics**
+ [使用配置文件（`.ebextensions`）](#configuration-options-during-console-ebextensions)
+ [使用保存的配置](#configuration-options-during-console-savedconfig)
+ [使用新建环境向导](#configuration-options-during-console-wizard)
### 使用配置文件（`.ebextensions`）
将 `.config` 文件放在一个名为 `.ebextensions` 的文件夹内的[应用程序源包](applications-sourcebundle.md)中。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
```
~/workspace/my-app-v1.zip
|-- .ebextensions
| |-- environmentvariables.config
| `-- healthcheckurl.config
|-- index.php
`-- styles.css
```
通常在[创建环境](using-features.environments.md)期间将源包上传到 Elastic Beanstalk。
Elastic Beanstalk 控制台为某些配置选项应用[建议值](command-options.md#configuration-options-recommendedvalues)，并为其他选项提供表单字段。通过 Elastic Beanstalk 控制台配置的选项会直接应用于环境，覆盖配置文件中的设置。
### 使用保存的配置
使用 Elastic Beanstalk 控制台创建新环境时，首先执行的步骤是选择配置。配置可以是[**预定义配置**](concepts.platforms.md)（通常是某个平台（如 **PHP** 或 **Tomcat**）的最新版本），也可以是**保存的配置**。
**在创建环境期间应用保存的配置（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Applications**（应用程序），然后从列表中选择应用程序的名称。
1. 在导航窗格中，找到应用程序的名称，然后选择 **Saved configurations**（已保存的配置）。
1. 选择要应用的已保存的配置，然后选择 **Launch environment**（启动环境）。
1. 继续执行向导以创建环境。
保存的配置将因应用程序而异。有关创建保存的配置的详细信息，请参阅[保存的配置](environment-configuration-methods-before.md#configuration-options-before-savedconfig)。
### 使用新建环境向导
大多数标准配置选项都在[创建新环境向导](environments-create-wizard.md)的**配置更多选项**页面上。如果您创建 Amazon RDS 数据库或为环境配置 VPC，则会为这些资源提供其他配置选项。
**在创建环境期间设置配置选项（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Applications**（应用程序）。
1. 选择或[创建](applications.md)应用程序。
1. 选择 **Actions**（操作），然后选择 **Create environment**（创建环境）。
1. 继续执行向导，然后选择**配置更多选项**。
1. 选择任何 **configuration presets**（配置预设），然后在一个或多个配置类别中选择 **Edit**（编辑）以更改一组相关的配置选项。
1. 在完成选项的选择后，选择**创建环境**。
在新建环境向导中设置的任何选项都直接对环境进行设置，并将覆盖所应用的保存配置或配置文件（`.ebextensions`）中的任何选项设置。可以在创建环境之后使用 [EB CLI](environment-configuration-methods-after.md#configuration-options-after-ebcli) 或 [AWS CLI](environment-configuration-methods-after.md#configuration-options-after-awscli) 删除设置，以允许保存的配置或配置文件中的设置发挥作用。
有关新建环境向导的详细信息，请参阅[创建新环境向导](environments-create-wizard.md)。
## 使用 EB CLI
**Topics**
+ [使用配置文件 (`.ebextensions`)](#configuration-options-during-ebcli-ebextensions)
+ [使用保存的配置](#configuration-options-during-ebcli-savedconfig)
+ [使用命令行选项](#configuration-options-during-ebcli-params)
### 使用配置文件 (`.ebextensions`)
将 `.config` 文件放在项目文件夹的 `.ebextensions` 下，以便与应用程序代码一起部署它们。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
```
~/workspace/my-app/
|-- .ebextensions
| |-- environmentvariables.config
| `-- healthcheckurl.config
|-- .elasticbeanstalk
| `-- config.yml
|-- index.php
`-- styles.css
```
使用 **eb create** 创建环境并将源代码部署到其中。
```
~/workspace/my-app$ eb create my-env
```
### 使用保存的配置
要在使用 [**eb create**](eb3-create.md) 创建环境时应用保存的配置，请使用 `--cfg` 选项。
```
~/workspace/my-app$ eb create --cfg savedconfig
```
可以将保存的配置存储在项目文件夹中或 Amazon S3 上的 Elastic Beanstalk 存储位置中。在以上示例中，EB CLI 首先在文件夹 `savedconfig.cfg.yml` 中查找名为 `.elasticbeanstalk/saved_configs/` 的保存的配置文件。在使用 `.cfg.yml` 应用保存的配置时，不要包含文件扩展名（`--cfg`）。
```
~/workspace/my-app/
|-- .ebextensions
| `-- healthcheckurl.config
|-- .elasticbeanstalk
| |-- saved_configs
| | `-- savedconfig.cfg.yml
| `-- config.yml
|-- index.php
`-- styles.css
```
如果 EB CLI 未在本地找到配置，则它会在 Amazon S3 中的 Elastic Beanstalk 存储位置中进行查找。有关创建、编辑和上传保存的配置的详细信息，请参阅[保存的配置](environment-configuration-methods-before.md#configuration-options-before-savedconfig)。
### 使用命令行选项
EB CLI **eb create** 命令具有几个[选项](eb3-create.md#eb3-createoptions)，可以用于在创建环境期间设置配置选项。可以使用这些选项来将 RDS 数据库添加到环境、配置 VPC 或覆盖[建议值](command-options.md#configuration-options-recommendedvalues)。
例如，EB CLI 在默认情况下使用 `t2.micro` 实例类型。要选择不同的实例类型，请使用 `--instance_type` 选项。
```
$ eb create my-env --instance_type t2.medium
```
要创建 Amazon RDS 数据库实例并将它挂载到环境，请使用 `--database` 选项。
```
$ eb create --database.engine postgres --database.username dbuser
```
如果您省略环境名称、数据库密码或创建环境所需的任何其他参数，则 EB CLI 会提示您输入它们。
有关可用选项的完整列表以及用法示例，请参阅 [eb create](eb3-create.md)。
## 使用 AWS CLI
[当您使用`create-environment`命令创建 Elastic Beanstalk 环境 AWS CLI时 AWS CLI ，不会应用任何建议值。](command-options.md#configuration-options-recommendedvalues)指定源包中的配置文件中定义了所有配置选项。
**Topics**
+ [使用配置文件（`.ebextensions`）](#configuration-options-during-awscli-ebextensions)
+ [使用保存的配置](#configuration-options-during-awscli-savedconfig)
+ [使用命令行选项](#configuration-options-during-awscli-params)
### 使用配置文件（`.ebextensions`）
要将配置文件应用于您使用创建的环境 AWS CLI，请将其包含在您上传到 Amazon S3 的应用程序源包中。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
```
~/workspace/my-app-v1.zip
|-- .ebextensions
| |-- environmentvariables.config
| `-- healthcheckurl.config
|-- index.php
`-- styles.css
```
**上传应用程序源包并使用创建环境 AWS CLI**
1. 如果您在 Amazon S3 中还没有 Elastic Beanstalk 存储桶，请使用 `create-storage-location` 创建一个。
```
$ aws elasticbeanstalk create-storage-location
{
"S3Bucket": "elasticbeanstalk-us-west-2-123456789012"
}
```
1. 将应用程序源包上传到 Amazon S3。
```
$ aws s3 cp sourcebundle.zip s3://elasticbeanstalk-us-west-2-123456789012/my-app/sourcebundle.zip
```
1. 创建应用程序版本。
```
$ aws elasticbeanstalk create-application-version --application-name my-app --version-label v1 --description MyAppv1 --source-bundle S3Bucket="elasticbeanstalk-us-west-2-123456789012",S3Key="my-app/sourcebundle.zip" --auto-create-application
```
1. 创建环境。
```
$ aws elasticbeanstalk create-environment --application-name my-app --environment-name my-env --version-label v1 --solution-stack-name "64bit Amazon Linux 2015.03 v2.0.0 running Tomcat 8 Java 8"
```
### 使用保存的配置
要在创建过程中将保存的配置应用于环境，请使用 `--template-name` 参数。
```
$ aws elasticbeanstalk create-environment --application-name my-app --environment-name my-env --template-name savedconfig --version-label v1
```
指定保存的配置时，不要同时指定解决方案堆栈名称。保存的配置已指定解决方案堆栈，如果您尝试同时使用两个选项，则 Elastic Beanstalk 将返回错误。
### 使用命令行选项
使用 `--option-settings` 参数可采用 JSON 格式指定配置选项。
```
$ aws elasticbeanstalk create-environment --application-name my-app --environment-name my-env --version-label v1 --template-name savedconfig --option-settings '[
{
"Namespace": "aws:elasticbeanstalk:application",
"OptionName": "Application Healthcheck URL",
"Value": "/health"
}
]
```
要从文件加载 JSON，请使用 `file://` 前缀。
```
$ aws elasticbeanstalk create-environment --application-name my-app --environment-name my-env --version-label v1 --template-name savedconfig --option-settings file://healthcheckurl.json
```
Elastic Beanstalk 会将您使用 `--option-settings` 选项指定的选项设置直接应用于环境。如果在保存的配置或配置文件中指定了相同选项，则 `--option-settings` 会覆盖这些值。
# 在环境创建后设置配置选项
您可以修改正在运行的环境的选项设置，方法是应用保存的配置，上传带有配置文件（`.ebextensions`）的新的源包或使用 JSON 文档。EB CLI 和 Elastic Beanstalk 控制台还具有客户端特定的功能，可用于设置和更新配置选项。
当您设置或更改某一配置选项时，根据更改的严重性，可能会触发完整环境更新。例如，如果对 [`aws:autoscaling:launchconfiguration`](command-options-general.md#command-options-general-autoscalinglaunchconfiguration) 中的选项（如 `InstanceType`）进行更改，则需要重新预置环境中的 Amazon EC2 实例。这将触发[滚动更新](using-features.rollingupdates.md)。其他配置更改无需中断或重新配置即可应用。
您可以使用 EB CLI 或 AWS CLI 命令从环境中删除选项设置。通过删除在 API 级别直接对环境设置的选项，可使配置文件中的设置（否则被直接应用于环境的设置屏蔽）将生效。
通过其他某种配置方法直接对环境设置相同的选项可以覆盖保存的配置和配置文件中的相应设置。但只有应用更新的保存的配置或配置文件才能完全删除这些设置。如果选项在保存的配置、配置文件中未设置并且也没有直接对环境设置，则应用默认值（如果有默认值）。有关更多信息，请参阅 [优先级](command-options.md#configuration-options-precedence)。
**Topics**
+ [Elastic Beanstalk 控制台](#configuration-options-after-console)
+ [EB CLI](#configuration-options-after-ebcli)
+ [的 AWS CLI](#configuration-options-after-awscli)
## Elastic Beanstalk 控制台
您可以在 Elastic Beanstalk 控制台中更新配置选项设置，方法是部署包含配置文件的应用程序源包，应用保存的配置，或者在环境管理控制台中使用 **Configuration**（配置）页面直接修改环境。
**Topics**
+ [使用配置文件 (`.ebextensions`)](#configuration-options-after-console-ebextensions)
+ [使用保存的配置](#configuration-options-after-console-savedconfig)
+ [使用 Elastic Beanstalk 控制台](#configuration-options-after-console-configpage)
### 使用配置文件 (`.ebextensions`)
更新源目录中的配置文件，创建新的源包，并将新版本部署到您的 Elastic Beanstalk 环境以应用更改。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
**部署源包**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 在环境概述页面上，选择 **Upload and deploy**（上传和部署）。
1. 使用屏幕上的对话框上传源包。
1. 选择 **Deploy**（部署）。
1. 部署完成后，选择站点 URL 以在新选项卡中打开您的网站。
对配置文件进行的更改不会覆盖保存的配置中的选项设置或在 API 级别直接应用于环境的设置。有关详细信息，请参阅[优先顺序](command-options.md#configuration-options-precedence)。
### 使用保存的配置
对正在运行的环境应用保存的配置以便应用它所定义的选项设置。
**将保存的配置应用于正在运行的环境（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Applications**（应用程序），然后从列表中选择应用程序的名称。
1. 在导航窗格中，找到应用程序的名称，然后选择 **Saved configurations (已保存的配置)**。
1. 选择要应用的已保存的配置，然后选择 **Load**（加载）。
1. 选择一个环境，然后选择**加载**。
保存的配置中定义的设置会覆盖配置文件中的设置，但会被使用环境管理控制台配置的设置覆盖。
有关创建保存的配置的详细信息，请参阅[保存的配置](environment-configuration-methods-before.md#configuration-options-before-savedconfig)。
### 使用 Elastic Beanstalk 控制台
Elastic Beanstalk 控制台在每个环境的 **Configuration**（配置）页面上提供多个配置选项。
**在正在运行的环境中更改配置选项（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 在导航窗格中，选择 **Configuration (配置)**。
1. 找到要编辑的配置页面：
+ 如果您看到感兴趣的选项，或者您知道它所在的配置类别，请在它的配置类别中选择 **Edit**（编辑）。
+ 要查找一个选项，请打开**表视图**，然后在搜索框中输入搜索词。在您键入时，列表将会变短，并且仅显示与搜索词匹配的选项。
在看到要查找的选项时，请在包含该选项的配置类别中选择 **Edit**（编辑）。
![\[Elastic Beanstalk 控制台的配置概述页面的表视图，其中显示了选项搜索\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/images/environments-cfg-console.overview.table.search1.png)
1. 更改设置，然后选择**保存**。
1. 根据需要，在其他配置类别中重复前面的两个步骤。
1. 选择 **Apply**。
在环境管理控制台中对配置选项所做的更改将直接应用于环境。这些更改覆盖配置文件或保存的配置中的相同选项的设置。有关详细信息，请参阅[优先顺序](command-options.md#configuration-options-precedence)。
有关使用 Elastic Beanstalk 控制台更改运行的环境上的配置选项的详细信息，请参阅[配置 Elastic Beanstalk 环境](customize-containers.md)下面的主题。
## EB CLI
您可以使用 EB CLI 更新配置选项设置，方法是部署包含配置文件的源代码，应用来自保存的配置的设置，或使用 **eb config** 命令直接修改环境配置。
**Topics**
+ [使用配置文件 (`.ebextensions`)](#configuration-options-after-ebcli-ebextensions)
+ [使用保存的配置](#configuration-options-after-ebcli-savedconfig)
+ [使用 **eb config**](#configuration-options-after-ebcli-ebconfig)
+ [使用 **eb setenv**](#configuration-options-after-ebcli-ebsetenv)
### 使用配置文件 (`.ebextensions`)
将 `.config` 文件放在项目文件夹的 `.ebextensions` 下，以便与应用程序代码一起部署它们。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
```
~/workspace/my-app/
|-- .ebextensions
| |-- environmentvariables.config
| `-- healthcheckurl.config
|-- .elasticbeanstalk
| `-- config.yml
|-- index.php
`-- styles.css
```
使用 **eb deploy** 部署您的源代码。
```
~/workspace/my-app$ eb deploy
```
### 使用保存的配置
您可以使用 **eb config** 命令对正在运行的环境应用保存的配置。使用 `--cfg` 选项和保存的配置的名称可将其设置应用于环境。
```
$ eb config --cfg v1
```
在本例中，`v1` 是[之前创建并保存的配置文件](environment-configuration-methods-before.md#configuration-options-before-savedconfig)的名称。
使用此命令应用于环境的设置会覆盖在环境创建期间应用的设置以及在应用程序源包中的配置文件中定义的设置。
### 使用 **eb config**
通过 EB CLI 的 **eb config** 命令，您可以使用文本编辑器直接设置或删除对环境的选项设置。
当您运行 **eb config** 时，EB CLI 会显示从所有源（包括配置文件、保存的配置、建议值、直接对环境设置的选项和 API 默认值）应用于环境的设置。
**注意**
**eb config** 不会显示环境属性。要设置可在您的应用程序中读取的环境属性，请使用 [**eb setenv**](#configuration-options-after-ebcli-ebsetenv)。
下面的示例显示在 `aws:autoscaling:launchconfiguration` 命名空间中应用的设置。这些设置包括：
+ EB CLI 在环境创建期间对 `IamInstanceProfile` 和 `InstanceType` 应用的两个建议值。
+ 在创建期间根据存储库配置直接对环境设置的选项 `EC2KeyName`。
+ 其他选项的 API 默认值。
```
ApplicationName: tomcat
DateUpdated: 2015-09-30 22:51:07+00:00
EnvironmentName: tomcat
SolutionStackName: 64bit Amazon Linux 2015.03 v2.0.1 running Tomcat 8 Java 8
settings:
...
aws:autoscaling:launchconfiguration:
BlockDeviceMappings: null
EC2KeyName: my-key
IamInstanceProfile: aws-elasticbeanstalk-ec2-role
ImageId: ami-1f316660
InstanceType: t2.micro
...
```
**使用 **eb config** 设置或更改配置选项**
1. 运行 **eb config** 查看您的环境配置。
```
~/workspace/my-app/$ eb config
```
1. 使用默认文本编辑器更改任意设置值。
```
aws:autoscaling:launchconfiguration:
BlockDeviceMappings: null
EC2KeyName: my-key
IamInstanceProfile: aws-elasticbeanstalk-ec2-role
ImageId: ami-1f316660
InstanceType: t2.medium
```
1. 保存临时配置文件并退出。
1. EB CLI 更新您的环境配置。
使用 **eb config** 设置配置选项会覆盖所有其他来源的设置。
您也可以使用 **eb config** 删除您的环境中的选项。
**删除配置选项（EB CLI）**
1. 运行 **eb config** 查看您的环境配置。
```
~/workspace/my-app/$ eb config
```
1. 将所有显示的值都替换为字符串 `null`。您也可以删除包含要删除选项的整行。
```
aws:autoscaling:launchconfiguration:
BlockDeviceMappings: null
EC2KeyName: my-key
IamInstanceProfile: aws-elasticbeanstalk-ec2-role
ImageId: ami-1f316660
InstanceType: null
```
1. 保存临时配置文件并退出。
1. EB CLI 更新您的环境配置。
通过 **eb config** 从环境中删除选项，可以使应用程序源包中配置文件中的相应选项设置生效。有关详细信息，请参阅[优先顺序](command-options.md#configuration-options-precedence)。
### 使用 **eb setenv**
要使用 EB CLI 设置环境属性，请使用 **eb setenv**。
```
~/workspace/my-app/$ eb setenv ENVVAR=TEST
INFO: Environment update is starting.
INFO: Updating environment my-env's configuration settings.
INFO: Environment health has transitioned from Ok to Info. Command is executing on all instances.
INFO: Successfully deployed new configuration to environment.
```
此命令在 [`aws:elasticbeanstalk:application:environment` 命名空间](command-options-general.md#command-options-general-elasticbeanstalkapplicationenvironment)中设置环境属性。通过 **eb setenv** 设置的环境属性经过短暂的更新过程即可用于您的应用程序。
使用 **eb printenv** 可查看您的环境中设置的环境属性。
```
~/workspace/my-app/$ eb printenv
Environment Variables:
ENVVAR = TEST
```
## 的 AWS CLI
您可以 AWS CLI 通过部署包含配置文件的源包、应用远程存储的保存配置或使用`aws elasticbeanstalk update-environment`命令直接修改环境来更新配置选项设置。
**Topics**
+ [使用配置文件（`.ebextensions`）](#configuration-options-after-awscli-ebextensions)
+ [使用保存的配置](#configuration-options-after-awscli-savedconfig)
+ [使用命令行选项](#configuration-options-after-awscli-commandline)
### 使用配置文件（`.ebextensions`）
要将配置文件应用于正在运行的环境 AWS CLI，请将其包含在您上传到 Amazon S3 的应用程序源包中。
有关配置文件的详细信息，请参阅[.Ebextensions](ebextensions.md)。
```
~/workspace/my-app-v1.zip
|-- .ebextensions
| |-- environmentvariables.config
| `-- healthcheckurl.config
|-- index.php
`-- styles.css
```
**上传应用程序源包并将其应用于正在运行的环境（AWS CLI）**
1. 如果您在 Amazon S3 中还没有 Elastic Beanstalk 存储桶，请使用 `create-storage-location` 创建一个：
```
$ aws elasticbeanstalk create-storage-location
{
"S3Bucket": "elasticbeanstalk-us-west-2-123456789012"
}
```
1. 将应用程序源包上传到 Amazon S3。
```
$ aws s3 cp sourcebundlev2.zip s3://elasticbeanstalk-us-west-2-123456789012/my-app/sourcebundlev2.zip
```
1. 创建应用程序版本。
```
$ aws elasticbeanstalk create-application-version --application-name my-app --version-label v2 --description MyAppv2 --source-bundle S3Bucket="elasticbeanstalk-us-west-2-123456789012",S3Key="my-app/sourcebundlev2.zip"
```
1. 更新环境。
```
$ aws elasticbeanstalk update-environment --environment-name my-env --version-label v2
```
### 使用保存的配置
通过在 `--template-name` 命令中使用 `aws elasticbeanstalk update-environment` 选项可以对正在运行的环境应用保存的配置。
保存的配置必须位于您的 Elastic Beanstalk 存储桶中，位于 `resources/templates` 下以您的应用程序命名的路径中。例如，对于账户 123456789012，美国西部（俄勒冈）区域（us-west-2）中的 `v1` 应用程序的 `my-app` 模板位于 `s3://elasticbeanstalk-us-west-2-123456789012/resources/templates/my-app/v1`
**对正在运行的环境应用保存的配置（AWS CLI）**
+ 使用 `update-environment` 选项在 `--template-name` 调用中指定保存的配置。
```
$ aws elasticbeanstalk update-environment --environment-name my-env --template-name v1
```
Elastic Beanstalk 在您使用 `aws elasticbeanstalk create-configuration-template` 创建时将保存的配置放在此位置。您也可以在本地修改保存的配置并自行将它们放在此处。
### 使用命令行选项
**使用 JSON 文档更改配置选项（AWS CLI）**
1. 在本地文件中以 JSON 格式定义您的选项设置。
1. 使用 `update-environment` 选项运行 `--option-settings`。
```
$ aws elasticbeanstalk update-environment --environment-name my-env --option-settings file://~/ebconfigs/as-zero.json
```
在本例中，`as-zero.json` 定义使用最少和最大零个实例配置环境的选项。这会停止环境中的实例而不终止环境。
**`~/ebconfigs/as-zero.json`**
```
[
{
"Namespace": "aws:autoscaling:asg",
"OptionName": "MinSize",
"Value": "0"
},
{
"Namespace": "aws:autoscaling:asg",
"OptionName": "MaxSize",
"Value": "0"
},
{
"Namespace": "aws:autoscaling:updatepolicy:rollingupdate",
"OptionName": "RollingUpdateEnabled",
"Value": "false"
}
]
```
**注意**
使用 `update-environment` 设置配置选项会覆盖所有其他来源的设置。
您也可以使用 `update-environment` 删除您的环境中的选项。
**删除配置选项（AWS CLI）**
+ 使用 `update-environment` 选项运行 `--options-to-remove` 命令。
```
$ aws elasticbeanstalk update-environment --environment-name my-env --options-to-remove Namespace=aws:autoscaling:launchconfiguration,OptionName=InstanceType
```
通过 `update-environment` 从环境中删除选项，可以使应用程序源包中配置文件中的相应选项设置生效。如果有一个选项不是使用这些方法中的任何方法配置的，则在有 API 默认值时就会使用 API 默认值。有关详细信息，请参阅[优先顺序](command-options.md#configuration-options-precedence)。
# 面向所有环境的常规选项
**Topics**
+ [aws:autoscaling:asg](#command-options-general-autoscalingasg)
+ [aws:autoscaling:launchconfiguration](#command-options-general-autoscalinglaunchconfiguration)
+ [aws:autoscaling:scheduledaction](#command-options-general-autoscalingscheduledaction)
+ [aws:autoscaling:trigger](#command-options-general-autoscalingtrigger)
+ [aws:autoscaling:updatepolicy:rollingupdate](#command-options-general-autoscalingupdatepolicyrollingupdate)
+ [aws:ec2:instances](#command-options-general-ec2instances)
+ [aws:ec2:vpc](#command-options-general-ec2vpc)
+ [aws:elasticbeanstalk:application](#command-options-general-elasticbeanstalkapplication)
+ [aws:elasticbeanstalk:application:environment](#command-options-general-elasticbeanstalkapplicationenvironment)
+ [aws:elasticbeanstalk:application:environmentsecrets](#command-options-general-elasticbeanstalk-application-environmentsecrets)
+ [aws:elasticbeanstalk:cloudwatch:logs](#command-options-general-cloudwatchlogs)
+ [aws:elasticbeanstalk:cloudwatch:logs:health](#command-options-general-cloudwatchlogs-health)
+ [aws:elasticbeanstalk:command](#command-options-general-elasticbeanstalkcommand)
+ [aws:elasticbeanstalk:environment](#command-options-general-elasticbeanstalkenvironment)
+ [aws:elasticbeanstalk:environment:process:default](#command-options-general-environmentprocess)
+ [aws:elasticbeanstalk:environment:process:process\$1name](#command-options-general-environmentprocess-process)
+ [aws:elasticbeanstalk:environment:proxy:staticfiles](#command-options-general-environmentproxystaticfiles)
+ [aws:elasticbeanstalk:healthreporting:system](#command-options-general-elasticbeanstalkhealthreporting)
+ [aws:elasticbeanstalk:hostmanager](#command-options-general-elasticbeanstalkhostmanager)
+ [aws:elasticbeanstalk:managedactions](#command-options-general-elasticbeanstalkmanagedactions)
+ [aws:elasticbeanstalk:managedactions:platformupdate](#command-options-general-elasticbeanstalkmanagedactionsplatformupdate)
+ [aws:elasticbeanstalk:monitoring](#command-options-general-elasticbeanstalkmonitoring)
+ [aws:elasticbeanstalk:sns:topics](#command-options-general-elasticbeanstalksnstopics)
+ [aws:elasticbeanstalk:sqsd](#command-options-general-elasticbeanstalksqsd)
+ [aws:elasticbeanstalk:trafficsplitting](#command-options-general-elasticbeanstalktrafficsplitting)
+ [aws:elasticbeanstalk:xray](#command-options-general-elasticbeanstalkxray)
+ [aws:elb:healthcheck](#command-options-general-elbhealthcheck)
+ [aws:elb:loadbalancer](#command-options-general-elbloadbalancer)
+ [aws:elb:listener](#command-options-general-elblistener)
+ [aws:elb:listener:listener\$1port](#command-options-general-elblistener-listener)
+ [aws:elb:policies](#command-options-general-elbpolicies)
+ [aws:elb:policies:policy\$1name](#command-options-general-elbpolicies-custom)
+ [aws:elbv2:listener:default](#command-options-general-elbv2-listener-default)
+ [aws:elbv2:listener:listener\$1port](#command-options-general-elbv2-listener)
+ [aws:elbv2:listenerrule:rule\$1name](#command-options-general-elbv2-listenerrule)
+ [aws:elbv2:loadbalancer](#command-options-general-elbv2)
+ [aws:rds:dbinstance](#command-options-general-rdsdbinstance)
## aws:autoscaling:asg
配置环境的 Auto Scaling 组。有关更多信息，请参阅[使用 Auto Scaling 功能自动扩缩 Elastic Beanstalk 环境实例](using-features.managing.as.md)。
**命名空间: `aws:autoscaling:asg`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| Availability Zones | 可用区 (AZs) 是一个 AWS 区域内的不同位置，经过精心设计，可与其他区域的故障隔离开来 AZs。它们为同一地区的其他人提供低成本、低延迟 AZs 的网络连接。 AZs 为您的实例选择数量。 | `Any` | `Any` `Any 1` `Any 2` `Any 3` |
| Cooldown | 冷却时间有助于防止 Amazon EC2 Auto Scaling 在先前活动产生明显影响前启动其他扩展活动。冷却时间是一个调整活动完成后、另一个调整活动开始前的时长（秒）。 | `360` | `0` 到 `10000` |
| Custom Availability Zones | AZs 为您的实例定义。 | 无 | `us-east-1a` `us-east-1b` `us-east-1c` `us-east-1d` `us-east-1e` `eu-central-1` |
| EnableCapacityRebalancing | 指定是否为 Auto Scaling 组中的 Spot 实例启用容量再平衡功能。有关更多信息，请参阅 *Amazon EC2 Auto Scaling 用户指南*中的[容量再平衡](https://docs.aws.amazon.com/autoscaling/ec2/userguide/capacity-rebalance.html)。 只有在 [`aws:ec2:instances`](#command-options-general-ec2instances) 命名空间里将 `EnableSpot` 设置为 `true`，并且 Auto Scaling 组中至少有一个 Spot 实例时，此选项才会相关联。 | `false` | `true` `false` |
| MinSize | 您希望 Auto Scaling 组中拥有的最小实例数。 | `1` | `1` 到 `10000` |
| MaxSize | 您希望 Auto Scaling 组中拥有的最大实例数。 | `4` | `1` 到 `10000` |
## aws:autoscaling:launchconfiguration
配置环境的 Amazon Elastic Compute Cloud（Amazon EC2）实例。
使用 Amazon EC2 启动模板或使用 Auto Scaling 组启动配置资源来创建环境的实例。以下选项适用于这两种资源类型。
有关更多信息，请参阅 [你的 Elastic Beanstalk 环境的亚马逊 EC2 实例](using-features.managing.ec2.md)。此外，您还可以参阅《*Amazon EC2 用户指南*》中的 [Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) 章节中有关 Amazon Elastic Block Store（EBS）的更多信息。
**命名空间: `aws:autoscaling:launchconfiguration`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DisableDefaultEC2SecurityGroup | 当设置为默认值 `false` 时，Elastic Beanstalk 会创建一个默认安全组，该安全组允许来自互联网或负载均衡器的流量通过 HTTP（80）的标准端口。它会在创建环境时将此安全组附加到环境的 EC2 实例。 当设置为 `true` 时，Elastic Beanstalk 不会为新环境的 EC2 实例分配默认安全组。对于现有环境，Elastic Beanstalk 会取消分配您环境的 EC2 实例的默认 EC2 安全组。因此，您还必须设置以下配置： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 如果在 `DisableDefaultEC2SecurityGroup` 设置为 `true` 的环境中为 EC2KeyName 指定了值，则默认安全组不会与 EC2 实例关联。 | `false` | `true` `false` |
| DisableIMDSv1 | 设置为`true`以禁用实例元数据服务版本 1 (IMDSv1) 并强制执行 IMDSv2。 设置为`false`可同时启用 IMDSv1 和 IMDSv2。 根据平台操作系统，您的环境的实例默认如下所示： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 有关更多信息，请参阅[配置实例元数据服务](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html)。 此选项设置可能导致 Elastic Beanstalk 将具有启动配置的现有环境迁移到启动模板。此行为需要具备管理启动模板的必要权限。这些权限包含在我们的托管式策略中。如果您使用自定义策略而非托管式策略，则在更新环境配置时，创建或更新环境可能会失败。有关更多信息和重要注意事项，请参阅[将 Elastic Beanstalk 环境迁移到启动模板](environments-cfg-autoscaling-launch-templates.md)。 | `false` – 基于 Windows 服务器、Amazon Linux 2 及更早版本的平台 `true` – 基于 Amazon Linux 2023 的平台 | `true` `false` |
| EC2KeyName | 您可以使用密钥对安全地登录 EC2 实例。 如果在 `DisableDefaultEC2SecurityGroup` 设置为 `true` 的环境中为 `EC2KeyName` 指定了值，则默认安全组不会与 EC2 实例关联。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 无 | |
| IamInstanceProfile | 实例配置文件允许 AWS Identity and Access Management (IAM) 用户和 AWS 服务访问临时安全证书以进行 AWS API 调用。指定实例配置文件的名称或其 ARN。 示例： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 无 | 实例配置文件名称或 ARN。 |
| ImageId | 通过指定自定义 AMI ID，您可以覆盖默认的 Amazon Machine Image（AMI）。 示例：`ami-1f316660` | 无 | |
| InstanceType | 用于在 Elastic Beanstalk 环境中运行您的应用程序的实例类型。 `InstanceType` 选项已过时。它被 [`InstanceTypes`](#command-options-general-ec2instances) 命名空间中更新、功能更强大的 `aws:ec2:instances` 选项所取代。您可以使用新选项为环境指定一个或多个实例类型的列表。该列表上的第一个值等于此处描述的 `aws:autoscaling:launchconfiguration` 命名空间中包含的 `InstanceType` 选项的值。我们建议您使用新选项指定实例类型。如果指定，则新选项优先于前一个选项。有关更多信息，请参阅 [aws:ec2:instances 命名空间](environments-cfg-autoscaling-configuration-approaches.md#environments-cfg-autoscaling-namespace.instances)。 可用的实例类型取决于使用的可用区和区域。如果您选择子网，则包含该子网的可用区将决定可用的实例类型。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 因账户和区域而异。 | 一种 EC2 实例类型 因账户、区域和可用区而异。您可以获取通过这些值筛选的 Amazon EC2 实例类型的列表。有关更多信息，请参阅《*Amazon EC2 用户指南*》中的[可用实例类型](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes)。 |
| LaunchTemplateTagPropagationEnabled | 设置为 `true`，以允许将环境标签传播到为环境预调配的特定资源的启动模板。 Elastic Beanstalk 只能将标签传播到以下资源的启动模板： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 之所以存在此限制，是因为 CloudFormation 仅允许在为特定资源创建模板时使用标签。有关更多信息，请参阅[TagSpecification](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-tagspecification.html)《*AWS CloudFormation 用户指南》*。 将现有环境的此选项值从更改 `false` 为 `true` 对于先前存在的标签可能是一项重大更改。 启用此功能后，传播标签将需要更换 EC2，这可能会导致停机。您可以启用*滚动更新*以批量应用配置更改，并防止在更新过程中出现停机。有关更多信息，请参阅 [配置更改](environments-updating.md)。 有关启动模板的更多信息，请参阅以下内容： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 有关此选项的更多信息，请参阅 [标签传播到启动模板](applications-tagging-resources.launch-templates.md)。 | `false` | `true` `false` |
| MonitoringInterval | 您希望返回 Amazon CloudWatch 指标的时间间隔（以分钟为单位）。 | `5 minute` | `1 minute` `5 minute` |
| SecurityGroups | 列出分配给 Auto Scaling 组中的 EC2 实例的 Amazon EC2 安全组 ID，以便为这些实例定义防火墙规则。 将此选项与 `DisableDefaultEC2SecurityGroup` 一起使用，可以附加您自己的自定义安全组，这些安全组定义了 EC2 实例的防火墙规则。有关更多信息，请参阅 [负载均衡（多实例）环境](using-features.managing.ec2.instances.sg.md#using-features.managing.ec2.instances.sg.load-balancer-security)。 您可能需要完成一些额外的配置，来防止传入您 EC2 实例的流量被阻止。这仅适用于具有自定义 EC2 安全组的多实例环境。EC2 安全组必须包含入站规则，该规则允许访问从负载均衡器路由的流量。有关更多信息，请参阅 [管理多实例环境中的 EC2 安全组](using-features.managing.ec2.instances.sg.md#using-features.managing.ec2.instances.sg.load-balancer-security)。 您可以提供一串以逗号分隔的值，其中包含现有 Amazon EC2 安全组 ID 或对模板中创建的 AWS::EC2::SecurityGroup 资源的引用。 如果将此命名空间的 `DisableDefaultEC2SecurityGroup` 设置为 `true`，则必须为此选项提供至少一个值。 | `elasticbeanstalk-default` | |
| SSHSourceRestriction | 用于锁定 SSH 对环境的访问权限。例如，您可以锁定 SSH 对 EC2 实例的访问权限，以便只有堡垒主机才能访问私有子网中的实例。 该字符串采用以下形式： `protocol, fromPort, toPort, source_restriction` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) | 无 | |
| BlockDeviceMappings | 在 Auto Scaling 组中的所有实例上挂载其他 Amazon EBS 卷或实例存储卷。 此选项设置可能导致 Elastic Beanstalk 将具有启动配置的现有环境迁移到启动模板。此行为需要具备管理启动模板的必要权限。这些权限包含在我们的托管式策略中。如果您使用自定义策略而非托管式策略，则在更新环境配置时，创建或更新环境可能会失败。有关更多信息和重要注意事项，请参阅[将 Elastic Beanstalk 环境迁移到启动模板](environments-cfg-autoscaling-launch-templates.md)。 映射实例存储卷时，您只需将设备名称映射到卷名称。但是，我们建议在映射 Amazon EBS 卷时，另外指定以下部分或全部字段（每个字段必须用冒号分隔）： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 下面的示例附加三个 Amazon EBS 卷：一个空白 100GB gp2 卷和一个快照、一个具有 2000 个预配置 IOPS 的空白 20GB io1 卷以及一个实例存储卷 `ephemeral0`。如果实例类型支持，则可以附加多个实例存储卷。 `/dev/sdj=:100:true:gp2,/dev/sdh=snap-51eef269,/dev/sdi=:20:true:io1:2000,/dev/sdb=ephemeral0` | 无 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) |
| RootVolumeType | 用于已附加到环境的 EC2 实例的根 Amazon EBS 卷的卷类型（机械硬盘、通用型 SSD 或预置 IOPS SSD）。 此选项设置可能导致 Elastic Beanstalk 将具有启动配置的现有环境迁移到启动模板。此行为需要具备管理启动模板的必要权限。这些权限包含在我们的托管式策略中。如果您使用自定义策略而非托管式策略，则在更新环境配置时，创建或更新环境可能会失败。有关更多信息和重要注意事项，请参阅[将 Elastic Beanstalk 环境迁移到启动模板](environments-cfg-autoscaling-launch-templates.md)。 | 因平台而异。 | 对于机械硬盘存储，为 `standard`。 对于通用型 SSD，为`gp2` 或 `gp3`。 对于预配置的 IOPS SSD，为 `io1`。 |
| RootVolumeSize | 根 Amazon EBS 卷的存储容量（以完整 GB 为单位）。 如果将 `RootVolumeType` 设置为预配置的 IOPS SSD，则是必需的。 例如 。`"64"` | 对于机械硬盘存储和通用型 SSD，因平台而异。 对于预配置的 IOPS SSD，为“无”。 | 对于通用型和预配置的 IOPS SSD，为 `10` 至 `16384` GB。 对于机械硬盘存储，为 `8` 至 `1024` GB。 |
| RootVolumeIOPS | 预配置 IOPS SSD 根卷或通用 `gp3` SSD 根卷所需的每秒 input/output 操作数 (IOPS)。 IOPS 与卷大小的最大比率为 500:1。例如，IOPS 为 3000 的卷至少必须为 6 GiB。 | 无 | 对于 io1 预置 IOPS 固态硬盘根卷，范围为 `100` 到 `20000`。 对于通用型 `gp3` 固态硬盘根卷，范围为 `3000` 到 `16000`。 |
| RootVolumeThroughput | 已附加到环境的 EC2 实例的 Amazon EBS 根卷所需的每秒吞吐量兆字节数（MiB/s）。 此选项仅适用于 `gp3` 存储类型。 | 无 | `125` 到 `1000` |
## aws:autoscaling:scheduledaction
为环境的 Auto Scaling 组配置[计划操作](environments-cfg-autoscaling-scheduledactions.md)。对于每个操作，除了指定选项名称、命名空间和每个设置的值之外，还要指定 `resource_name`。有关示例，请参阅 [aws:autoscaling:scheduledaction 命名空间](environments-cfg-autoscaling-scheduledactions.md#environments-cfg-autoscaling-scheduledactions-namespace)。
**命名空间: `aws:autoscaling:scheduledaction`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| StartTime | 对于一次性操作，请选择运行操作的日期和时间。对于重复操作，请选择激活操作的时间。 | 无 | 跨所有计划的扩展操作的唯一 [ISO-8601 时间戳](http://www.w3.org/TR/NOTE-datetime)。 |
| EndTime | 您希望计划扩展操作停止重复的将来的日期和 UTC/GMT 时间（以时区为单位）。如果未指定 **EndTime**，则操作将根据`Recurrence`表达式重复。 示例：`2015-04-28T04:07:2Z` 当计划的操作结束时，Amazon EC2 Auto Scaling 不会自动恢复到其以前的设置。配置第二个计划操作，以根据需要返回原始设置。 | 无 | 跨所有计划的扩展操作的唯一 [ISO-8601 时间戳](http://www.w3.org/TR/NOTE-datetime)。 |
| MaxSize | 运行操作时要应用的最大实例计数。 | 无 | `0` 到 `10000` |
| MinSize | 运行操作时要应用的最小实例计数。 | 无 | `0` 到 `10000` |
| DesiredCapacity | 为 Auto Scaling 组设置初始所需容量。在应用计划的操作后，触发器将根据其设置调整所需容量。 | 无 | `0` 到 `10000` |
| Recurrence | 您希望计划操作发生的频率。如果不指定循环，则扩展操作仅发生一次，如 `StartTime` 所指定。 | 无 | [Cron](http://en.wikipedia.org/wiki/Cron) 表达式。 |
| Suspend | 设置为 `true` 可临时停用重复的计划操作。 | `false` | `true` `false` |
## aws:autoscaling:trigger
为环境的 Auto Scaling 组配置扩展触发器。
**注意**
此命名空间中的三个选项确定在触发器启用之前触发器指标可超出其定义的限制多长时间。这些选项具有相关性，如下所述：
`BreachDuration = Period * EvaluationPeriods`
这些选项的默认值（分别是 5、5 和 1）满足此等式。如果您指定不一致的值，Elastic Beanstalk 可能会修改其中某个值，以便等式仍然成立。
**命名空间: `aws:autoscaling:trigger`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| BreachDuration | 调用触发器前，指标可以超出所定义限制（如 `UpperThreshold` 和 `LowerThreshold` 所指定）的时间（单位：分钟）。 | `5` | `1` 到 `600` |
| LowerBreachScaleIncrement | 执行扩展活动时要移除的 Amazon EC2 实例的数量。 | `-1` | |
| LowerThreshold | 如果测量值低于该违例持续时间值，则会调用触发器。 | `2000000` | `0` 到 `20000000` |
| MeasureName | 用于 Auto Scaling 触发器的指标。 `HealthyHostCount`、`UnhealthyHostCount` 和 `TargetResponseTime` 仅适用于具有专用负载均衡器的环境。对于配置了共享负载均衡器的环境，这些值不是有效指标值。有关负载均衡器类型的更多信息，请参阅 [Elastic Beanstalk 环境的负载均衡器](using-features.managing.elb.md)。 | `NetworkOut` | `CPUUtilization` `NetworkIn` `NetworkOut` `DiskWriteOps` `DiskReadBytes` `DiskReadOps` `DiskWriteBytes` `Latency` `RequestCount` `HealthyHostCount` `UnhealthyHostCount` `TargetResponseTime` |
| Period | 指定 Amazon CloudWatch 衡量触发器指标的频率。此值是两个连续时间段之间的分钟数。 | `5` | `1` 到 `600` |
| EvaluationPeriods | 用于确定是否违例的连续评估期的数量。 | `1` | `1` 到 `600` |
| Statistic | 触发器使用的统计数据，例如 `Average`。 | `Average` | `Minimum` `Maximum` `Sum` `Average` |
| Unit | 触发器度量单位，例如 `Bytes`。 | `Bytes` | `Seconds` `Percent` `Bytes` `Bits` `Count` `Bytes/Second` `Bits/Second` `Count/Second` `None` |
| UpperBreachScaleIncrement | 执行扩展活动时，指定要添加的 Amazon EC2 实例的数量。 | `1` | |
| UpperThreshold | 如果测量值高于该违例持续时间值，则会调用触发器。 | `6000000` | `0` 到 `20000000` |
## aws:autoscaling:updatepolicy:rollingupdate
为您环境的 Auto Scaling 组配置滚动更新。
**命名空间: `aws:autoscaling:updatepolicy:rollingupdate`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| MaxBatchSize | 滚动更新的每个批次中包含的实例数。 | Auto Scaling 组的最小大小的三分之一（舍入到下一个最大整数） | `1` 到 `10000` |
| MinInstancesInService | 终止其他实例时，Auto Scaling 组中必须处于运行中的最小实例数。 | Auto Scaling 组的最小大小，或 Auto Scaling 组的最大大小减一（取二者中的较小值）。 | `0` 到 `9999` |
| RollingUpdateEnabled | 如果为 `true`，则为环境启用滚动更新。在您需要对 Elastic Beanstalk 软件应用程序进行频繁的少量更新，并且希望避免应用程序停机时，滚动更新很有用。 将此值设置为 true 会自动启用 `MaxBatchSize`、`MinInstancesInService` 和 `PauseTime` 选项。设置这些选项中的任何选项也会自动将 `RollingUpdateEnabled` 选项值设置为 `true`。将此选项设置为 `false` 会禁用滚动更新。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `false` | `true` `false` |
| RollingUpdateType | 其中包括三种类型：基于时间的滚动更新、基于运行状况的滚动更新和不可变更新。 基于时间的滚动更新在批次 PauseTime 之间应用。基于运行状况的滚动更新会等新实例通过运行状况检查后再继续下一个批次。[不可变更新](environmentmgmt-updates-immutable.md)将启动新 Auto Scaling 组中的一整组实例。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `Time` | `Time` `Health` `Immutable` |
| PauseTime | Elastic Beanstalk 服务在完成一批实例更新之后到开始下一批实例更新之前要等待的时长（以秒、分钟或小时为单位）。 | 基于实例类型和容器自动计算。 | `PT0S`\$1（0 秒）至 `PT1H`（1 小时） |
| Timeout | 在取消更新之前，等待一个实例批次中的所有实例通过运行状况检查的最长时间（以分钟或小时为单位）。 | `PT30M`（30 分钟） | `PT5M`\$1（5 分钟）至 `PT1H`（1 小时） \$1 [ISO8601持续时间](http://en.wikipedia.org/wiki/ISO_8601#Durations)格式：`PT#H#M#S`其中每个 \$1 分别是小时、分钟、 and/or 秒数。 |
## aws:ec2:instances
配置环境的实例，包括 Spot 选项。此命名空间是 [`aws:autoscaling:launchconfiguration`](#command-options-general-autoscalinglaunchconfiguration) 和 [`aws:autoscaling:asg`](#command-options-general-autoscalingasg) 的补充。
有关更多信息，请参阅 [使用 Auto Scaling 功能自动扩缩 Elastic Beanstalk 环境实例](using-features.managing.as.md)。
**命名空间: `aws:ec2:instances`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| EnableSpot | 为您的环境启用 Spot 实例请求。如果为 `false`，此命名空间中的某些选项不会生效。 此选项设置可能导致 Elastic Beanstalk 将具有启动配置的现有环境迁移到启动模板。此行为需要具备管理启动模板的必要权限。这些权限包含在我们的托管式策略中。如果您使用自定义策略而非托管式策略，则在更新环境配置时，创建或更新环境可能会失败。有关更多信息和重要注意事项，请参阅[将 Elastic Beanstalk 环境迁移到启动模板](environments-cfg-autoscaling-launch-templates.md)。 | `false` | `true` `false` |
| InstanceTypes | 您希望环境使用的实例类型的逗号分隔列表（例如，`t2.micro,t3.micro`）。 当 `EnableSpot` 为 `true` 且 `SpotAllocationStrategy` 设置为 `capacity-optimized-prioritized` 时，此选项中指定的值列表决定了竞价型实例分配策略的实例类型优先级。 当未激活 Spot 实例（`EnableSpot` 为 `false`）时，仅使用列表中的第一种实例类型。 此选项的列表中的第一个实例类型等同于 [`InstanceType`](#command-options-general-autoscalinglaunchconfiguration) 命名空间中的 `aws:autoscaling:launchconfiguration` 选项的值。我们不建议使用后一个选项，因为它已经过时了。如果您同时指定两者，则使用 `InstanceTypes` 选项的列表中的第一个实例类型，并忽略 `InstanceType`。 可用的实例类型取决于使用的可用区和区域。如果您选择子网，则包含该子网的可用区将决定可用的实例类型。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 一些较旧的 AWS 账户可能会为 Elastic Beanstalk 提供不支持竞价型实例的默认实例类型（例如 t1.micro）。如果激活 Spot 实例请求，并收到不支持 Spot 的实例类型的相关错误，请务必配置支持 Spot 的实例类型。要选择 Spot 实例类型，请使用 [Spot Instance Advisor](https://aws.amazon.com/ec2/spot/instance-advisor/)。 当您更新环境配置并从 `InstanceTypes` 选项中删除一个或多个实例类型时，Elastic Beanstalk 会终止在任何已删除的实例类型上运行的任何 Amazon EC2 实例。然后，您环境的 Auto Scaling 组根据需要启动新实例，以使用当前指定的实例类型来完成所需的容量。 | 两种实例类型的列表。 因账户和区域而异。 | 一到四十种 EC2 实例类型。我们建议至少两种。 因账户、区域和可用区而异。您可以获取通过这些值筛选的 Amazon EC2 实例类型的列表。有关更多信息，请参阅《*Amazon EC2 用户指南*》中的[可用实例类型](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes)。 实例类型必须均属于同一架构（`arm64`、`x86_64`、`i386`）。 `SupportedArchitectures` 也是此命名空间的一部分。如果您为 `SupportedArchitectures` 提供了任何值，则为 `InstanceTypes` 输入的值必须属于且仅属于为 `SupportedArchitectures` 提供的架构之一。 |
| SpotAllocationStrategy | 指定[竞价型实例分配策略](environments-cfg-autoscaling-spot-allocation-strategy.md)，该策略决定了可用竞价型容量池中竞价型实例的分配方式。 如果设置为 `capacity-optimized-prioritized`，则 `InstanceTypes` 中值的顺序将决定分配时的实例类型优先级。 此选项仅在 `EnableSpot` 为 `true` 时有意义。 | `capacity-optimized` | `capacity-optimized` `price-capacity-optimized` `capacity-optimized-prioritized` `lowest-price ` |
| SpotFleetOnDemandBase | 扩展环境时，在考虑 Spot 实例之前，Auto Scaling 组预配置的最小按需实例数。 此选项仅在 `EnableSpot` 为 `true` 时有意义。 | `0` | [`0`](#command-options-general-autoscalingasg) 命名空间中 `MaxSize` 至 `aws:autoscaling:asg` 选项 |
| SpotFleetOnDemandAboveBasePercentage | Auto Scaling 组在 `SpotOnDemandBase` 实例之外作为额外容量预配置的按需实例的百分比。 此选项仅在 `EnableSpot` 为 `true` 时有意义。 | `0` 适用于单实例环境 `70` 适用于负载均衡环境 | `0` 到 `100` |
| SpotMaxPrice | 您愿意为 Spot 实例支付的每单位小时的最高价（USD）。有关竞价型实例最高价格选项的建议，请参阅《*Amazon EC2 用户指南*》中的[竞价型实例定价历史记录](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html)。 此选项仅在 `EnableSpot` 为 `true` 时有意义。 | 每种实例类型的按需价格。在这种情况下，该选项的值为 `null`。 | `0.001` 到 `20.0` `null` |
| SupportedArchitectures | 您希望环境使用的 EC2 实例架构类型的逗号分隔列表。 Elastic Beanstalk 支持基于以下处理器架构的实例类型： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 有关处理器架构和 Amazon EC2 实例类型的更多信息，请参阅 [Amazon EC2 实例类型](using-features.managing.ec2.instance-types.md)。 | 无 | `arm64` `x86_64` `i386` 大多数 Elastic Beanstalk 平台都不支持 32 位架构 `i386`。我们建议您选择 `x86_64` 或 `arm64` 架构类型代替。 |
## aws:ec2:vpc
配置环境以在自定义 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/)（Amazon VPC）中启动资源。如果您不在此命名空间中配置设置，Elastic Beanstalk 将在默认 VPC 中启动资源。
**命名空间: `aws:ec2:vpc`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| VPCId | 您的 Amazon VPC 的 ID。 | 无 | |
| Subnets | Auto Scaling 组 IDs 的一个或多个子网中的一个或多个子网。如果您有多个子网，请将该值指定为一个以逗号分隔的子网字符串 IDs （例如）。`"subnet-11111111,subnet-22222222"` | 无 | |
| ELBSubnets | 弹性负载均衡器 IDs 的一个或多个子网的。如果您有多个子网，请将该值指定为一个以逗号分隔的子网字符串 IDs（例如）。`"subnet-11111111,subnet-22222222"` | 无 | |
| ELBScheme | 如果您要在 Amazon VPC 中创建一个内部负载均衡器，请指定 `internal`，从而确保不能从 Amazon VPC 的外部访问您的 Elastic Beanstalk 应用程序。如果指定 `public` 或 `internal` 以外的值，Elastic Beanstalk 会忽略此值。 | `public` | `public` `internal` |
| DBSubnets | 包含数据库 IDs 子网的。这仅可用于以下情况：需要将 Amazon RDS 数据库实例添加到应用程序中。如果您有多个子网，请将该值指定为一个以逗号分隔的子网字符串 IDs （例如）。`"subnet-11111111,subnet-22222222"` | 无 | |
| AssociatePublicIpAddress | 指定是否在您的 Amazon VPC 中启动具有公有 IP 地址的实例。具有公有 IP 地址的实例无需 NAT 设备即可与 Internet 通信。如果要在单个公有子网中包含您的负载均衡器和实例，则必须将值设置为 `true`。 此选项对单实例环境没有影响，该环境始终具有带弹性 IP 地址的单个 Amazon EC2 实例。该选项与负载平衡、可扩展的环境相关。 | 无 | `true` `false` |
## aws:elasticbeanstalk:application
为您的应用程序配置运行状况检查路径。有关更多信息，请参阅 [基本运行状况报告](using-features.healthstatus.md)。
**命名空间: `aws:elasticbeanstalk:application`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| 应用程序运行状况检查 URL | 运行状况检查请求发送到的路径。如果未设置此路径，负载均衡器将尝试在端口 80 上建立一个 TCP 连接，以验证应用程序的运行状况状态。设置为以 `/` 开头的路径可将 HTTP GET 请求发送到该路径。您还可以在该路径前面包含协议 (HTTP、HTTPS、TCP 或 SSL) 和端口以检查 HTTPS 连接情况或使用非默认端口。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 无 | 有效值包括： `/` (HTTP GET to root path) `/health` `HTTPS:443/` `HTTPS:443/health` |
EB CLI 和 Elastic Beanstalk 控制台会对前面的选项应用建议的值。如果您需要使用配置文件来配置相同的项，则必须删除这些设置。有关更多信息，请参阅 [建议值](command-options.md#configuration-options-recommendedvalues)。
## aws:elasticbeanstalk:application:environment
为您的应用程序配置环境属性。
**命名空间: `aws:elasticbeanstalk:application:environment`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| 任意环境变量名称。 | 传入密钥-值对。 | 无 | 任意环境变量值。 |
请参阅[环境变量和其他软件设置](environments-cfg-softwaresettings.md)了解更多信息。
## aws:elasticbeanstalk:application:environmentsecrets
配置环境变量以用作应用程序的*环境密钥*。环境密钥存储 AWS Secrets Manager 密钥或 AWS Systems Manager 参数存储参数。
**命名空间: `aws:elasticbeanstalk:application:environmentsecrets`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| OptionName | 指定用于保存密钥存储库或参数存储值的环境变量的名称。 | 无 | 任意环境变量名称。 |
| 值 | 为存储在 AWS Secrets Manager 或 AWS Systems Manager 参数存储中的值指定 ARN。在实例引导期间，Elastic Beanstalk 会将环境变量初始化为存储在此 ARN 资源中的值。 确保您的环境的 EC2 实例配置文件角色拥有访问密钥和参数所需的权限 ARNs。有关更多信息，请参阅 [所需的 IAM 权限](AWSHowTo.secrets.IAM-permissions.md)。 | None（无） | AWS Secrets Manager 密钥或 AWS Systems Manager 参数存储参数值的有效 ARN 值。 |
有关更多信息，请参阅 [将密钥配置为环境变量](AWSHowTo.secrets.env-vars.md)。
## aws:elasticbeanstalk:cloudwatch:logs
为应用程序配置实例日志流式传输。
**命名空间: `aws:elasticbeanstalk:cloudwatch:logs`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| StreamLogs | 指定是否在 CloudWatch 日志中为代理和部署日志创建组，以及是否从环境中的每个实例流式传输日志。 | `false` | `true` `false` |
| DeleteOnTerminate | 指定是否在环境终止后删除日志组。如果为 `false`，则日志保留 `RetentionInDays` 天。 | `false` | `true` `false` |
| RetentionInDays | 日志事件在到期前保留的天数。 | 7 | 1、3、5、7、14、30、60、90、120、150、180、365、400、545、731、1827、3653 |
## aws:elasticbeanstalk:cloudwatch:logs:health
为应用程序配置环境运行状况日志流式传输。
**命名空间: `aws:elasticbeanstalk:cloudwatch:logs:health`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| HealthStreamingEnabled | 对于启用了增强型运行状况报告的环境，指定是否在环境运行状况 CloudWatch 日志中创建群组并存档 Elastic Beanstalk 环境运行状况数据。有关启用增强型运行状况的信息，请参阅 [`aws:elasticbeanstalk:healthreporting:system`](#command-options-general-elasticbeanstalkhealthreporting)。 | `false` | `true` `false` |
| DeleteOnTerminate | 指定是否在终止环境后删除日志组。如果为 `false`，则运行状况数据将保留 `RetentionInDays` 天。 | `false` | `true` `false` |
| RetentionInDays | 在存档的运行状况数据过期前要保留其的天数。 | 7 | 1、3、5、7、14、30、60、90、120、150、180、365、400、545、731、1827、3653 |
## aws:elasticbeanstalk:command
为您的应用程序代码配置部署策略。有关更多信息，请参阅 [部署策略和设置](using-features.rolling-version-deploy.md)。
**命名空间: `aws:elasticbeanstalk:command`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DeploymentPolicy | 选择应用程序版本部署的[部署策略](using-features.rolling-version-deploy.md)。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `AllAtOnce` | `AllAtOnce` `Rolling` `RollingWithAdditionalBatch` `Immutable` `TrafficSplitting` |
| Timeout | 等待实例完成执行命令的时间（单位：秒）。 Elastic Beanstalk 内部向 `Timeout` 值添加 240 秒（4 分钟）。例如，默认的有效超时为 840 秒（600 \$1 240）或 14 分钟。 | `600` | `1` 到 `3600` |
| BatchSizeType | 中指定的数字类型**BatchSize**。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `Percentage` | `Percentage` `Fixed` |
| BatchSize | Auto Scaling 组中要同时执行部署的 Amazon EC2 实例的百分比或固定数量。有效值因使用的**BatchSizeType**设置而异。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `100` | `1` 到 `100` (`Percentage`)。 `1`到 [aws: autoscaling: asg](#command-options-general-autoscalingasg):: () MaxSize `Fixed` |
| IgnoreHealthCheck | 不要由于运行状况检查失败而取消部署。 | false | `true` `false` |
## aws:elasticbeanstalk:environment
配置您的环境的架构和服务角色。
**命名空间: `aws:elasticbeanstalk:environment`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| EnvironmentType | 设置为 `SingleInstance` 可启动一个 EC2 实例而无需负载均衡器。 | `LoadBalanced` | `SingleInstance` `LoadBalanced` |
| ServiceRole | 一个 IAM 角色的名称，该角色供 Elastic Beanstalk 用来管理环境的资源。指定角色名称（可以选择添加自定义路径作为前缀）或其 ARN。 示例： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 无 | IAM 角色名称、路径/名称或 ARN |
| LoadBalancerType | 用于环境的负载均衡器的类型。有关更多信息，请参阅 [Elastic Beanstalk 环境的负载均衡器](using-features.managing.elb.md)。 | `classic` | `classic` `application` `network` |
| LoadBalancerIsShared | 指定环境的负载均衡器是专用的还是共享的。只能为 Application Load Balancer 设置此选项。环境创建后无法更改。 当为 `false` 时，环境具有自己的专用负载均衡器（由 Elastic Beanstalk 创建和管理）。当为 `true` 时，环境使用共享的负载均衡器，该负载均衡器由您创建并在 [aws:elbv2:loadbalancer](#command-options-general-elbv2) 命名空间的 `SharedLoadBalancer` 选项中指定。 | `false` | `true` `false` |
## aws:elasticbeanstalk:environment:process:default
配置您的环境的默认过程。
**命名空间: `aws:elasticbeanstalk:environment:process:default`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DeregistrationDelay | 在取消注册之前等待活动请求完成的时间（单位：秒）。 | `20` | `0` 到 `3600` |
| HealthCheckInterval | Elastic Load Balancing 检查应用程序的 Amazon EC2 实例运行状况的时间间隔（单位：秒）。 | 使用 Classic 或应用程序负载均衡器：`15` 使用网络负载均衡器：`30` | 使用 Classic 或应用程序负载均衡器：`5` 至 `300` 使用网络负载均衡器：`10`、`30` |
| HealthCheckPath | 运行状况检查的 HTTP 请求发送到的路径。 | `/` | 可路由路径。 |
| HealthCheckTimeout | 在运行状况检查期间等待响应的时间（单位：秒）。 此选项仅适用于使用应用程序负载均衡器的环境。 | `5` | `1` 到 `60` |
| HealthyThresholdCount | Elastic Load Balancing 更改实例运行状况状态前的连续成功请求数。 | 使用 Classic 或应用程序负载均衡器：`3` 使用网络负载均衡器：`5` | `2` 到 `10` |
| MatcherHTTPCode | 指示实例正常的 HTTP 代码 (以逗号分隔) 的列表。 此选项仅适用于使用网络或应用程序负载均衡器的环境。 | `200` | 使用应用程序负载均衡器：`200` 至 `499` 使用网络负载均衡器：`200` 至 `399` |
| Port | 进程侦听的端口。 | `80` | `1` 到 `65535` |
| Protocol | 进程使用的协议。 使用应用程序负载均衡器时，您只能将此选项设置为 `HTTP` 或 `HTTPS`。 使用网络负载均衡器时，您只能将此选项设置为 `TCP`。 | 使用 Classic 或应用程序负载均衡器：`HTTP` 使用网络负载均衡器：`TCP` | `TCP` `HTTP` `HTTPS` |
| StickinessEnabled | 设置为 true 可启用粘性会话。 此选项仅适用于使用应用程序负载均衡器的环境。 | `'false'` | `'false'` `'true'` |
| StickinessLBCookieDuration | 粘性会话 Cookie 的生存期（单位：秒） 此选项仅适用于使用应用程序负载均衡器的环境。 | `86400` (一天) | `1` 到 `604800` |
| StickinessType | 设置为 `lb_cookie` 可以为粘性会话使用 Cookie。 此选项仅适用于使用应用程序负载均衡器的环境。 | `lb_cookie` | `lb_cookie` |
| UnhealthyThresholdCount | Elastic Load Balancing 更改实例运行状况状态前的连续失败请求数。 | `5` | `2` 到 `10` |
## aws:elasticbeanstalk:environment:process:process\$1name
配置您的环境的其他过程。
**命名空间: `aws:elasticbeanstalk:environment:process:process_name`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DeregistrationDelay | 在取消注册之前等待活动请求完成的时间（单位：秒）。 | `20` | `0` 到 `3600` |
| HealthCheckInterval | Elastic Load Balancing 检查应用程序的 Amazon EC2 实例运行状况的时间间隔（单位：秒）。 | 使用 Classic 或应用程序负载均衡器：`15` 使用网络负载均衡器：`30` | 使用 Classic 或应用程序负载均衡器：`5` 至 `300` 使用网络负载均衡器：`10`、`30` |
| HealthCheckPath | 运行状况检查的 HTTP 请求发送到的路径。 | `/` | 可路由路径。 |
| HealthCheckTimeout | 在运行状况检查期间等待响应的时间（单位：秒）。 此选项仅适用于使用应用程序负载均衡器的环境。 | `5` | `1` 到 `60` |
| HealthyThresholdCount | Elastic Load Balancing 更改实例运行状况状态前的连续成功请求数。 | 使用 Classic 或应用程序负载均衡器：`3` 使用网络负载均衡器：`5` | `2` 到 `10` |
| MatcherHTTPCode | 指示实例正常的 HTTP 代码（以逗号分隔）的列表。 此选项仅适用于使用网络或应用程序负载均衡器的环境。 | `200` | 使用应用程序负载均衡器：`200` 至 `499` 使用网络负载均衡器：`200` 至 `399` |
| Port | 进程侦听的端口。 | `80` | `1` 到 `65535` |
| Protocol | 进程使用的协议。 使用应用程序负载均衡器时，您只能将此选项设置为 `HTTP` 或 `HTTPS`。 使用网络负载均衡器时，您只能将此选项设置为 `TCP`。 | 使用 Classic 或应用程序负载均衡器：`HTTP` 使用网络负载均衡器：`TCP` | `TCP` `HTTP` `HTTPS` |
| StickinessEnabled | 设置为 true 可启用粘性会话。 此选项仅适用于使用应用程序负载均衡器的环境。 | `'false'` | `'false'` `'true'` |
| StickinessLBCookieDuration | 粘性会话 Cookie 的生存期（单位：秒） 此选项仅适用于使用应用程序负载均衡器的环境。 | `86400` (一天) | `1` 到 `604800` |
| StickinessType | 设置为 `lb_cookie` 可以为粘性会话使用 Cookie。 此选项仅适用于使用应用程序负载均衡器的环境。 | `lb_cookie` | `lb_cookie` |
| UnhealthyThresholdCount | Elastic Load Balancing 更改实例运行状况状态前的连续失败请求数。 | `5` | `2` 到 `10` |
## aws:elasticbeanstalk:environment:proxy:staticfiles
您可以使用以下命名空间来配置代理服务器提供静态文件。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。这将减少您的应用程序必须处理的请求的数量。
在源代码中将代理服务器提供的路径映射到包含静态资产的文件夹。在此命名空间中定义的每个选项都映射不同的路径。
**注意**
此命名空间适用于基于 Amazon Linux 2 的平台分支。如果您的环境使用基于 Amazon Linux AMI（在 Amazon Linux 2 之前）的平台版本，请参阅[特定于平台的选项](command-options-specific.md)以获取特定于平台的静态文件命名空间。
**命名空间: `aws:elasticbeanstalk:environment:proxy:staticfiles`**
| **名称** | **值** |
| --- | --- |
| 代理服务器提供文件的路径。值以 `/` 开始。 例如，指定 `/images` 以在 `subdomain.eleasticbeanstalk.com/images` 提供文件。 | 包含文件的文件夹名称。 例如，指定 `staticimages` 以在源代码包顶层从名为 `staticimages` 的文件夹中提供文件。 |
## aws:elasticbeanstalk:healthreporting:system
为您的环境配置增强型运行状况报告。
**命名空间: `aws:elasticbeanstalk:healthreporting:system`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| SystemType | 运行状况报告系统（[基本](using-features.healthstatus.md)或[增强](health-enhanced.md)）。增强型运行状况报告需要一个[服务角色](concepts-roles-service.md)和一个版本 2 或更高的[平台版本](concepts.platforms.md)。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `basic` | `basic` `enhanced` |
| ConfigDocument | 一个 JSON 文档，描述要发布到的环境和实例指标 CloudWatch。 | 无 | |
| EnhancedHealthAuthEnabled | 为内部 API 启用授权，Elastic Beanstalk 使用此授权将增强型运行状况信息从您的环境实例传达到 Elastic Beanstalk 服务。 有关更多信息，请参阅 [增强型运行状况角色](health-enhanced.md#health-enhanced-roles)。 此选项仅适用于增强型运行状况报告（例如 `SystemType` 设置为 `enhanced` 时）。 | `true` | `true` `false` |
| HealthCheckSuccessThreshold | 降低阈值以便实例能够通过运行状况检查。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `Ok` | `Ok` `Warning` `Degraded` `Severe` |
## aws:elasticbeanstalk:hostmanager
在环境中配置 EC2 实例以将轮换日志上传到 Amazon S3。
**命名空间: `aws:elasticbeanstalk:hostmanager`**
| **名称** | **描述** | **默认** | 有效值 |
| --- | --- | --- | --- |
| LogPublicationControl | 将应用程序的 Amazon EC2 实例日志文件复制到与应用程序相关联的 Amazon S3 存储桶。 | `false` | `true` `false` |
## aws:elasticbeanstalk:managedactions
为您的环境配置托管平台更新。
**命名空间: `aws:elasticbeanstalk:managedactions`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ManagedActionsEnabled | 启用[托管平台更新](environment-platform-update-managed.md#environment-platform-update-managed-namespace)。 在将此项设置为 `true` 时，还必须指定 `PreferredStartTime` 和 `UpdateLevel`。 | `false` | `true` `false` |
| PreferredStartTime | 配置托管操作的维护时段 (采用 UTC 表示)。 例如 `"Tue:09:00"`。 | 无 | 日期和时间 *day*:*hour*:*minute* 格式的日期和时间。 |
| ServiceRoleForManagedUpdates | Elastic Beanstalk 用于为您的环境执行托管平台更新的 IAM 角色的名称。 您可以使用为 `ServiceRole` 命名空间的 `aws:elasticbeanstalk:environment` 选项指定同一个角色，也可以使用账户的[托管更新服务相关角色](using-service-linked-roles-managedupdates.md)。在后一种情况下，如果账户还没有托管更新服务相关角色，Elastic Beanstalk 会创建该角色。 | 无 | 与 `ServiceRole` 相同 或 `AWSServiceRoleForElasticBeanstalkManagedUpdates` |
## aws:elasticbeanstalk:managedactions:platformupdate
为您的环境配置托管平台更新。
**命名空间: `aws:elasticbeanstalk:managedactions:platformupdate`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| UpdateLevel | 要通过托管平台更新应用的最高级别的更新。平台已版本化。*major* *minor*。 *patch*。例如，在 2.0.8 中，主版本为 2，次版本为 0，修补版本为 8。 | 无 | `patch` 仅适用于修补版本更新。 `minor` 适用于次版本更新和修补版本更新。 |
| InstanceRefreshEnabled | 启用每周实例替换。 需要将 `ManagedActionsEnabled` 设置为 `true`。 | false | `true` `false` |
## aws:elasticbeanstalk:monitoring
配置您的环境以终止运行状况检查失败的 EC2 实例。
**命名空间: `aws:elasticbeanstalk:monitoring`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| Automatically Terminate Unhealthy Instances | 如果实例无法通过运行状况检查，请将其终止。 此选项仅在[早期环境](using-features.migration.md)上受支持。它根据能够达到实例的运行状况及其他基于实例的指标确定了实例的运行状况。 Elastic Beanstalk 不提供根据应用程序运行状况自动终止实例的方法。 | `true` | `true` `false` |
## aws:elasticbeanstalk:sns:topics
为您的环境配置通知。
**命名空间: `aws:elasticbeanstalk:sns:topics`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| Notification Endpoint | 在该端点处，系统会通知您对应用程序产生影响的重要事件。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | 无 | |
| Notification Protocol | 用于向您的端点发送通知的协议。 | `email` | `http` `https` `email` `email-json` `sqs` |
| Notification Topic ARN | 已订阅主题的 Amazon Resource Name (ARN)。 | 无 | |
| Notification Topic Name | 已订阅主题的名称。 | 无 | |
## aws:elasticbeanstalk:sqsd
为工作线程环境配置 Amazon SQS 队列。
**命名空间: `aws:elasticbeanstalk:sqsd`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| WorkerQueueURL | 队列的 URL，工作线程环境层中的守护程序从该队列读取消息。 当您不指定值时，Elastic Beanstalk 自动创建的队列是[标准](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues.html) Amazon SQS 队列。当您提供值时，可以提供标准或 [FIFO](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html) Amazon SQS 队列的 URL。请注意，如果提供 FIFO 队列，不支持[定期任务](using-features-managing-env-tiers.md#worker-periodictasks)。 | 自动生成 | 如果您不指定值，则 Elastic Beanstalk 会自动创建队列。 |
| HttpPath | 将 HTTP POST 消息发送到的应用程序的相对路径。 | / | |
| MimeType | HTTP POST 请求中发送的消息的 MIME 类型。 | `application/json` | `application/json` `application/x-www-form-urlencoded` `application/xml` `text/plain` 自定义 MIME 类型。 |
| HttpConnections | 与 Amazon EC2 实例中任何应用程序之间的最大并发连接数。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `50` | `1` 到 `100` |
| ConnectTimeout | 等待成功连接到应用程序的时长（单位：秒）。 | `5` | `1` 到 `60` |
| InactivityTimeout | 在与应用程序的现有连接上等待响应的时长（单位：秒）。消息会重新处理，直到守护程序从工作线程环境层中的应用程序收到 200 (OK) 响应或 RetentionPeriod 过期。 | `299` | `1` 到 `36000` |
| VisibilityTimeout | 锁定来自 Amazon SQS 队列的入站消息以进行处理的时长（以秒为单位）。在配置的时长之后，再次使消息在队列中可见，以供任何其他守护程序读取。 | 300 | `0` 到 `43200` |
| ErrorVisibilityTimeout | 在处理尝试由于显式错误而失败后，Elastic Beanstalk 将消息返回到 Amazon SQS 队列之前经过的时长（以秒为单位）。 | `2` 秒 | `0` 至 `43200` 秒 |
| RetentionPeriod | 消息有效和等待主动处理的时长（单位：秒） | `345600` | `60` 到 `1209600` |
| MaxRetries | Elastic Beanstalk 在将消息移动到死信队列之前，尝试向处理消息的 Web 应用程序发送消息的最大尝试次数。 | `10` | `1` 到 `100` |
## aws:elasticbeanstalk:trafficsplitting
为您的环境配置流量拆分部署。
当您将 [aws:elasticbeanstalk:command](#command-options-general-elasticbeanstalkcommand) 命名空间的 `DeploymentPolicy` 选项设置为 `TrafficSplitting` 时，将应用此命名空间。有关部署策略的更多信息，请参阅[部署策略和设置](using-features.rolling-version-deploy.md)。
**命名空间: `aws:elasticbeanstalk:trafficsplitting`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| NewVersionPercent | 对于运行您正在部署的新应用程序版本的环境实例，Elastic Beanstalk 转移到这些实例的传入客户端流量的初始百分比。 | `10` | `1` 到 `100` |
| EvaluationTime | 在初始正常部署之后，Elastic Beanstalk 等待的时间段（以分钟为单位），在经过该时间后，会继续将所有传入的客户端流量转移到正在部署的新应用程序版本。 | `5` | `3` 到 `600` |
## aws:elasticbeanstalk:xray
运行 AWS X-Ray 守护程序以中继来自 [X-Ray 集成](environment-configuration-debugging.md)应用程序的跟踪信息。
**命名空间: `aws:elasticbeanstalk:xray`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| `XRayEnabled` | 设为 `true` 可在环境中的实例上运行 X-Ray 守护程序。 | `false` | `true` `false` |
## aws:elb:healthcheck
为经典负载均衡器配置运行状况检查。
**命名空间: `aws:elb:healthcheck`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| HealthyThreshold | Elastic Load Balancing 更改实例运行状况状态前的连续成功请求数。 | `3` | `2` 到 `10` |
| Interval | Elastic Load Balancing 检查应用程序的 Amazon EC2 实例运行状况的时间间隔。 | `10` | `5` 到 `300` |
| Timeout | Elastic Load Balancing 在将实例视为无响应之前等待的时间（单位：秒） | `5` | `2` 到 `60` |
| UnhealthyThreshold | Elastic Load Balancing 更改实例运行状况状态前的连续失败请求数。 | `5` | `2` 到 `10` |
| （已弃用）Target | 运行状况检查发送到的后端实例上的目标。请改为在 [`Application Healthcheck URL`](#command-options-general-elasticbeanstalkapplication) 命名空间中使用 `aws:elasticbeanstalk:application`。 | `TCP:80` | 目标格式为*PROTOCOL*：*PORT**/PATH* |
## aws:elb:loadbalancer
配置您环境的经典负载均衡器。
此命名空间中的多个选项已不再受支持，以支持 [aws:elb:listener](#command-options-general-elblistener) 命名空间中特定于侦听器的选项。使用这些不再受支持的选项，您只能在标准端口上配置两个侦听器（一个安全一个不安全）。
**命名空间: `aws:elb:loadbalancer`**
| 名称 | 描述 | 默认值 | 有效值 |
| --- | --- | --- | --- |
| CrossZone | 将负载均衡器配置为在所有可用区中的所有实例间 (而不是仅在每个区域中) 均匀地路由流量。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `false` | `true` `false` |
| SecurityGroups | 将您创建的一个或多个安全组分配到负载均衡器。 当 `DisableDefaultEC2SecurityGroup`（[aws:autoscaling:launchconfiguration](#command-options-general-autoscalinglaunchconfiguration)）设置为 `true` 时，此选项是必需的。已经选择不使用默认 Elastic Beanstalk EC2 安全组的负载均衡环境必须为一个或多个安全组提供此选项。有关更多信息，请参阅[管理 EC2 安全组](using-features.managing.ec2.instances.sg.md)。 | None（无） | 一个或多个安全组 IDs。 |
| ManagedSecurityGroup | 将现有安全组分配给环境的负载均衡器，而不是创建一个新安全组。要使用此设置，请更新此命名空间中的 `SecurityGroups` 设置以包含安全组的 ID，然后删除自动创建的安全组 ID（如果已创建）。 为了允许从负载均衡器到环境的 EC2 实例的流量，Elastic Beanstalk 会向实例的安全组添加一条规则，允许来自托管安全组的入站流量。 | 无 | 安全组 ID。 |
| （已弃用）LoadBalancerHTTPPort | 不安全的侦听器要侦听的端口。 | `80` | `OFF` `80` |
| （已弃用）LoadBalancerPortProtocol | 不安全的侦听器上使用的协议。 | `HTTP` | `HTTP` `TCP` |
| （已弃用）LoadBalancerHTTPSPort | 安全的侦听器要侦听的端口。 | `OFF` | `OFF` `443` `8443` |
| （已弃用）LoadBalancerSSLPortProtocol | 安全的侦听器上使用的协议。 | `HTTPS` | `HTTPS` `SSL` |
| （已弃用）SSLCertificateId | 要绑定到安全的侦听器的 SSL 证书的 Amazon Resource Name (ARN)。 | 无 | |
## aws:elb:listener
在经典负载均衡器上配置默认侦听器（端口 80）。
**命名空间: `aws:elb:listener`**
| 名称 | 描述 | 默认值 | 有效值 |
| --- | --- | --- | --- |
| ListenerProtocol | 侦听器使用的协议。 | HTTP | HTTP TCP |
| InstancePort | 此侦听器用于与 EC2 实例通信的端口。 | 80 | 1 到 65535 |
| InstanceProtocol | 此侦听器用于与 EC2 实例通信的协议。 它必须位于与 `ListenerProtocol` 相同的 Internet 协议层中。其安全级别也必须与使用与该侦听器相同的 `InstancePort` 的任何其他侦听器相同。 例如，如果 `ListenerProtocol` 是 `HTTPS` (应用程序层，使用安全连接)，您可以将 `InstanceProtocol` 设置为 `HTTP` (也位于应用程序层，使用不安全的连接)。此外，如果将 `InstancePort` 设置为 `80`，您必须在将 `InstanceProtocol` 设置为 `HTTP` 的所有其他侦听器中将 `InstancePort` 设置为 `80`。 | `HTTP` (当 `ListenerProtocol` 为 `HTTP` 时) `TCP` (当 `ListenerProtocol` 为 `TCP` 时) | HTTP 或 HTTPS 当 ListenerProtocol 为 HTTP 或 HTTPS `TCP` 或 `SSL` 当 `ListenerProtocol` 为 `TCP` 或 `SSL` |
| PolicyNames | 应用于该侦听器的端口的策略名称的逗号分隔列表。我们建议您改用[aws:elb:policies](#command-options-general-elbpolicies)命名空间 LoadBalancerPorts 选项。 | 无 | |
| ListenerEnabled | 指定是否启用该侦听器。如果指定 false，则此侦听器不包含在负载均衡器中。 | true | `true` `false` |
## aws:elb:listener:listener\$1port
在经典负载均衡器上配置其他侦听器。
**命名空间: `aws:elb:listener:listener_port`**
| 名称 | 描述 | 默认值 | 有效值 |
| --- | --- | --- | --- |
| ListenerProtocol | 侦听器使用的协议。 | HTTP | HTTP HTTPS TCP SSL |
| InstancePort | 此侦听器用于与 EC2 实例通信的端口。 | 与... 相同listener\$1port。 | 1 到 65535 |
| InstanceProtocol | 此侦听器用于与 EC2 实例通信的协议。 它必须位于与 `ListenerProtocol` 相同的 Internet 协议层中。其安全级别也必须与使用与该侦听器相同的 `InstancePort` 的任何其他侦听器相同。 例如，如果 `ListenerProtocol` 是 `HTTPS` (应用程序层，使用安全连接)，您可以将 `InstanceProtocol` 设置为 `HTTP` (也位于应用程序层，使用不安全的连接)。此外，如果将 `InstancePort` 设置为 `80`，您必须在将 `InstanceProtocol` 设置为 `HTTP` 的所有其他侦听器中将 `InstancePort` 设置为 `80`。 | `HTTP` 当 `ListenerProtocol` 为 `HTTP` 或 `HTTPS` `TCP` 当 `ListenerProtocol` 为 `TCP` 或 `SSL` | HTTP 或 HTTPS 当 ListenerProtocol 为 HTTP 或 HTTPS `TCP` 或 `SSL` 当 `ListenerProtocol` 为 `TCP` 或 `SSL` |
| PolicyNames | 应用于该侦听器的端口的策略名称的逗号分隔列表。我们建议您改用[aws:elb:policies](#command-options-general-elbpolicies)命名空间的 LoadBalancerPorts 选项。 | 无 | |
| SSLCertificateId | 要绑定到侦听器的 SSL 证书的 Amazon Resource Name (ARN)。 | 无 | |
| ListenerEnabled | 指定是否启用该侦听器。如果指定 false，则此侦听器不包含在负载均衡器中。 | 如果设置了任何其他选项，则为 true；否则为 false。 | true false |
## aws:elb:policies
修改经典负载均衡器的默认粘性和全局负载均衡器策略。
**命名空间: `aws:elb:policies`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ConnectionDrainingEnabled | 指定负载均衡器是否维持与已运行状况不佳或取消注册的实例之间的现有连接以完成正在进行的请求。 如果您使用 Elastic Beanstalk 控制台或 EB CLI 创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台和 EB CLI 使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `false` | `true` `false` |
| ConnectionDrainingTimeout | 在强制关闭连接之前，负载均衡器在连接耗尽过程中维持与实例之间的现有连接的最大秒数。 如果您使用 Elastic Beanstalk 控制台创建环境，则无法在[配置文件](ebextensions.md)中设置此选项。控制台使用[建议的值](command-options.md#configuration-options-recommendedvalues)覆盖此选项。 | `20` | `1` 到 `3600` |
| ConnectionSettingIdleTimeout | 负载均衡器等待通过连接发送或接收任何数据的时间（单位：秒）。如果此时段后未发送或接收任何数据，则负载均衡器将关闭连接。 | `60` | `1` 到 `3600` |
| LoadBalancerPorts | 应用默认策略 (`AWSEB-ELB-StickinessPolicy`) 的侦听器端口的逗号分隔列表。 | 无 | 您可以使用 :all 指示所有侦听器端口 |
| Stickiness Cookie Expiration | 每个 Cookie 的有效时间，以秒为单位。使用默认策略 (`AWSEB-ELB-StickinessPolicy`)。 | `0` | `0` 到 `1000000` |
| Stickiness Policy | 将一个用户会话绑定到某一特定的服务器实例，以便系统将用户在此会话期间发出的所有请求都发送到同一服务器实例。使用默认策略 (`AWSEB-ELB-StickinessPolicy`)。 | `false` | true false |
## aws:elb:policies:policy\$1name
为经典负载均衡器创建其他负载均衡器策略。
**命名空间: `aws:elb:policies:policy_name`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| CookieName | 应用程序生成的 Cookie 的名称，用于控制 AppCookieStickinessPolicyType 策略的会话生存期。此策略只能与 HTTP/HTTPS 监听器关联。 | 无 | |
| InstancePorts | 应用此策略的实例端口的逗号分隔列表。 | 无 | 端口列表或 :all |
| LoadBalancerPorts | 应用此策略的侦听器端口的逗号分隔列表。 | 无 | 端口列表或 :all |
| ProxyProtocol | 对于 `ProxyProtocolPolicyType` 策略，指定是否包含 TCP 消息的原始请求的 IP 地址和端口。此策略只能与 TCP/SSL 监听器关联。 | 无 | true false |
| PublicKey | 对后端服务器进行身份验证时要使用的 `PublicKeyPolicyType` 策略的公有密钥的内容。此策略不能直接应用于后端服务器或侦听器。必须作为 `BackendServerAuthenticationPolicyType` 策略的一部分。 | 无 | |
| PublicKeyPolicyNames | 控制后端服务器身份验证的 `PublicKeyPolicyType` 策略的策略名称（来自 `BackendServerAuthenticationPolicyType` 策略）的逗号分隔列表。此策略只能与使用 HTTPS/SSL 的后端服务器关联。 | 无 | |
| SSLProtocols | 对 `SSLNegotiationPolicyType` 策略（用于定义负载均衡器所接受的密码和协议）启用的 SSL 协议的逗号分隔列表。此策略只能与 HTTPS/SSL 监听器关联。 | 无 | |
| SSLReferencePolicy | 符合安全最佳实践的预定义 AWS 安全策略的名称，您要为定义负载均衡器接受的密码和协议的`SSLNegotiationPolicyType`策略激活该策略。此策略只能与 HTTPS/SSL 监听器关联。 | 无 | |
| Stickiness Cookie Expiration | 每个 Cookie 的有效时间，以秒为单位。 | `0` | `0` 到 `1000000` |
| Stickiness Policy | 将一个用户会话绑定到某一特定的服务器实例，以便系统将用户在此会话期间发出的所有请求都发送到同一服务器实例。 | `false` | true false |
## aws:elbv2:listener:default
在 Application Load Balancer 或 Network Load Balancer 上配置默认侦听器（端口 80）。
此命名空间不适用于使用共享负载均衡器的环境。共享的负载均衡器没有默认侦听器。
**命名空间: `aws:elbv2:listener:default`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DefaultProcess | 无规则匹配时将流量转发到的[流程](#command-options-general-environmentprocess)的名称。 | `default` | 过程名称。 |
| ListenerEnabled | 设置为 `false` 可禁用侦听器。您可以使用此选项对端口 80 禁用默认侦听器。 | `true` | `true` `false` |
| Protocol | 要处理的流量的协议。 | 使用应用程序负载均衡器：`HTTP` 使用网络负载均衡器：`TCP` | 使用应用程序负载均衡器：`HTTP`、`HTTPS` 使用网络负载均衡器：`TCP` |
| Rules | 应用于侦听器的[规则](#command-options-general-elbv2-listenerrule)的列表 此选项仅适用于带 Application Load Balancer 的环境。 | 无 | 逗号分隔的规则名称列表。 |
| SSLCertificateArns | 要绑定到侦听器的 SSL 证书的 Amazon Resource Name (ARN)。 此选项仅适用于带 Application Load Balancer 的环境。 | 无 | 存储在 IAM 或 ACM 中的证书的 ARN。 |
| SSLPolicy | 指定要应用于监听器的安全策略。 此选项仅适用于带 Application Load Balancer 的环境。 | 无 (ELB 默认值) | 负载均衡器安全策略的名称。 |
## aws:elbv2:listener:listener\$1port
在 Application Load Balancer 或 Network Load Balancer 上配置其他侦听器。
**注意**
对于共享 Application Load Balancer，您只能指定 `Rule` 选项。其他选项不适用于共享的负载均衡器。
**命名空间: `aws:elbv2:listener:listener_port`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DefaultProcess | 无规则匹配时将流量转发到的[流程](#command-options-general-environmentprocess)的名称。 | `default` | 过程名称。 |
| ListenerEnabled | 设置为 `false` 可禁用侦听器。您可以使用此选项对端口 80 禁用默认侦听器。 | `true` | `true` `false` |
| Protocol | 要处理的流量的协议。 | 使用应用程序负载均衡器：`HTTP` 使用网络负载均衡器：`TCP` | 使用应用程序负载均衡器：`HTTP`、`HTTPS` 使用网络负载均衡器：`TCP` |
| Rules | 要应用于侦听器的[规则](#command-options-general-elbv2-listenerrule)的列表 此选项仅适用于带 Application Load Balancer 的环境。 如果您的环境使用共享的 Application Load Balancer，并且您没有为任何侦听器指定此选项，则 Elastic Beanstalk 自动将 `default` 规则与端口 80 侦听器关联。 | 无 | 逗号分隔的规则名称列表。 |
| SSLCertificateArns | 要绑定到侦听器的 SSL 证书的 Amazon Resource Name (ARN)。 此选项仅适用于带 Application Load Balancer 的环境。 | 无 | 存储在 IAM 或 ACM 中的证书的 ARN。 |
| SSLPolicy | 指定要应用于监听器的安全策略。 此选项仅适用于带 Application Load Balancer 的环境。 | 无 (ELB 默认值) | 负载均衡器安全策略的名称。 |
## aws:elbv2:listenerrule:rule\$1name
为 Application Load Balancer 定义侦听器规则。如果请求与规则中的主机名或路径匹配，则负载均衡器将请求转发到指定的进程。要使用规则，请使用 [`Rules`](#command-options-general-elbv2-listener) 命名空间中的 `aws:elbv2:listener:listener_port` 选项将其添加到侦听器中。
**注意**
此命名空间不适用于使用网络负载均衡器的环境。
**命名空间: `aws:elbv2:listenerrule:rule_name`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| HostHeaders | 要匹配的主机名列表。例如 `my.example.com`。 | 专用负载均衡器：无 共享的负载均衡器：环境的 CNAME | 每个名称最多可以包含 128 个字符。模式可包含大写和小写字母、数字、连字符 (–) 以及最多三个通配符（`*` 匹配零个或多个字符；`?` 恰好匹配一个字符）。您可以列出多个名称，每个名称用逗号分隔。Application Load Balancer 最多支持五个 `HostHeader` 和 `PathPattern` 规则组合。 有关更多信息，请参阅 *Application Load Balancer 用户指南*中的[主机条件](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#host-conditions)。 |
| PathPatterns | 要匹配的路径模式（例如，`/img/*`)。 此选项仅适用于使用应用程序负载均衡器的环境。 | 无 | 每个模式最多可包含 128 个字符。模式可包含大写和小写字母、数字、连字符 (–) 以及最多三个通配符（`*` 匹配零个或多个字符；`?` 恰好匹配一个字符）。您可以添加多个逗号分隔的路径模式。Application Load Balancer 最多支持五个 `HostHeader` 和 `PathPattern` 规则组合。 有关更多信息，请参阅 *Application Load Balancer 用户指南*中的[路径条件](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions)。 |
| Priority | 多个规则匹配时此规则的优先顺序。较小的数字优先。任何两个规则的优先级不能相同。 利用共享的负载均衡器，Elastic Beanstalk 将规则优先级视为跨共享环境的相对优先级，并在创建过程中将其映射到绝对优先级。 | `1` | `1` 到 `1000` |
| Process | 此规则与请求匹配时要将流量转发到的[流程](#command-options-general-environmentprocess)的名称。 | `default` | 过程名称。 |
## aws:elbv2:loadbalancer
配置 Application Load Balancer。
对于共享的负载均衡器，只有 `SharedLoadBalancer` 和 `SecurityGroups` 选项有效。
**注意**
此命名空间不适用于带 Network Load Balancer 的环境。
**命名空间: `aws:elbv2:loadbalancer`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| AccessLogsS3Bucket | 存储访问日志的 Amazon S3 存储桶。存储桶必须与环境处于同一区域并授予负载均衡器的写入访问权限。 | 无 | 存储桶名称。 |
| AccessLogsS3Enabled | 启用访问日志存储。 | `false` | `true` `false` |
| AccessLogsS3Prefix | 放在访问日志名称前的前缀。默认情况下，负载均衡器会将日志上传到您指定的存储桶 AWSLogs 中名为的目录。指定前缀以将该 AWSLogs 目录放在另一个目录中。 | 无 | |
| IdleTimeout | 在关闭到客户端和实例的连接之前，等待请求完成的时间（单位：秒）。 | 无 | `1` 到 `3600` |
| IpAddressType | 指定环境负载均衡器的 IP 地址格式配置。使用 d *ualstack* 选项启用 IPv6 协议和 IPv4 协议。 只有应用程序负载均衡器和网络负载均衡器支持*双堆栈*选项。单实例环境和使用经典负载均衡器的环境不支持该选项。 您必须将环境的 VPC 和所有 VPC 子网与 IPv6 CIDR 块关联才能支持*双堆*栈选项。 有关更多信息，请参阅 [配置双堆栈 Elastic Beanstalk 负载均衡器](environments-cfg-elbv2-ipv6-dualstack.md)。 | IPv4 | ipv4、dualstack |
| ManagedSecurityGroup | 将现有安全组分配给环境的负载均衡器，而不是创建一个新安全组。要使用此设置，请更新此命名空间中的 `SecurityGroups` 设置以包括安全组的 ID，并删除自动创建的安全组 ID (如果存在)。 为了允许从负载均衡器到环境的 EC2 实例的流量，Elastic Beanstalk 会向实例的安全组添加一条规则，允许来自托管安全组的入站流量。 | Elastic Beanstalks 为您的负载均衡器闯进的安全组。 | 安全组 ID。 |
| SecurityGroups | 附加到负载均衡器的安全组的列表。 当 `DisableDefaultEC2SecurityGroup`（[aws:autoscaling:launchconfiguration](#command-options-general-autoscalinglaunchconfiguration)）设置为 `true` 时，此选项是必需的。已经选择不使用默认 Elastic Beanstalk EC2 安全组的负载均衡环境必须为一个或多个安全组提供此选项。有关更多信息，请参阅[管理 EC2 安全组](using-features.managing.ec2.instances.sg.md)。 对于共享的负载均衡器，如果您未指定此值，则 Elastic Beanstalk 将检查其管理的现有安全组是否已连接到负载均衡器。如果没有连接到负载均衡器，Elastic Beanstalk 将创建一个安全组并将其附加到负载均衡器。当最后一个共享负载均衡器的环境终止时，Elastic Beanstalk 将删除此安全组。 负载均衡器安全组用于设置 Amazon EC2 实例安全组入口规则。 | Elastic Beanstalks 为您的负载均衡器创建的安全组。 | 以逗号分隔的安全组列表。 IDs |
| SharedLoadBalancer | 共享负载均衡器的 Amazon Resource Name (ARN)。此选项仅与 Application Load Balancer 相关。当 [aws:elasticbeanstalk:environment](#command-options-general-elasticbeanstalkenvironment) 命名空间的 `LoadBalancerIsShared` 选项设置为 `true` 时，这是必需的。创建环境后，您将无法更改共享的负载均衡器 ARN。 有效值的条件： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/command-options-general.html) 例如： `arn:aws:elasticloadbalancing:us-east-2:123456789012:loadbalancer/app/FrontEndLB/0dbf78d8ad96abbc` | 无 | 符合此处所述全部条件的有效负载均衡器的 ARN。 |
## aws:rds:dbinstance
配置连接的 Amazon RDS 数据库实例。
**命名空间: `aws:rds:dbinstance`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DBAllocatedStorage | 分配的数据库存储大小 (以吉字节为单位来指定)。 | MySQL：`5` Oracle：`10` sqlserver-se：`200` sqlserver-ex：`30` sqlserver-web：`30` | MySQL：`5`-`1024` Oracle：`10`-`1024` sqlserver：无法修改 |
| DBDeletionPolicy | 指定在环境终止时保留、删除或创建数据库实例还是为数据库实例拍摄快照。 此选项与 `HasCoupledDatabase` 结合使用，也是此命名空间的一个选项。 删除数据库实例会导致数据永久丢失。 | `Delete` | `Delete` `Retain` `Snapshot` |
| DBEngine | 要用于此实例的数据库引擎的名称。 | `mysql` | `mysql` `oracle-se1` `sqlserver-ex` `sqlserver-web` `sqlserver-se` `postgres` |
| DBEngineVersion | 数据库引擎的版本号。 | `5.5` | |
| DBInstanceClass | 数据库实例类型。 | `db.t2.micro` （对于并未在 Amazon VPC 中运行的环境，为 `db.m1.large`） | 有关更多信息，请参阅 *Amazon Relational Database Service 用户指南*中的[数据库实例类](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.html)。 |
| DBPassword | 数据库实例的主用户密码。 | 无 | |
| DBSnapshotIdentifier | 要用来恢复数据库的数据库快照的标识符。 | 无 | |
| DBUser | 数据库实例的主用户名称。 | **ebroot** | |
| HasCoupledDatabase | 指定数据库实例是否与环境耦合。如果切换为 `true`，Elastic Beanstalk 会创建一个与您的环境耦合的新数据库实例。如果切换为 `false`，Elastic Beanstalk 开始将数据库实例与您的环境解耦。 此选项与 `DBDeletionPolicy` 结合使用，也是此命名空间的一个选项。 注意：如果在解耦前一个数据库之后将此值切换回 `true` ，Elastic Beanstalk 将使用前一个数据库选项设置创建一个新的数据库。但是，为了维护环境的安全性，它不会保留现有的 `DBUser` 和 `DBPassword` 设置。您需要再次指定 `DBUser` 和 `DBPassword`。 | `false` | `true` `false` |
| MultiAZDatabase | 指定是否需要创建数据库实例的多可用区部署。有关使用 Amazon Relational Database Service (RDS) 进行多可用区部署的更多信息，请参阅 *Amazon Relational Database Service 用户指南*中的[区域和可用区](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html)。 | `false` | `true` `false` |
# 特定于平台的选项
某些 Elastic Beanstalk 平台定义特定于平台的选项命名空间。下面列出了每个平台的这些命名空间及其选项。
**注意**
以前，在基于 Amazon Linux AMI（在 Amazon Linux 2 之前）的平台版本中，以下两个功能及其各自的命名空间被视为特定于平台的功能，并且在此处按平台列出：
**静态文件的代理配置** - `aws:elasticbeanstalk:environment:proxy:staticfiles`
**AWS X-Ray 支持** — `aws:elasticbeanstalk:xray`
在 Amazon Linux 2 平台版本中，Elastic Beanstalk 以一致的方式在所有支持平台上实现这些功能。相关的命名空间现在列在 [面向所有环境的常规选项](command-options-general.md) 页面中。对于命名空间名称不同的平台，我们只在此页面上提到它们。
**Topics**
+ [Docker 平台选项](#command-options-docker)
+ [Go 平台选项](#command-options-golang)
+ [Java SE 平台选项](#command-options-plain-java)
+ [具有 Tomcat 的 Java 平台选项](#command-options-java)
+ [Linux 上的 .NET Core 平台选项](#command-options-dotnet-core-linux)
+ [.NET 平台选项](#command-options-net)
+ [Node.js 平台选项](#command-options-nodejs)
+ [PHP 平台选项](#command-options-php)
+ [Python 平台选项](#command-options-python)
+ [Ruby 平台选项](#command-options-ruby)
## Docker 平台选项
以下 Docker 特定的配置选项适用于 Docker 和预配置的 Docker 平台。
**注意**
这些配置选项不适用于
带 Docker Compose 的 Docker 平台（Amazon Linux 2）
多容器 Docker 平台（亚马逊 Linux AMI AL1）——该平台已停用
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ProxyServer | 指定要用作代理的 Web 服务器。 | `nginx` | `nginx` `none`— 仅限*亚马逊 Linux AM* 和 *Docker w/DC * |
## Go 平台选项
### Amazon Linux AMI（先前的 Amazon Linux 2）平台选项
#### 命名空间: `aws:elasticbeanstalk:container:golang:staticfiles`
您可以使用以下命名空间来配置代理服务器提供静态文件。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。这将减少您的应用程序必须处理的请求的数量。
在源代码中将代理服务器提供的路径映射到包含静态资产的文件夹。在此命名空间中定义的每个选项都映射不同的路径。
| **名称** | **值** |
| --- | --- |
| 代理服务器将提供文件的路径。 示例：`/images` 将在 `subdomain.eleasticbeanstalk.com/images` 提供文件。 | 包含文件的文件夹名称。 示例：`staticimages` 将在源代码包顶层从名为 `staticimages` 的文件夹中提供文件。 |
## Java SE 平台选项
### Amazon Linux AMI（先前的 Amazon Linux 2）平台选项
#### 命名空间: `aws:elasticbeanstalk:container:java:staticfiles`
您可以使用以下命名空间来配置代理服务器提供静态文件。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。这将减少您的应用程序必须处理的请求的数量。
在源代码中将代理服务器提供的路径映射到包含静态资产的文件夹。在此命名空间中定义的每个选项都映射不同的路径。
| **名称** | **值** |
| --- | --- |
| 代理服务器将提供文件的路径。 示例：`/images` 将在 `subdomain.eleasticbeanstalk.com/images` 提供文件。 | 包含文件的文件夹名称。 示例：`staticimages` 将在源代码包顶层从名为 `staticimages` 的文件夹中提供文件。 |
## 具有 Tomcat 的 Java 平台选项
**命名空间: `aws:elasticbeanstalk:application:environment`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| JDBC\$1CONNECTION\$1STRING | 外部数据库的连接字符串。 | 不适用 | 不适用 |
有关更多信息，请参阅 [环境变量和其他软件设置](environments-cfg-softwaresettings.md)。
**命名空间: `aws:elasticbeanstalk:container:tomcat:jvmoptions`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| JVM Options | 在启动时将命令行选项传递给 JVM。 | 不适用 | 不适用 |
| Xmx | 最大 JVM 堆大小。 | `256m` | 不适用 |
| XX:MaxPermSize | JVM 堆中用于存储类定义和相关元数据的部分。 此选项仅适用于 Java 8 之前的 Java 版本，基于 Amazon Linux 2 和更高版本的 Elastic Beanstalk Tomcat 平台不支持此选项。 | `64m` | 不适用 |
| Xms | 初始 JVM 堆大小。 | `256m` | 不适用 |
| *optionName* | 除了 Tomcat 平台定义的选项外，还指定任意 JVM 选项。 | 不适用 | 不适用 |
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| GzipCompression | 设置为 `false` 以禁用响应压缩。 *仅在 Amazon Linux AMI（在 Amazon Linux 2 之前）平台版本上有效。* | `true` | `true` `false` |
| ProxyServer | 设置要在环境的实例上使用的代理。如果将此选项设置为 `apache`，则 Elastic Beanstalk 将使用 [Apache 2.4](https://httpd.apache.org/docs/2.4/)。 如果应用程序由于代理配置设置不兼容未准备好从 [Apache 2.2](https://httpd.apache.org/docs/2.2/) 迁移，则设置为 `apache/2.2`。*此值仅在 Amazon Linux AMI（在 Amazon Linux 2 之前）平台版本上有效。* 设置为 `nginx` 以使用 [nginx](https://www.nginx.com/)。这是以 Amazon Linux 2 平台版本开始的默认值。 有关更多信息，请参阅 [配置代理服务器](java-tomcat-proxy.md)。 | `nginx` (Amazon Linux 2) `apache` (Amazon Linux AMI) | `apache` `apache/2.2` – *仅限 Amazon Linux AMI* `nginx` |
## Linux 上的 .NET Core 平台选项
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ProxyServer | 指定要用作代理的 Web 服务器。 | `nginx` | `nginx` `none` |
## .NET 平台选项
**命名空间: `aws:elasticbeanstalk:container:dotnet:apppool`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| Target Runtime | 选择用于应用程序的 .NET Framework 版本。 | `4.0` | `2.0` `4.0` |
| Enable 32-bit Applications | 设置为 `True` 以运行 32 位应用程序。 | `False` | `True` `False` |
## Node.js 平台选项
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ProxyServer | 设置要在环境的实例上使用的代理。 | `nginx` | `apache` `nginx` |
### Amazon Linux AMI（先前的 Amazon Linux 2）平台选项
#### 命名空间: `aws:elasticbeanstalk:container:nodejs`
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| NodeCommand | 用来启动 Node.js 应用程序的命令。如果指定空字符串，则依次使用 `app.js`、`server.js` 和 `npm start`。 | "" | 不适用 |
| NodeVersion | Node.js 的版本。例如：`4.4.6`。 支持的 Node.js 版本因 Node.js 平台版本而异。有关目前受支持版本的列表，请参阅 *AWS Elastic Beanstalk 平台文档*中的 [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。 如果对您正在使用的 Node.js 版本的支持已从平台中移除，则您必须先更改或移除版本设置再进行[平台更新](using-features.platform.upgrade.md)。当在一个或多个 Node.js 版本中识别到安全漏洞时，可能会发生这种情况。 发生这种情况时，尝试更新到不支持配置的平台的新版本会[NodeVersion](#command-options-nodejs)失败。为避免需要创建新环境，请将*NodeVersion*配置选项更改为旧平台版本和新平台版本都支持的 Node.js 版本，或者[删除该选项设置](environment-configuration-methods-after.md)，然后执行平台更新。 | 变化 | 变化 |
| GzipCompression | 指定是否启用 gzip 压缩。如果设置 ProxyServer 为`none`，则禁用 gzip 压缩。 | `false` | `true` `false` |
| ProxyServer | 指定应使用哪台 Web 服务器来代理与 Node.js 的连接。如果设置 ProxyServer 为`none`，则静态文件映射不生效并禁用 gzip 压缩。 | `nginx` | `apache` `nginx` `none` |
#### 命名空间: `aws:elasticbeanstalk:container:nodejs:staticfiles`
您可以使用以下命名空间来配置代理服务器提供静态文件。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。这将减少您的应用程序必须处理的请求的数量。
在源代码中将代理服务器提供的路径映射到包含静态资产的文件夹。在此命名空间中定义的每个选项都映射不同的路径。
**注意**
如果 `aws:elasticbeanstalk:container:nodejs::ProxyFiles` 设置为 `none`，将不应用静态文件设置。
| **名称** | **值** |
| --- | --- |
| 代理服务器将提供文件的路径。 示例：`/images` 将在 `subdomain.eleasticbeanstalk.com/images` 提供文件。 | 包含文件的文件夹名称。 示例：`staticimages` 将在源代码包顶层从名为 `staticimages` 的文件夹中提供文件。 |
## PHP 平台选项
**命名空间: `aws:elasticbeanstalk:container:php:phpini`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| document\$1root | 指定项目的子目录，这也是面向公众的 Web 根目录。 | `/` | 将空字符串视为 `/`，或指定以 `/` 开头的字符串 |
| memory\$1limit | 分配给 PHP 环境的内存量。 | `256M` | 不适用 |
| zlib.output\$1compression | 指定 PHP 在输出时是否应使用压缩。 | `Off` | `On` `Off` `true` `false` |
| allow\$1url\$1fopen | 指定是否允许 PHP 的文件功能从远程位置 (如网站或 FTP 服务器) 检索数据。 | `On` | `On` `Off` `true` `false` |
| display\$1errors | 指定错误消息是否应该是输出的一部分。 | `Off` | `On` `Off` |
| max\$1execution\$1time | 设置一个脚本在被环境终止前允许运行的最长时间，计算单位为秒。 | `60` | `0` 至 `9223372036854775807` (PHP\$1INT\$1MAX) |
| composer\$1options | 设置通过 **composer.phar install** 命令使用 Composer 安装依赖项时要使用的自定义选项。有关更多信息，请参阅 *getcomposer.org* 网站上的 [install](https://getcomposer.org/doc/03-cli.md#install-i)。 | 不适用 | 不适用 |
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ProxyServer | 设置要在环境的实例上使用的代理。 | `nginx` | `apache` `nginx` |
**注意**
有关 PHP 平台的更多信息，请参阅[使用 Elastic Beanstalk PHP 平台](create_deploy_PHP.container.md)。
## Python 平台选项
**命名空间: `aws:elasticbeanstalk:application:environment`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| DJANGO\$1SETTINGS\$1MODULE | 指定要使用的设置文件。 | 不适用 | 不适用 |
有关更多信息，请参阅 [环境变量和其他软件设置](environments-cfg-softwaresettings.md)。
**命名空间: `aws:elasticbeanstalk:container:python`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| WSGIPath | 包含 WSGI 应用程序的文件。此文件必须有一个可调用的 `application`。 | 在 Amazon Linux 2 Python 平台版本上：`application` 在 Amazon Linux AMI Python 平台版本上：`application.py` | 不适用 |
| NumProcesses | 运行 WSGI 应用程序时，应为进程组启动的守护程序进程数。 | `1` | 不适用 |
| NumThreads | 运行 WSGI 应用程序时，为了处理进程组内部每个守护程序进程中的请求而要创建的线程数。 | `15` | 不适用 |
**命名空间: `aws:elasticbeanstalk:environment:proxy`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| ProxyServer | 设置要在环境的实例上使用的代理。 | `nginx` | `apache` `nginx` |
### Amazon Linux AMI（先前的 Amazon Linux 2）平台选项
#### 命名空间: `aws:elasticbeanstalk:container:python:staticfiles`
您可以使用以下命名空间来配置代理服务器提供静态文件。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。这将减少您的应用程序必须处理的请求的数量。
在源代码中将代理服务器提供的路径映射到包含静态资产的文件夹。在此命名空间中定义的每个选项都映射不同的路径。
默认情况下，Python 环境中的代理服务器提供 `static` 路径下名为 `/static` 的文件夹中的任何文件。
**命名空间: `aws:elasticbeanstalk:container:python:staticfiles`**
| **名称** | **值** |
| --- | --- |
| 代理服务器将提供文件的路径。 示例：`/images` 将在 `subdomain.eleasticbeanstalk.com/images` 提供文件。 | 包含文件的文件夹名称。 示例：`staticimages` 将在源代码包顶层从名为 `staticimages` 的文件夹中提供文件。 |
## Ruby 平台选项
**命名空间: `aws:elasticbeanstalk:application:environment`**
| **名称** | **描述** | **默认** | **有效值** |
| --- | --- | --- | --- |
| RAILS\$1SKIP\$1MIGRATIONS | 指定是代表用户的应用程序运行``rake db:migrate``，还是应跳过它。此功能仅适用于 Rails 3 应用程序。 | `false` | `true` `false` |
| RAILS\$1SKIP\$1ASSET\$1COMPILATION | 指定该容器是应代表用户的应用程序运行``rake assets:precompile` `，还是应跳过它。此功能也仅适用于 Rails 3 应用程序。 | `false` | `true` `false` |
| BUNDLE\$1WITHOUT | 从 Gemfile 安装依赖项时要忽略的组列表，用冒号 (`:`) 分隔。 | `test:development` | 不适用 |
| RACK\$1ENV | 指定可以运行应用程序的环境阶段。常见的环境示例包括开发、生产和测试。 | `production` | 不适用 |
参阅 [环境变量和其他软件设置](environments-cfg-softwaresettings.md) 了解更多信息。
# 自定义选项
使用 `aws:elasticbeanstalk:customoption` 命名空间定义可在其他配置文件的 `Resources` 块中读取的选项和值。使用自定义选项收集用户在单个配置文件中指定的设置。
例如，您可能有一个复杂的配置文件，该文件定义了可由用户在启动环境时配置的资源。如果使用 `Fn::GetOptionSetting` 检索某个自定义选项的值，您可以在另一个配置文件中定义该选项，以便用户更容易发现和修改。
此外，由于自定义选项是配置选项，因此可在 API 级别设置它们以覆盖在配置文件中设置的值。有关更多信息，请参阅[优先顺序](command-options.md#configuration-options-precedence)。
自定义选项的定义方式与任何其他选项的类似：
```
option_settings:
aws:elasticbeanstalk:customoption:
option name: option value
```
例如，以下配置文件创建了一个名为 `ELBAlarmEmail` 的选项并将值设置为 `someone@example.com`：
```
option_settings:
aws:elasticbeanstalk:customoption:
ELBAlarmEmail: someone@example.com
```
在其他某个位置，配置文件定义了一个可读取包含 `Fn::GetOptionSetting` 的选项的 SNS 主题以填充 `Endpoint` 属性的值：
```
Resources:
MySNSTopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Endpoint:
Fn::GetOptionSetting:
OptionName: ELBAlarmEmail
DefaultValue: nobody@example.com
Protocol: email
```
您可以在[添加和自定义 Elastic Beanstalk 环境资源](environment-resources.md)中找到更多使用 `Fn::GetOptionSetting` 的示例代码段。
# 使用配置文件 (`.ebextensions`) 进行高级环境自定义
您可以将 AWS Elastic Beanstalk 配置文件 (`.ebextensions`) 添加到 Web 应用程序的源代码中，以配置您的环境并自定义其包含的 AWS 资源。配置文件是 YAML 或 JSON 格式的文档，采用 `.config` 文件扩展名，您将其放在名为 `.ebextensions` 的文件夹中，并在应用程序[源包](applications-sourcebundle.md)中部署它们。
**Example .ebextensions/ .config network-load-balancer**
此示例进行了简单的配置更改。它修改一个配置选项，以将环境的负载均衡器的类型设置为 Network Load Balancer。
```
option_settings:
aws:elasticbeanstalk:environment:
LoadBalancerType: network
```
我们建议对配置文件使用 YAML，因为它比 JSON 更可读。YAML 支持注释、多行命令、针对使用引号的多个备选项等。但是，您可以使用 YAML 或 JSON 在 Elastic Beanstalk 配置文件中以相同的方式进行任何配置更改。
**提示**
当您开发或测试新的配置文件时，启动运行默认应用程序的干净环境并部署到此环境。格式不正确的配置文件将导致新环境启动失败，并且错误不可恢复。
配置文件的 `option_settings` 部分定义[配置选项](command-options.md)的值。配置选项允许您配置 Elastic Beanstalk 环境 AWS 、其中的资源以及运行应用程序的软件。设置配置选项有几种方法，配置文件只是其中之一。
该[`Resources`部分](environment-resources.md)允许您进一步自定义应用程序环境中的资源，并定义配置选项提供的功能之外的其他 AWS 资源。您可以添加和配置支持的任何资源 AWS CloudFormation，Elastic Beanstalk 使用这些资源来创建环境。
配置文件的其他部分（`packages`、、、`sources`、`files`、`users`、`groups``commands``container_commands`、和`services`）允许您配置在您的环境中启动的 EC2 实例。只要您的环境中有服务器启动，Elastic Beanstalk 就会运行这些部分中定义的操作，为您的应用程序准备操作系统和存储系统。
有关常用 .ebextensions 的示例，请参阅 [Elastic Beanstalk 配置文件存储库](https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files)。
**要求**
+ **位置** — Elastic Beanstalk 将处理部署中存在的所有 `.ebextensions` 文件夹。但是，我们建议您将所有配置文件放在源包根目录中名为 `.ebextensions` 的文件夹中。以点开头的文件夹可被文件浏览器隐藏，因此请确保在创建源包时添加文件夹。有关更多信息，请参阅 [创建 Elastic Beanstalk 应用程序源包](applications-sourcebundle.md)。
+ **命名** – 配置文件必须具有 `.config` 文件扩展名。
+ **格式** – 配置文件必须符合 YAML 或 JSON 规范。
当使用 YAML 时，请始终使用空格以不同的嵌套级别缩进键。有关 YAML 的更多信息，请参阅 [YAML Ain't 标记语言 (YAML™) 版本 1.1](http://yaml.org/spec/current.html)。
+ **唯一性** – 在每个配置文件中使用每个键一次。
**警告**
如果您在同一个配置文件中两次使用同一个键 (例如 `option_settings`)，则会删除两个部分之一。将重复的部分组合为单个部分，或将其放在不同的配置文件中。
根据您用来管理环境的客户端，部署过程可能略有不同。有关详细信息，请参阅下面几节：
+ [Elastic Beanstalk 控制台](environment-configuration-methods-during.md#configuration-options-during-console-ebextensions)
+ [EB CLI](environment-configuration-methods-during.md#configuration-options-during-ebcli-ebextensions)
+ [AWS CLI](environment-configuration-methods-during.md#configuration-options-during-awscli-ebextensions)
**Topics**
+ [选项设置](ebextensions-optionsettings.md)
+ [自定义 Linux 服务器上的软件](customize-containers-ec2.md)
+ [自定义 Windows Server 上的软件](customize-containers-windows-ec2.md)
+ [添加和自定义 Elastic Beanstalk 环境资源](environment-resources.md)
# 选项设置
您可以使用 `option_settings` 键修改 Elastic Beanstalk 配置，并定义可以使用环境变量从应用程序中检索的变量。一些命名空间可让您扩展参数的数量，并指定参数名。有关命名空间和配置选项的列表，请参阅[配置选项](command-options.md)。
也可在创建或更新环境期间将选项设置直接应用于环境。直接应用于环境的设置将覆盖配置文件中相同选项的设置。移除环境配置中的设置后，配置文件中的设置将生效。有关详细信息，请参阅 [优先级](command-options.md#configuration-options-precedence)。
## 语法
选项设置标准语法是对象数组，每一个对象都有一个 `namespace`、`option_name` 和 `value` 键。
```
option_settings:
- namespace: namespace
option_name: option name
value: option value
- namespace: namespace
option_name: option name
value: option value
```
`namespace` 键可选。如果不指定命名空间，则默认使用 `aws:elasticbeanstalk:application:environment`：
```
option_settings:
- option_name: option name
value: option value
- option_name: option name
value: option value
```
Elastic Beanstalk 还支持选项设置快速输入语法，您可以在命名空间下以键值对形式指定选项：
```
option_settings:
namespace:
option name: option value
option name: option value
```
## 示例
下面的示例在 `aws:elasticbeanstalk:container:tomcat:jvmoptions` 命名空间中设置一个特定于 Tomcat 平台的选项和一个名为 `MYPARAMETER` 的环境属性。
标准 YAML 格式：
**Example .ebextensions/options.config**
```
option_settings:
- namespace: aws:elasticbeanstalk:container:tomcat:jvmoptions
option_name: Xmx
value: 256m
- option_name: MYPARAMETER
value: parametervalue
```
快速输入格式：
**Example .ebextensions/options.config**
```
option_settings:
aws:elasticbeanstalk:container:tomcat:jvmoptions:
Xmx: 256m
aws:elasticbeanstalk:application:environment:
MYPARAMETER: parametervalue
```
在 JSON 中：
**Example .ebextensions/options.config**
```
{
"option_settings": [
{
"namespace": "aws:elasticbeanstalk:container:tomcat:jvmoptions",
"option_name": "Xmx",
"value": "256m"
},
{
"option_name": "MYPARAMETER",
"value": "parametervalue"
}
]
}
```
# 自定义 Linux 服务器上的软件
本节介绍您可以在配置文件中包含的信息类型，以便在运行 Linux 的 EC2 实例上自定义软件。有关自定义和配置 Elastic Beanstalk 环境的一般信息，请参阅[配置 Elastic Beanstalk 环境](customize-containers.md)。有关在运行 Windows 的 EC2 实例上自定义软件的信息，请参阅[自定义 Windows Server 上的软件](customize-containers-windows-ec2.md)。
建议自定义和配置您的应用程序所依赖的软件。您可以添加要在实例预置期间执行的命令；定义 Linux 用户和组；以及下载文件或直接在环境实例上创建文件。这些文件可能是应用程序所需的依赖项（例如 yum 存储库中的其他包），也可能是配置文件（例如代理配置的替代项，用于覆盖 Elastic Beanstalk 默认的特定设置）。
**注意**
在 Amazon Linux 2 平台上，我们强烈建议您使用 *Buildfile*，而不是在 .ebextensions 配置文件中提供文件和命令。*Procfile* 和*平台挂钩*，（如果可能）用于在实例预置期间在环境实例上配置和运行自定义代码。有关这些机制的详细信息，请参阅[扩展 Elastic Beanstalk Linux 平台](platforms-linux-extend.md)。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
配置文件支持以下键，它们影响运行您的应用程序的 Linux 服务器。
**Topics**
+ [软件包](#linux-packages)
+ [组](#linux-groups)
+ [Users](#linux-users)
+ [来源](#linux-sources)
+ [文件](#linux-files)
+ [命令](#linux-commands)
+ [Services](#linux-services)
+ [容器命令](#linux-container-commands)
+ [示例：使用自定义 Amazon CloudWatch 指标](customize-containers-cw.md)
将按键在此处列出的顺序对其进行处理。
观察您的环境的[事件](using-features.events.md)，同时开发和测试配置文件。Elastic Beanstalk 将忽略包含验证错误的配置文件（例如“密钥无效”），并且不会处理同一文件中的任何其他密钥。出现这种情况时，Elastic Beanstalk 将警告事件添加到事件日志中。
## 软件包
您可以使用 `packages` 键下载并安装预先打包的应用程序和组件。
### 语法
```
packages:
name of package manager:
package name: version
...
name of package manager:
package name: version
...
...
```
您可以在每个程序包管理器密钥下指定多个软件包。
### 支持的软件包格式
目前，Elastic Beanstalk 支持以下包管理器：yum、rubygems、python 和 rpm。包的处理顺序如下：rpm、yum、rubygems 和 python。rubygems 和 python 之间没有处理顺序。在每个包管理器内，不保证包安装顺序。请使用您的操作系统支持的包管理器。
**注意**
Elastic Beanstalk 支持两个用于 Python 的基础包管理器：pip 和 easy\$1install。但是，在配置文件语法中，您必须将包管理器名称指定为 `python`。当您使用配置文件指定 Python 包管理器时，Elastic Beanstalk 会使用 Python 2.7。如果您的应用程序依赖于不同的 Python 版本，可以在 `requirements.txt` 文件中指定要安装的包。有关更多信息，请参阅 [在 Elastic Beanstalk 上使用要求文件指定依赖项](python-configuration-requirements.md)。
### 指定版本
在每个包管理器内，会使用包名和一系列版本对每个包进行指定。版本可以是字符串、一系列版本、空字符串或者空列表。空字符串或者空列表表示您需要最新的版本。对于 rpm 管理器，版本是以磁盘或 URL 上的文件的路径的方式指定的。不支持相对路径。
如果您指定包的版本，Elastic Beanstalk 会尝试安装该版本，即使实例上已经安装了较新的包版本。如果已经安装了较新的版本，那么部署会失败。一些包管理器支持多个版本，但其他的包管理器可能不支持。有关更多信息，请查看相关的包管理器文档。如果您没有指定版本且已安装了某种版本的包，那么 Elastic Beanstalk 不会安装新的版本，因为它会认为您希望保留并使用现有的版本。
### 示例代码段
下面的代码段为 rpm 指定版本 URL，从 yum 请求最新版本并从 rubygems 请求 chef 的版本 0.10.2。
```
packages:
yum:
libmemcached: []
ruby-devel: []
gcc: []
rpm:
epel: http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm
rubygems:
chef: '0.10.2'
```
## 组
您可以使用`groups`密钥创建 Linux/UNIX 群组和分配群组 IDs。要创建组，请添加新的密钥值对，将新的组名映射到可选组 ID。组键可以包含一个或多个组名。下表列出了可用的密钥。
### 语法
```
groups:
name of group: {}
name of group:
gid: "group id"
```
### 选项
`gid`
组 ID 编号。
如果指定了组 ID，且存在该名称的组，那么创建组将失败。如果另一个组已拥有所指定的组 ID，那么操作系统可能会拒绝创建组。
### 示例代码段
以下代码段指定了一个名为“groupOne”、但没有分配组 ID 的组，以及一个名为“groupTwo”、但指定了组 ID 值为 45 的组。
```
groups:
groupOne: {}
groupTwo:
gid: "45"
```
## Users
您可以使用`users`密钥在 EC2 实例上创建 Linux/UNIX 用户。
### 语法
```
users:
name of user:
groups:
- name of group
uid: "id of the user"
homeDir: "user's home directory"
```
### 选项
`uid`
用户 ID。如果用户名还有另一个用户 ID，那么此创建过程会失败。如果用户 ID 已指定给现有的用户，那么操作系统可能会拒绝该创建请求。
`groups`
一系列组名。用户会添加到列表中的每个组。
`homeDir`
用户的主目录。
创建的用户属于非交互式系统用户，带有 `/sbin/nologin` Shell。这是特意设计的，无法修改。
### 示例代码段
```
users:
myuser:
groups:
- group1
- group2
uid: "50"
homeDir: "/tmp"
```
## 来源
您可以使用`sources`密钥从公共 URL 下载存档文件，然后将其解压缩到 EC2 实例的目标目录中。
### 语法
```
sources:
target directory: location of archive file
```
### 支持的格式
支持的格式有 tar、tar\$1gzip、tar\$1bz2 和 Zip。只要该 URL 可公开访问，您就可以引用 Amazon Simple Storage Service (Amazon S3) 等外部位置 (例如，`https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject`)。
### 示例代码段
以下示例会从 Amazon S3 存储桶下载一个公有 .zip 文件并将其解压到 `/etc/myapp` 中：
```
sources:
/etc/myapp: https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject
```
**注意**
多个提取不应重用相同的目标路径。将其他源提取到项目的相同目标路径上将替换内容而不是附加到内容上。
## 文件
您可以使用`files`密钥在 EC2 实例上创建文件。该内容可以內嵌在配置文件中，也可以从 URL 中提取。这些文件会按词典顺序写入磁盘。
您可以提供一个用于授权的实例配置文件，从而使用 `files` 密钥从 Amazon S3 下载私有文件。
如果您指定的文件路径已在实例上存在，则将保留现有文件，并在其名称后附加扩展名 `.bak`。
### 语法
```
files:
"target file location on disk":
mode: "six-digit octal value"
owner: name of owning user for file
group: name of owning group for file
source: URL
authentication: authentication name:
"target file location on disk":
mode: "six-digit octal value"
owner: name of owning user for file
group: name of owning group for file
content: |
# this is my
# file content
encoding: encoding format
authentication: authentication name:
```
### 选项
`content`
要添加到文件的字符串内容。指定 `content` 或 `source`，但不能同时指定两者。
`source`
要下载的文件的 URL。指定 `content` 或 `source`，但不能同时指定两者。
`encoding`
使用 `content` 选项指定的字符串的编码格式。
有效值：`plain` \$1 `base64`
`group`
拥有文件的 Linux 组。
`owner`
拥有文件的 Linux 用户。
`mode`
是一个六位数的八进制值，表示这个文件的模式。在 Windows 系统中不受支持。将前三位数用于符号链接，将后三位数用于设置权限。要创建符号链接，请指定 `120xxx`，其中 `xxx` 定义目标文件的权限。要指定文件的权限，请使用最后三位，例如 `000644`。
`authentication`
要使用的 [CloudFormation 身份验证方法](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-authentication.html)的名称。您可以使用资源键将身份验证方法添加到 Auto Scaling 组元数据。有关示例，请参阅以下内容。
### 示例代码段
```
files:
"/home/ec2-user/myfile" :
mode: "000755"
owner: root
group: root
source: http://foo.bar/myfile
"/home/ec2-user/myfile2" :
mode: "000755"
owner: root
group: root
content: |
this is my
file content
```
使用符号链接的示例。这会创建指向现有文件 `/tmp/myfile2.txt` 的链接 `/tmp/myfile1.txt`。
```
files:
"/tmp/myfile2.txt" :
mode: "120400"
content: "/tmp/myfile1.txt"
```
以下示例使用资源键添加名为 S3Auth 的身份验证方法并使用该方法从 Amazon S3 存储桶下载私有文件：
```
Resources:
AWSEBAutoScalingGroup:
Metadata:
AWS::CloudFormation::Authentication:
S3Auth:
type: "s3"
buckets: ["amzn-s3-demo-bucket2"]
roleName:
"Fn::GetOptionSetting":
Namespace: "aws:autoscaling:launchconfiguration"
OptionName: "IamInstanceProfile"
DefaultValue: "aws-elasticbeanstalk-ec2-role"
files:
"/tmp/data.json" :
mode: "000755"
owner: root
group: root
authentication: "S3Auth"
source: https://elasticbeanstalk-us-west-2-123456789012.s3-us-west-2.amazonaws.com/data.json
```
## 命令
您可以使用该`commands`密钥在 EC2 实例上执行命令。这些命令在应用程序之前运行，设置 Web 服务器以及提取应用程序版本文件。
指定的命令以根用户身份运行且按名称的字母顺序进行处理。默认情况下，该命令在根目录中运行。要从另一个目录运行命令，请使用 `cwd` 选项。
要使用您的命令排查问题，您可以在[实例日志](using-features.logging.md)中查找其输出。
### 语法
```
commands:
command name:
command: command to run
cwd: working directory
env:
variable name: variable value
test: conditions for command
ignoreErrors: true
```
### 选项
`command`
一个数组（YAML 语法中的[数据块序列集合](http://yaml.org/spec/1.2/spec.html#id2759963)）或一个用于指定要运行的命令的字符串。一些重要说明：
+ 如果您使用了字符串，则不需要用引号将整个字符串引起来。如果您确实使用了引号，请对相同类型的引号的文本匹配项进行转义。
+ 如果您使用了数组，则不需要对空格字符进行转义或用引号将命令参数引起来。每个数组元素都是一个命令参数。请勿使用数组指定多个命令。
以下示例具有完全相同的效果：
```
commands:
command1:
command: git commit -m "This is a comment."
command2:
command: "git commit -m \"This is a comment.\""
command3:
command: 'git commit -m "This is a comment."'
command4:
command:
- git
- commit
- -m
- This is a comment.
```
要指定多个命令，请使用[文本数据块标量](http://yaml.org/spec/1.2/spec.html#id2760844)，如以下示例所示。
```
commands:
command block:
command: |
git commit -m "This is a comment."
git push
```
`env`
(可选) 设置该命令的环境变量。这个属性会覆盖而不是追加到现有的环境。
`cwd`
(可选) 工作目录。如果未指定，命令将从根目录 (/) 运行。
`test`
（可选）一个命令，此命令必须返回值 `true`（退出代码为 0），以便 Elastic Beanstalk 处理 `command` 键中包含的命令，例如 shell 脚本。
`ignoreErrors`
(可选) 一个布尔值，该值确定在 `command` 密钥中包含的命令失败时 (返回非零值) 是否应该运行其他命令。如果要在命令失败后继续运行其他命令，请将该值设置为 `true`。否则，请将该值设置为 `false`。默认值为 `false`。
### 示例代码段
以下示例代码段运行 Python 脚本。
```
commands:
python_install:
command: myscript.py
cwd: /home/ec2-user
env:
myvarname: myvarvalue
test: "[ -x /usr/bin/python ]"
```
## Services
您可以使用 `services` 键定义哪些服务应该在实例启动时启动或者停止。`services` 键还可让您在源、包和文件上指定依赖项，以便在由于文件安装而需要重启时，让 Elastic Beanstalk 负责服务的重启。
### 语法
```
services:
sysvinit:
name of service:
enabled: "true"
ensureRunning: "true"
files:
- "file name"
sources:
- "directory"
packages:
name of package manager:
"package name[: version]"
commands:
- "name of command"
```
### 选项
`ensureRunning`
设置为 `true` 可确保在 Elastic Beanstalk 完成后服务能够运行。
设置为 `false` 可确保该服务在 Elastic Beanstalk 完成后不运行。
忽略该密钥，将不更改服务状态。
`enabled`
设置为 `true`，可确保该服务在启动时自动启动。
设置为 `false`，可确保该服务在启动时不会自动启动。
忽略该密钥，将不更改这个属性。
`files`
一系列文件。如果 Elastic Beanstalk 直接通过文件块更改一个文件，则该服务会重启。
`sources`
一系列目录。如果 Elastic Beanstalk 将存档展开到这些目录中的一个，则该服务会重启。
`packages`
包管理器与一系列包名的映射。如果 Elastic Beanstalk 安装或者更新了这些包中的一个，则该服务会重启。
`commands`
一系列命令名称。如果 Elastic Beanstalk 运行指定的命令，则服务将重新启动。
### 示例代码段
以下是示例代码段：
```
services:
sysvinit:
myservice:
enabled: true
ensureRunning: true
```
## 容器命令
您可以使用 `container_commands` 键执行将影响应用程序源代码的命令。容器命令将在设置应用程序和 Web 服务器并提取应用程序版本存档后，但在部署应用程序版本前运行。非容器命令和其他自定义操作将在提取应用程序源代码之前执行。
指定的命令以根用户身份运行且按名称的字母顺序进行处理。容器命令从暂存目录运行，您的源代码在部署到应用程序服务器前在这里提取。当源部署到其最终位置时，将包含您在暂存目录中使用容器命令对源代码所做的任何更改。
**注意**
您的容器命令的输出记录在 `cfn-init-cmd.log` 实例日志中。有关检索和查看实例日志的更多信息，请参阅[查看来自 Amazon EC2 实例的日志](using-features.logging.md)。
可以使用 `leader_only` 仅对单个实例运行此命令，也可以配置 `test` 以仅在测试命令的评估结果为 `true` 时运行此命令。仅领导容器命令只在创建和部署环境期间执行，而其他命令和服务器自定义操作将在预配置或更新实例时执行。由于启动配置发生更改 (例如 AMI Id 或实例类型的更改)，未执行仅领导容器命令。
### 语法
```
container_commands:
name of container_command:
command: "command to run"
leader_only: true
name of container_command:
command: "command to run"
```
### 选项
`command`
要运行的字符串或字符串数组。
`env`
(可选) 在运行命令之前设置环境变量，并覆盖任何现有值。
`cwd`
(可选) 工作目录。默认情况下，这是解压缩应用程序的暂存目录。
`leader_only`
（可选）仅对 Elastic Beanstalk 选定的单个实例运行命令。仅领导容器命令将在其他容器命令之前运行。命令可以是仅领导命令或具有 `test`，但不能同时具备这两个特性 (`leader_only` 优先)。
`test`
(可选) 运行必须返回 `true` 的测试命令以便运行容器命令。命令可以是仅领导命令或具有 `test`，但不能同时具备这两个特性 (`leader_only` 优先)。
`ignoreErrors`
(可选) 不在容器命令返回 0 以外的值 (成功) 时导致部署失败。设置为 `true` 可实现这一点。
### 示例代码段
以下是示例代码段。
```
container_commands:
collectstatic:
command: "django-admin.py collectstatic --noinput"
01syncdb:
command: "django-admin.py syncdb --noinput"
leader_only: true
02migrate:
command: "django-admin.py migrate"
leader_only: true
99customize:
command: "scripts/customize.sh"
```
# 示例：使用自定义 Amazon CloudWatch 指标
本主题提供了一个配置示例，该示例将基于亚马逊 Linux 2 及更高版本的平台的 Elastic Beanstalk 指标 CloudWatch 与亚马逊代理集成。配置示例使用 `.ebextensions` 配置文件中的文件和命令。
Amazon CloudWatch 是一项网络服务，可让您监控、管理和发布各种指标，并根据指标中的数据配置警报操作。您可以定义自定义指标供自己使用，Elastic Beanstalk 会将这些指标推送到亚马逊。 CloudWatch一旦亚马逊 CloudWatch 包含您的自定义指标，您就可以在亚马逊 CloudWatch 控制台中查看这些指标。
**亚马逊 CloudWatch 代理**
Amazon CloudWatch 代理支持跨操作系统从 Amazon EC2 实例和本地服务器收集 CloudWatch 指标和日志。代理支持在系统级别收集的指标。此外，它还支持从应用程序或服务中收集自定义日志和指标。有关亚马逊 CloudWatch 代理的更多信息，请参阅*亚马逊 CloudWatch 用户指南*[中的通过 CloudWatch 代理收集指标和日志](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html)。
**注意**
Ela [stic Beanstalk 增强型](health-enhanced.md)健康报告原生支持将各种实例和环境指标发布到。 CloudWatch有关详细信息，请参阅 [为环境发布 Amazon CloudWatch 自定义指标](health-enhanced-cloudwatch.md)。
**Topics**
+ [.Ebextensions 配置文件](#customize-containers-cw-update-roles)
+ [Permissions](#customize-containers-cw-policy)
+ [在 CloudWatch 控制台中查看指标](#customize-containers-cw-console)
## .Ebextensions 配置文件
此示例使用.ebextensions 配置文件中的文件和命令在 Amazon Linux 2 平台 CloudWatch 上配置和运行亚马逊代理。此代理预先包装在 Amazon Linux 2 中。如果您使用的是其他操作系统，则可能需要执行其他安装代理的步骤。有关更多信息，请参阅 *Amazon CloudWatch 用户指南*中的[安装 CloudWatch 代理](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-on-EC2-Instance.html)。
要使用该示例，请将其保存到名为 `cloudwatch.config` 的文件中，并将该文件放到项目目录顶层的 `.ebextensions` 目录中，然后使用 Elastic Beanstalk 控制台（在[源包](applications-sourcebundle.md)中包括 .ebextensions 目录）或 [EB CLI](eb-cli3.md) 部署您的应用程序。
有关配置文件的详细信息，请参阅 [使用配置文件 (`.ebextensions`) 进行高级环境自定义](ebextensions.md)。
此文件有以下两个部分：
+ `files` — 此部分添加代理配置文件。它指示代理应向 Amazon 发送哪些指标和日志 CloudWatch。在此示例中，我们只发送 *mem\$1used\$1percent* 指标。有关亚马逊 CloudWatch 代理支持的系统级指标的完整列表，请参阅*亚马逊 CloudWatch 用户指南*[中的 CloudWatch 代理收集的指标](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html)。
+ `container_commands` — 本部分包含启动代理的命令，并将配置文件作为参数传递。有关 `container_commands` 的更多详细信息，请参阅 [容器命令](customize-containers-ec2.md#linux-container-commands)。
**.ebextensions/cloudwatch.config**
```
files:
"/opt/aws/amazon-cloudwatch-agent/bin/config.json":
mode: "000600"
owner: root
group: root
content: |
{
"agent": {
"metrics_collection_interval": 60,
"run_as_user": "root"
},
"metrics": {
"namespace": "System/Linux",
"append_dimensions": {
"AutoScalingGroupName": "${aws:AutoScalingGroupName}"
},
"metrics_collected": {
"mem": {
"measurement": [
"mem_used_percent"
]
}
}
}
}
container_commands:
start_cloudwatch_agent:
command: /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a append-config -m ec2 -s -c file:/opt/aws/amazon-cloudwatch-agent/bin/config.json
```
## Permissions
您环境中的实例需要适当的 IAM 权限才能使用亚马逊 CloudWatch 代理发布自定义亚马逊 CloudWatch 指标。您可以将您的环境中的实例添加到此环境的[实例配置文件](concepts-roles-instance.md)中，从而向它们授予权限。您可以在部署应用程序前/后为此实例配置文件添加权限。
**授予发布 CloudWatch 指标的权限**
1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。
1. 在导航窗格中，选择**角色**。
1. 选择您的环境的实例配置文件角色。在使用 Elastic Beanstalk 控制台或 [EB CLI](eb-cli3.md) 创建环境时，该角色默认为 `aws-elasticbeanstalk-ec2-role`。
1. 选择**权限**选项卡。
1. 在 **Permissions Policies**（权限策略）下，**Permissions**（权限）部分中，选择 **Attach policies**（附加策略）。
1. 在 “**附加权限**” 下，选择 AWS 托管策略**CloudWatchAgentServerPolicy**。然后单击 **Attach policy**（附加策略）。
有关如何管理策略的更多信息，请参阅《IAM 用户指南》**中的[使用策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html)。
## 在 CloudWatch 控制台中查看指标
将 CloudWatch 配置文件部署到您的环境后，请查看 [Amazon CloudWatch 控制台](https://console.aws.amazon.com/cloudwatch/home)以查看您的指标。自定义指标将位于**CWAgent**命名空间中。
有关更多信息，请参阅《*Amazon CloudWatch 用户指南*》中的[查看可用指标](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html)。
# 自定义 Windows Server 上的软件
建议自定义和配置您的应用程序所依赖的软件。这些文件可能是该应用程序所要求的依赖项，例如需要运行的其他软件包或服务。有关自定义和配置 Elastic Beanstalk 环境的一般信息，请参阅[配置 Elastic Beanstalk 环境](customize-containers.md)。
**注意**
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
配置文件支持以下可对运行您的应用程序的 Windows 服务器产生影响的键。
**Topics**
+ [软件包](#windows-packages)
+ [来源](#windows-sources)
+ [文件](#windows-files)
+ [命令](#windows-commands)
+ [Services](#windows-services)
+ [容器命令](#windows-container-commands)
将按键在此处列出的顺序对其进行处理。
**注意**
较旧（不受版本控制）的 .NET 平台版本不会按正确顺序处理配置文件。有关更多信息，请参阅 [跨 Elastic BeanstalkWindows Server 平台的主要版本迁移](dotnet-v2migration.md)。
观察您的环境的[事件](using-features.events.md)，同时开发和测试配置文件。Elastic Beanstalk 将忽略包含验证错误的配置文件（例如“密钥无效”），并且不会处理同一文件中的任何其他密钥。出现这种情况时，Elastic Beanstalk 将警告事件添加到事件日志中。
## 软件包
使用 `packages` 键下载并安装预先打包的应用程序和组件。
在 Windows 环境中，Elastic Beanstalk 支持下载和安装 MSI 软件包。（Linux 环境支持其他软件包管理器。有关详细信息，请参阅*在 Linux 服务器上自定义软件*页面上的 [软件包](customize-containers-ec2.md#linux-packages)。）
只要该 URL 可公开访问，您就可以引用 Amazon Simple Storage Service (Amazon S3) 对象等任意外部位置。
如果您指定了多个 `msi:` 程序包，则无法保证其安装顺序。
### 语法
指定您选择的名称作为软件包名称，而且指定 MSI 文件位置的 URL 作为该值。您可以在 `msi:` 密钥下指定多个程序包。
```
packages:
msi:
package name: package url
...
```
### 示例
下面的示例指定了从 `https://dev.mysql.com/` 中下载 **mysql** 的 URL。
```
packages:
msi:
mysql: https://dev.mysql.com/get/Downloads/Connector-Net/mysql-connector-net-8.0.11.msi
```
以下示例指定了 Amazon S3 对象作为 MSI 文件位置。
```
packages:
msi:
mymsi: https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject.msi
```
## 来源
使用 `sources` 键从公有 URL 下载存档文件并将其解压到 EC2 实例上的目标目录中。
### 语法
```
sources:
target directory: location of archive file
```
### 支持的格式
在 Windows 环境中，Elastic Beanstalk 支持 .zip 格式。（Linux 环境支持其他格式。有关详细信息，请参阅*在 Linux 服务器上自定义软件*页面上的 [来源](customize-containers-ec2.md#linux-sources)。）
只要该 URL 可公开访问，您就可以引用 Amazon Simple Storage Service (Amazon S3) 对象等任意外部位置。
### 示例
以下示例会从 Amazon S3 下载一个公有 .zip 文件并将其解压到 `c:/myproject/myapp` 中。
```
sources:
"c:/myproject/myapp": https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject.zip
```
## 文件
使用 `files` 键在 EC2 实例上创建文件。内容可以内嵌在配置文件中，也可以取自 URL。这些文件会按词典顺序写入磁盘。要从 Amazon S3 下载私有文件，请提供实例配置文件以进行授权。
### 语法
```
files:
"target file location on disk":
source: URL
authentication: authentication name:
"target file location on disk":
content: |
this is my content
encoding: encoding format
```
### 选项
`content`
(可选) 一个字符串。
`source`
(可选) 加载文件的 URL。不能使用内容密钥指定该选项。
`encoding`
(可选) 编码格式。此选项只用于所提供的内容键值。默认值为 `plain`。
有效值：`plain` \$1 `base64`
`authentication`
（可选）要使用的 [CloudFormation 身份验证方法](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-authentication.html)的名称。您可以使用资源键将身份验证方法添加到 Auto Scaling 组元数据。
### 示例
以下示例显示了提供文件内容的两种方式：通过 URL 或内嵌在配置文件中。
```
files:
"c:\\targetdirectory\\targetfile.txt":
source: http://foo.bar/myfile
"c:/targetdirectory/targetfile.txt":
content: |
# this is my file
# with content
```
**注意**
如果您在文件路径中使用反斜杠 (\$1)，则必须在它前面再插入一个反斜杠 (转义字符)，如上例所示。
以下示例使用资源键添加名为 S3Auth 的身份验证方法并使用该方法从 Amazon S3 下载私有文件：
```
files:
"c:\\targetdirectory\\targetfile.zip":
source: https://elasticbeanstalk-us-east-2-123456789012.s3.amazonaws.com/prefix/myfile.zip
authentication: S3Auth
Resources:
AWSEBAutoScalingGroup:
Metadata:
AWS::CloudFormation::Authentication:
S3Auth:
type: "s3"
s: ["amzn-s3-demo-bucket"]
roleName:
"Fn::GetOptionSetting":
Namespace: "aws:autoscaling:launchconfiguration"
OptionName: "IamInstanceProfile"
DefaultValue: "aws-elasticbeanstalk-ec2-role"
```
## 命令
使用 `commands` 键在 EC2 实例上执行命令。该命令是按名称的字母顺序处理的，它们会在安裝应用程序和 Web 服务器以及提取应用程序版本文件前运行。
管理员用户身份可运行指定的命令。
要使用您的命令排查问题，您可以在[实例日志](using-features.logging.md)中查找其输出。
### 语法
```
commands:
command name:
command: command to run
```
### 选项
`command`
指定要运行的命令的数组或字符串。如果您使用了数组，则不需要对空格字符进行转义或用引号将命令参数引起来。
`cwd`
(可选) 工作目录。默认情况下，Elastic Beanstalk 会尝试查找项目的目录位置。如果找不到，则它会使用 `c:\Windows\System32` 作为默认目录位置。
`env`
(可选) 设置该命令的环境变量。这个属性会覆盖而不是追加到现有的环境。
`ignoreErrors`
（可选）一个布尔值，该值确定在 `command` 密钥中包含的命令失败时（返回非零值）是否应该运行其他命令。如果要在命令失败后继续运行其他命令，请将该值设置为 `true`。否则，请将该值设置为 `false`。默认值为 `false`。
`test`
（可选）一种命令，该命令必须返回值 `true`（退出代码 0），以便 Elastic Beanstalk 处理 `command` 键中包含的命令。
`waitAfterCompletion`
(可选) 在命令完成后、运行下一个命令前等待的秒数。默认值为 **60** 秒。您还可以指定 **forever**。
不支持在部署期间重启系统。如果系统因命令而重启，则实例初始化将失败，从而导致部署失败。
要解决此问题，您可以使用此 [https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/instance-configuration/windows-configuration/scheduled-restart.config](https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/instance-configuration/windows-configuration/scheduled-restart.config) 来安排在部署完成后进行重启。
### 示例
下面的示例将 `set` 命令的输出保存到指定的文件。如果有后续命令，Elastic Beanstalk 会在此命令完成后立即运行后续命令。如果命令需要重新启动，则 Elastic Beanstalk 会在命令完成后立即重新启动实例。
```
commands:
test:
command: set > c:\\myapp\\set.txt
waitAfterCompletion: 0
```
## Services
使用 `services` 键定义哪些服务应该在实例启动时启动或者停止。`services` 键还可让您指定源、包和文件的依赖项，以便在由于文件安装而需要重启时，让 Elastic Beanstalk 负责服务的重启。
### 语法
```
services:
windows:
name of service:
files:
- "file name"
sources:
- "directory"
packages:
name of package manager:
"package name[: version]"
commands:
- "name of command"
```
### 选项
`ensureRunning`
（可选）设置为 `true` 可确保在 Elastic Beanstalk 完成后服务能够运行。
设置为 `false` 可确保该服务在 Elastic Beanstalk 完成后不运行。
忽略该密钥，将不更改服务状态。
`enabled`
(可选) 设为 `true` 以确保此服务在启动时自动启动。
设置为 `false`，可确保该服务在启动时不会自动启动。
忽略该密钥，将不更改这个属性。
`files`
一系列文件。如果 Elastic Beanstalk 直接通过文件块更改一个文件，则该服务会重启。
`sources`
一系列目录。如果 Elastic Beanstalk 将存档展开到这些目录中的一个，则该服务会重启。
`packages`
包管理器与一系列包名的映射。如果 Elastic Beanstalk 安装或者更新了这些包中的一个，则该服务会重启。
`commands`
一系列命令名称。如果 Elastic Beanstalk 运行指定的命令，则服务将重新启动。
### 示例
```
services:
windows:
myservice:
enabled: true
ensureRunning: true
```
## 容器命令
使用 `container_commands` 键执行将影响应用程序源代码的命令。容器命令将在设置应用程序和 Web 服务器并提取应用程序版本存档后，但在部署应用程序版本前运行。非容器命令和其他自定义操作将在提取应用程序源代码之前执行。
容器命令从暂存目录运行，您的源代码在部署到应用程序服务器前在这里提取。当源部署到其最终位置时，将包含您在暂存目录中使用容器命令对源代码所做的任何更改。
要使用您的容器命令排查问题，您可以在[实例日志](using-features.logging.md)中查找其输出。
可以使用 `leader_only` 选项只对单个实例运行此命令，也可以配置 `test` 以只在测试命令的评估结果为 `true` 时运行此命令。仅领导容器命令只在创建和部署环境期间执行，而其他命令和服务器自定义操作将在预配置或更新实例时执行。由于启动配置发生更改 (例如 AMI Id 或实例类型的更改)，未执行仅领导容器命令。
### 语法
```
container_commands:
name of container_command:
command: command to run
```
### 选项
`command`
要运行的字符串或字符串数组。
`env`
(可选) 在运行命令之前设置环境变量，并覆盖任何现有值。
`cwd`
(可选) 工作目录。默认情况下，这是解压缩应用程序的暂存目录。
`leader_only`
（可选）仅对 Elastic Beanstalk 选定的单个实例运行命令。仅领导容器命令将在其他容器命令之前运行。命令可以是仅领导命令或具有 `test`，但不能同时具备这两个特性 (`leader_only` 优先)。
`test`
(可选) 运行必须返回 `true` 的测试命令以便运行容器命令。命令可以是仅领导命令或具有 `test`，但不能同时具备这两个特性 (`leader_only` 优先)。
`ignoreErrors`
(可选) 不在容器命令返回 0 以外的值 (成功) 时导致部署失败。设置为 `true` 可实现这一点。
`waitAfterCompletion`
(可选) 在命令完成后、运行下一个命令前等待的秒数。默认值为 **60** 秒。您还可以指定 **forever**。
不支持在部署期间重启系统。如果系统因命令而重启，则实例初始化将失败，从而导致部署失败。
要解决此问题，您可以使用此 [https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/instance-configuration/windows-configuration/scheduled-restart.config](https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/instance-configuration/windows-configuration/scheduled-restart.config) 来安排在部署完成后进行重启。
### 示例
下面的示例将 `set` 命令的输出保存到指定的文件。Elastic Beanstalk 在一个实例上运行此命令，并在命令完成后立即重新启动实例。
```
container_commands:
foo:
command: set > c:\\myapp\\set.txt
leader_only: true
waitAfterCompletion: 0
```
# 添加和自定义 Elastic Beanstalk 环境资源
您可能希望自定义属于 Elastic Beanstalk 环境一部分的环境资源。例如，您可能想要添加 Amazon SQS 队列和队列深度警报，或者您可能想要添加一个 Ama ElastiCache zon 集群。在部署应用程序版本的同时，您就可以轻松地自定义环境，只需使用源包将配置文件添加进来即可。
您可以使用[配置文件](ebextensions.md)中的`Resources`密钥在您的环境中创建和自定义 AWS 资源。配置文件中定义的资源将添加到用于启动环境的 CloudFormation 模板中。支持所有 CloudFormation [资源类型](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)。
**注意**
每当您添加不由 Elastic Beanstalk 管理的资源时，请务必为您的 (IAM) 用户添加具有相应权限 AWS Identity and Access Management 的用户策略。Elastic Beanstalk 提供的[托管用户策略](AWSHowTo.iam.managed-policies.md)仅涵盖对 Elastic Beanstalk 托管资源的权限。
例如，以下配置文件将 Auto Scaling 生命周期挂钩添加到 Elastic Beanstalk 创建的默认 Auto Scaling 组中：
**`~/my-app/.ebextensions/as-hook.config`**
```
Resources:
hookrole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument: {
"Version": "2012-10-17",
"Statement": [ {
"Effect": "Allow",
"Principal": {
"Service": [ "autoscaling.amazonaws.com" ]
},
"Action": [ "sts:AssumeRole" ]
} ]
}
Policies: [ {
"PolicyName": "SNS",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Resource": "*",
"Action": [
"sqs:SendMessage",
"sqs:GetQueueUrl",
"sns:Publish"
]
}
]
}
} ]
hooktopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Endpoint: "my-email@example.com"
Protocol: email
lifecyclehook:
Type: AWS::AutoScaling::LifecycleHook
Properties:
AutoScalingGroupName: { "Ref" : "AWSEBAutoScalingGroup" }
LifecycleTransition: autoscaling:EC2_INSTANCE_TERMINATING
NotificationTargetARN: { "Ref" : "hooktopic" }
RoleARN: { "Fn::GetAtt" : [ "hookrole", "Arn"] }
```
此示例定义三个资源：`hookrole`、`hooktopic` 和 `lifecyclehook`。前两个资源是 IAM 角色，它授予 Amazon A EC2 uto Scaling 向亚马逊 SNS 发布消息的权限，以及一个 SNS 主题，用于将来自 Auto Scaling 组的消息中继到电子邮件地址。Elastic Beanstalk 使用指定的属性和类型创建这些资源。
最后一个资源 `lifecyclehook` 是生命周期钩子本身：
```
lifecyclehook:
Type: AWS::AutoScaling::LifecycleHook
Properties:
AutoScalingGroupName: { "Ref" : "AWSEBAutoScalingGroup" }
LifecycleTransition: autoscaling:EC2_INSTANCE_TERMINATING
NotificationTargetARN: { "Ref" : "hooktopic" }
RoleARN: { "Fn::GetAtt" : [ "hookrole", "Arn"] }
```
生命周期钩子使用两个[函数](ebextensions-functions.md)填充钩子属性值。`{ "Ref" : "AWSEBAutoScalingGroup" }` 检索 Elastic Beanstalk 为环境创建的 Auto Scaling 组的名称。`AWSEBAutoScalingGroup` 是 Elastic Beanstalk 提供的标准[资源名称](customize-containers-format-resources-eb.md)之一。
对于 `[AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#d0e48356)`，`Ref` 只返回角色名称，而不返回 ARN。要获取 `RoleARN` 参数的 ARN，需要改用另一个内部函数 `Fn::GetAtt`，该函数获取一个资源的所有属性。`RoleARN: { "Fn::GetAtt" : [ "hookrole", "Arn"] }` 将从 `hookrole` 资源获取 `Arn` 属性。
`{ "Ref" : "hooktopic" }` 获取之前在配置文件中创建的 Amazon SNS 主题的 ARN。返回的值因资源类型`Ref`而异，可以在该[ AWS::SNS::Topic 资源类型的 CloudFormation 用户指南主题](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html#d0e62250)中找到。
# 修改 Elastic Beanstalk 为环境创建的资源
Elastic Beanstalk 为您的环境创建的资源有名称。您可以使用这些名称通过[函数](ebextensions-functions.md)来获取有关资源的信息，或修改资源中的属性来自定义其行为。本主题介绍了 Elastic Beanstalk 在不同类型的环境中使用的 AWS 资源。
**注意**
上一主题[自定义资源](environment-resources.md)提供了一些用于自定义环境资源的使用案例和示例。另外，您可以在后面的主题 [自定义资源示例](customize-environment-resources-examples.md) 中找到更多配置文件示例。
Web 服务器环境具有以下资源。
**Web 服务器环境**
+ `AWSEBAutoScalingGroup`（[AWS::AutoScaling::AutoScaling群组](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-group.html)）— 连接到您的环境的 Auto Scaling 群组。
+ 以下两种资源之一。
+ `AWSEBAutoScalingLaunchConfiguration`([AWS::AutoScaling::LaunchConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-launchconfig.html))-附加到您环境的 Auto Scaling 组的启动配置。
+ `AWSEBEC2LaunchTemplate`([AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html)) — 您的环境的 Auto Scaling 组使用的 Amazon EC2 启动模板。
**注意**
如果您的环境使用需要 Amazon EC2 启动模板的功能，并且您的用户策略缺少所需权限，则创建或更新环境可能会失败。[使用 **AdministratorAccess-AWSElastic Beanstalk**[托管用户策略](AWSHowTo.iam.managed-policies.md)，或向您的自定义策略添加所需的权限。](AWSHowTo.iam.managed-policies.md#AWSHowTo.iam.policies)
+ `AWSEBEnvironmentName`([AWS::ElasticBeanstalk::Environment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-beanstalk-environment.html)) — 您的环境。
+ `AWSEBSecurityGroup`([AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html)) — 附加到您的 Auto Scaling 组的安全组。
+ `AWSEBRDSDatabase`([AWS:: RDS:: DBInstance](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-rds-database-instance.html)) — 连接到您的环境的 Amazon RDS 数据库实例（如果适用）。
在负载均衡的环境中，您可以访问与负载均衡器相关的其他资源。传统负载均衡器有一个资源用于负载均衡器，一个资源用于连接到它的安全组。应用程序和网络负载均衡器还有附加资源可用于负载均衡器的默认侦听器、侦听器规则和目标组。
**负载均衡环境**
+ `AWSEBLoadBalancer`([AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-elb.html))-您的环境的经典负载均衡器。
+ `AWSEBV2LoadBalancer`([AWS::ElasticLoadBalancingV2::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-loadbalancer.html))-您的环境的应用程序或网络负载均衡器。
+ `AWSEBLoadBalancerSecurityGroup`([AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html)) — 仅在自定义[亚马逊虚拟私有云](https://docs.aws.amazon.com/vpc/latest/userguide/)（亚马逊 VPC）中，Elastic Beanstalk 为负载均衡器创建的安全组的名称。在默认 VPC 或 EC2 Classic 中，Elastic Load Balancing 会将默认安全组分配给负载均衡器。
+ `AWSEBV2LoadBalancerListener`([AWS::ElasticLoadBalancingV2::Listener](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listener.html)) — 允许负载均衡器检查连接请求并将其转发给一个或多个目标组的侦听器。
+ `AWSEBV2LoadBalancerListenerRule`([AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listenerrule.html)) — 定义 Elastic Load Balancing 侦听器对哪些请求采取操作以及它采取的操作。
+ `AWSEBV2LoadBalancerTargetGroup`([AWS::ElasticLoadBalancingV2::TargetGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html)) — 一个 Elastic Load Balancing 目标组，用于将请求路由到一个或多个注册目标，例如 Amazon EC2 实例。
工作线程环境具有用于可缓存传入请求的 SQS 队列的资源，还有一个 Amazon DynamoDB 表，实例可使用该表来选择领导。
**工作线程环境**
+ `AWSEBWorkerQueue`([AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sqs-queues.html)) — Amazon SQS 队列，守护程序从中提取需要处理的请求。
+ `AWSEBWorkerDeadLetterQueue`([AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sqs-queues.html)) — Amazon SQS 队列，用于存储守护程序无法传送或未成功处理的消息。
+ `AWSEBWorkerCronLeaderRegistry`([AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html)) — Amazon DynamoDB 表，它是守护程序用于执行定期任务的内部注册表。
# 其他 CloudFormation 模板密钥
我们已经引入了 CloudFormation 诸如`Resources``files`、和之类的配置文件密钥`packages`。Elastic Beanstalk 将配置文件 CloudFormation 内容添加到支持您的环境的模板中，因此 CloudFormation 您可以使用其他部分在配置文件中执行高级任务。
**Topics**
+ [参数](#ebextensions-otherkeys-parameters)
+ [输出](#ebextensions-otherkeys-outputs)
+ [映像](#ebextensions-otherkeys-mappings)
## 参数
参数是 Elastic Beanstalk 自己的[自定义选项](configuration-options-custom.md)的替代项，您可以用来定义要在配置文件的其他位置使用的值。与自定义选项相似，您可以使用参数在一个位置，收集用户可配置值。与自定义选项不同，您不能使用 Elastic Beanstalk 的 API 来设置参数值，并且可以在模板中定义的参数数量受到限制。 CloudFormation
您可能想要使用参数的原因之一是让您的配置文件兼作 CloudFormation 模板。如果您使用参数而不是自定义选项，则可以使用配置文件在中 CloudFormation 创建与其自己的堆栈相同的资源。例如，您可能有一个配置文件用于向环境中添加用于测试的 Amazon EFS 文件系统，然后使用同一个文件创建独立的文件系统，不绑定到用于生产用途的环境生命周期。
以下示例演示使用参数在配置文件顶部收集用户可配置的值。
**Example [L oadbalancer-accesslogs-existingbucket .config](https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/resource-configuration/loadbalancer-accesslogs-existingbucket.config) — 参数**
```
Parameters:
bucket:
Type: String
Description: "Name of the Amazon S3 bucket in which to store load balancer logs"
Default: "amzn-s3-demo-bucket"
bucketprefix:
Type: String
Description: "Optional prefix. Can't start or end with a /, or contain the word AWSLogs"
Default: ""
```
## 输出
您可以使用 `Outputs` 数据块，将有关已创建资源的信息导出到 CloudFormation。然后，你可以使用该`Fn::ImportValue`函数将该值提取到 Elastic Beanstalk 之外的 CloudFormation 模板中。
以下示例创建了一个 Amazon SNS 主题，并将其 ARN 导出到名称为。 CloudFormation `NotificationTopicArn`
**Example [sns-topic.config](https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/resource-configuration/sns-topic.config)**
```
Resources:
NotificationTopic:
Type: AWS::SNS::Topic
Outputs:
NotificationTopicArn:
Description: Notification topic ARN
Value: { "Ref" : "NotificationTopic" }
Export:
Name: NotificationTopicArn
```
在其他环境的配置文件或 Elastic Beanstalk 之外的 CloudFormation 模板中，`Fn::ImportValue`您可以使用该函数来获取导出的 ARN。此示例将导出的值分配给名为 `TOPIC_ARN` 的环境属性。
**Example env.config**
```
option_settings:
aws:elasticbeanstalk:application:environment:
TOPIC_ARN: '`{ "Fn::ImportValue" : "NotificationTopicArn" }`'
```
## 映像
您可以使用映射，来存储按命名空间组织的键-值对。映射可以帮助组织您在配置中使用的值，或根据其它值来更改参数值。例如，以下配置根据当前区域来设置账户 ID 参数的值。
**Example [L oadbalancer-accesslogs-newbucket .config](https://github.com/awsdocs/elastic-beanstalk-samples/tree/main/configuration-files/aws-provided/resource-configuration/loadbalancer-accesslogs-newbucket.config) — 映射**
```
Mappings:
Region2ELBAccountId:
us-east-1:
AccountId: "111122223333"
us-west-2:
AccountId: "444455556666"
us-west-1:
AccountId: "123456789012"
eu-west-1:
AccountId: "777788889999"
...
Principal:
AWS:
? "Fn::FindInMap"
:
- Region2ELBAccountId
-
Ref: "AWS::Region"
- AccountId
```
# 函数
您可以在配置文件中使用函数，通过来自其他资源或来自 Elastic Beanstalk 配置选项设置的信息填充资源属性的值。Elastic B CloudFormation eanstalk 支持`Ref`函数 `Fn::GetAtt` (`Fn::Join`、、) 和一个特定于 Elastic BeanStalk 的函数。`Fn::GetOptionSetting`
**Topics**
+ [Ref](#ebextensions-functions-ref)
+ [Fn:: GetAtt](#ebextensions-functions-getatt)
+ [Fn::Join](#ebextensions-functions-join)
+ [Fn:: GetOptionSetting](#ebextensions-functions-getoptionsetting)
## Ref
`Ref`用于检索 AWS 资源的默认字符串表示形式。`Ref` 返回的值取决于资源类型，有时也取决于其他因素。例如，安全组 ([AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html)) 返回安全组的名称或 ID，具体取决于该安全组是在默认的[亚马逊虚拟私有云 (Amazon](https://docs.aws.amazon.com/vpc/latest/userguide/) VPC)、 EC2经典还是自定义 VPC 中。
```
{ "Ref" : "resource name" }
```
**注意**
有关每个资源类型的详细信息（包括 `Ref` 的返回值），请参阅 *CloudFormation 用户指南*中的 [AWS 资源类型参考](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)。
在 [Auto Scaling 生命周期挂钩](environment-resources.md)示例中：
```
Resources:
lifecyclehook:
Type: AWS::AutoScaling::LifecycleHook
Properties:
AutoScalingGroupName: { "Ref" : "AWSEBAutoScalingGroup" }
```
您还可以使用`Ref`检索在同一文件或其他配置文件中其他位置定义的 CloudFormation 参数的值。
## Fn:: GetAtt
`Fn::GetAtt`用于检索 AWS 资源上属性的值。
```
{ "Fn::GetAtt" : [ "resource name", "attribute name"] }
```
在 [Auto Scaling 生命周期挂钩](environment-resources.md)示例中：
```
Resources:
lifecyclehook:
Type: AWS::AutoScaling::LifecycleHook
Properties:
RoleARN: { "Fn::GetAtt" : [ "hookrole", "Arn"] }
```
有关更多信息，请参阅 [Fn:: GetAtt](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html)。
## Fn::Join
使用 `Fn::Join` 可组合带有一个分隔符的字符串。这些字符串可以进行硬编码，也可以使用来自 `Fn::GetAtt` 或 `Ref` 的输出。
```
{ "Fn::Join" : [ "delimiter", [ "string1", "string2" ] ] }
```
有关更多信息，请参阅 [Fn::Join](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html)。
## Fn:: GetOptionSetting
使用 `Fn::GetOptionSetting` 可检索应用于环境的[配置选项](command-options.md)设置的值。
```
"Fn::GetOptionSetting":
Namespace: "namespace"
OptionName: "option name"
DefaultValue: "default value"
```
在[存储私有密钥](https-storingprivatekeys.md)示例中：
```
Resources:
AWSEBAutoScalingGroup:
Metadata:
AWS::CloudFormation::Authentication:
S3Auth:
type: "s3"
buckets: ["elasticbeanstalk-us-west-2-123456789012"]
roleName:
"Fn::GetOptionSetting":
Namespace: "aws:autoscaling:launchconfiguration"
OptionName: "IamInstanceProfile"
DefaultValue: "aws-elasticbeanstalk-ec2-role"
```
# 自定义资源示例
以下是可以用于自定义 Elastic Beanstalk 环境的一系列示例配置文件：
+ [DynamoDB CloudWatch、和 SNS](https://elasticbeanstalk.s3.amazonaws.com/extensions/DynamoDB-with-CloudWatch-Alarms.config)
+ [Elastic Load Balancin CloudWatch](https://elasticbeanstalk.s3.amazonaws.com/extensions/ELB-Alarms.config)
+ [ElastiCache](https://elasticbeanstalk.s3.amazonaws.com/extensions/ElastiCache.config)
+ [RDS 和 CloudWatch](https://elasticbeanstalk.s3.amazonaws.com/extensions/RDS-Alarms.config)
+ [SQS、SNS 和 CloudWatch](https://elasticbeanstalk.s3.amazonaws.com/extensions/SNS.config)
本页的子主题提供了一些在 Elastic Beanstalk 环境中添加和配置自定义资源的扩展示例。
**Topics**
+ [例如： ElastiCache](customize-environment-resources-elasticache.md)
+ [示例：SQS CloudWatch、和 SNS](customize-environment-resources-sqs.md)
+ [示例：DynamoDB CloudWatch、和 SNS](customize-environment-resources-dynamodb.md)
# 例如： ElastiCache
以下示例将亚马逊 ElastiCache 集群添加到 EC2-Classic 和 EC2-VPC（包括默认和自定义[亚马逊虚拟私有云](https://docs.aws.amazon.com/vpc/latest/userguide/)（亚马逊 VPC））平台。有关这些平台以及如何确定 EC2 支持您所在地区和 AWS 账户的平台的更多信息，请参阅[https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html)。然后请参阅本主题中适用于您的平台的部分。
+ [EC2-classic 平台](#customize-environment-resources-elasticache-classic)
+ [EC2-VPC (默认)](#customize-environment-resources-elasticache-defaultvpc)
+ [EC2-VPC (自定义)](#customize-environment-resources-elasticache-targetedvpc)
## EC2-classic 平台
此示例将一个 Amazon ElastiCache 集群添加到一个环境中，其实例已启动到 EC2-Classic 平台。此示例中列出的所有属性是为每种资源类型必须设置的最低要求。你可以在示例中下载示[ElastiCache例](https://elasticbeanstalk.s3.amazonaws.com/extensions/ElastiCache.config)。
**注意**
此示例创建了 AWS 资源，您可能需要为此付费。有关 AWS 定价的更多信息，请参阅[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)。有些服务属于 AWS 免费使用套餐的一部分。如果您是新客户，则可免费试用这些服务。请参阅[https://aws.amazon.com/free/](https://aws.amazon.com/free/)了解更多信息。
要使用此示例，请执行下列操作：
1. 在源包的顶级目录中创建 `[.ebextensions](ebextensions.md)` 目录。
1. 创建两个扩展名为 `.config` 的配置文件并将其放入您的 `.ebextensions` 目录。一个配置文件定义资源，另一个配置文件定义选项。
1. 将应用程序部署到 Elastic Beanstalk。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
创建定义资源的配置文件 (例如，`elasticache.config`)。在此示例中，我们通过指定 ElastiCache 群集资源的名称 (`MyElastiCache`)、声明其类型，然后配置群集的属性来创建群集。 ElastiCache 该示例引用了在此配置文件中创建和定义 ElastiCache 的安全组资源的名称。接下来，我们创建一个 ElastiCache 安全组。我们会定义这个资源的名称、声明它的类型和添加该安全组的描述。最后，我们将安全组的入口规则设置为仅允许来自 ElastiCache 安全组 (`MyCacheSecurityGroup`) 和 Elastic Beanstalk ElastiCache 安全组 () 内部的实例进行访问。`AWSEBSecurityGroup`参数名 `AWSEBSecurityGroup` 是 Elastic Beanstalk 提供的固定资源名称。您必须`AWSEBSecurityGroup`向 ElastiCache 安全组添加入口规则，这样您的 Elastic Beanstalk 应用程序才能连接到集群中的实例。 ElastiCache
```
#This sample requires you to create a separate configuration file that defines the custom option settings for CacheCluster properties.
Resources:
MyElastiCache:
Type: AWS::ElastiCache::CacheCluster
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName : CacheNodeType
DefaultValue: cache.m1.small
NumCacheNodes:
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
Engine:
Fn::GetOptionSetting:
OptionName : Engine
DefaultValue: memcached
CacheSecurityGroupNames:
- Ref: MyCacheSecurityGroup
MyCacheSecurityGroup:
Type: AWS::ElastiCache::SecurityGroup
Properties:
Description: "Lock cache down to webserver access only"
MyCacheSecurityGroupIngress:
Type: AWS::ElastiCache::SecurityGroupIngress
Properties:
CacheSecurityGroupName:
Ref: MyCacheSecurityGroup
EC2SecurityGroupName:
Ref: AWSEBSecurityGroup
```
有关此示例配置文件中使用的资源的更多信息，请参阅以下参考：
+ [AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html)
+ [AWS::ElastiCache::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-security-group.html)
+ [AWS::Elasti缓存：SecurityGroupIngress](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-security-group-ingress.html)
创建名为 `options.config` 的单独配置文件，并定义自定义选项设置。
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType : cache.m1.small
NumCacheNodes : 1
Engine : memcached
```
**这些行告诉 Elastic Beanstalk **CacheNodeType从配置文件（我们的示例中**CacheNodeType为 NumCacheNodes options.config）中获取、**和引擎属性的值， NumCacheNodes该**文件包含一个 option\$1settings 部分，其中有一个 aws: elasticbeanstalk: customoption 部分，其中包含包含要使用的实际值的名称-值对。**在以上示例中，这意味着 cache.m1.small、1 和 memcached 将用于这些值。有关 `Fn::GetOptionSetting` 的更多信息，请参阅 [函数](ebextensions-functions.md)。
## EC2-VPC (默认)
此示例将 Amazon ElastiCache 集群添加到已启动到 EC2-VPC 平台的实例的环境中。具体来说，此部分中的信息适用于 EC2 在默认 VPC 中启动实例的情景。此示例中的所有属性是为每种资源类型必须设置的最低要求。有关默认的更多信息 VPCs，请参阅[您的默认 VPC 和子网](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html)。
**注意**
此示例创建了 AWS 资源，您可能需要为此付费。有关 AWS 定价的更多信息，请参阅[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)。有些服务属于 AWS 免费使用套餐的一部分。如果您是新客户，则可免费试用这些服务。请参阅[https://aws.amazon.com/free/](https://aws.amazon.com/free/)了解更多信息。
要使用此示例，请执行下列操作：
1. 在源包的顶级目录中创建 `[.ebextensions](ebextensions.md)` 目录。
1. 创建两个扩展名为 `.config` 的配置文件并将其放入您的 `.ebextensions` 目录。一个配置文件定义资源，另一个配置文件定义选项。
1. 将应用程序部署到 Elastic Beanstalk。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
现在将资源配置文件命名为 `elasticache.config`。要创建 ElastiCache 群集，此示例指定 ElastiCache 群集资源的名称 (`MyElastiCache`)，声明其类型，然后配置群集的属性。该示例引用在此配置文件中创建和定义的安全组资源的 ID。
接下来，我们会创建 EC2 安全组。我们定义此资源的名称，声明其类型，添加描述，并为安全组设置传入规则以便仅允许从 Elastic Beanstalk 安全组 (`AWSEBSecurityGroup`) 中的实例进行访问。（参数名称是 Elastic Beanstalk 提供的固定资源名称。`AWSEBSecurityGroup` 您必须`AWSEBSecurityGroup`向 ElastiCache 安全组添加入口规则，这样您的 Elastic Beanstalk 应用程序才能连接到集群中的实例。） ElastiCache
EC2 安全组的传入规则还定义缓存节点可以用于接受连接的 IP 协议和端口号。对于 Redis，默认端口号是 `6379`。
```
#This sample requires you to create a separate configuration file that defines the custom option settings for CacheCluster properties.
Resources:
MyCacheSecurityGroup:
Type: "AWS::EC2::SecurityGroup"
Properties:
GroupDescription: "Lock cache down to webserver access only"
SecurityGroupIngress :
- IpProtocol : "tcp"
FromPort :
Fn::GetOptionSetting:
OptionName : "CachePort"
DefaultValue: "6379"
ToPort :
Fn::GetOptionSetting:
OptionName : "CachePort"
DefaultValue: "6379"
SourceSecurityGroupName:
Ref: "AWSEBSecurityGroup"
MyElastiCache:
Type: "AWS::ElastiCache::CacheCluster"
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName : "CacheNodeType"
DefaultValue : "cache.t2.micro"
NumCacheNodes:
Fn::GetOptionSetting:
OptionName : "NumCacheNodes"
DefaultValue : "1"
Engine:
Fn::GetOptionSetting:
OptionName : "Engine"
DefaultValue : "redis"
VpcSecurityGroupIds:
-
Fn::GetAtt:
- MyCacheSecurityGroup
- GroupId
Outputs:
ElastiCache:
Description : "ID of ElastiCache Cache Cluster with Redis Engine"
Value :
Ref : "MyElastiCache"
```
有关此示例配置文件中使用的资源的更多信息，请参阅以下参考：
+ [AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html)
+ [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html)
接下来，将选项配置文件命名为 `options.config`，然后定义自定义选项设置。
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType : cache.t2.micro
NumCacheNodes : 1
Engine : redis
CachePort : 6379
```
这些行告知 Elastic Beanstalk 从配置文件（在我们的示例中为 `options.config`）中的 `CacheNodeType`、`NumCacheNodes`、`Engine` 和 `CachePort` 值获取 `CacheNodeType`、`NumCacheNodes`、`Engine` 和 `CachePort` 属性的值。该文件包含 `aws:elasticbeanstalk:customoption` 节 (在 `option_settings` 下)，其中含有要使用的实际值的名称/值对。在前面的示例中，会对这些值使用 `cache.t2.micro`、`1`、`redis` 和 `6379`。有关 `Fn::GetOptionSetting` 的更多信息，请参阅 [函数](ebextensions-functions.md)。
## EC2-VPC (自定义)
如果您在 EC2-VPC 平台上创建自定义 VPC 并将其指定为 EC2 在其中启动实例的 VPC，则向您的环境中添加 Amazon ElastiCache 集群的过程与默认 VPC 的过程不同。主要区别在于您必须为 ElastiCache 集群创建子网组。此示例中的所有属性是为每种资源类型必须设置的最低要求。
**注意**
此示例创建了 AWS 资源，您可能需要为此付费。有关 AWS 定价的更多信息，请参阅[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)。有些服务属于 AWS 免费使用套餐的一部分。如果您是新客户，则可免费试用这些服务。请参阅[https://aws.amazon.com/free/](https://aws.amazon.com/free/)了解更多信息。
要使用此示例，请执行下列操作：
1. 在源包的顶级目录中创建 `[.ebextensions](ebextensions.md)` 目录。
1. 创建两个扩展名为 `.config` 的配置文件并将其放入您的 `.ebextensions` 目录。一个配置文件定义资源，另一个配置文件定义选项。
1. 将应用程序部署到 Elastic Beanstalk。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
现在将资源配置文件命名为 `elasticache.config`。要创建 ElastiCache 群集，此示例指定 ElastiCache 群集资源的名称 (`MyElastiCache`)，声明其类型，然后配置群集的属性。示例中的属性引用了 ElastiCache 集群子网组的名称以及我们在此配置文件中创建和定义的安全组资源的 ID。
接下来，我们会创建 EC2 安全组。我们定义此资源的名称，声明其类型，添加描述和 VPC ID，并为安全组设置传入规则以便仅允许从 Elastic Beanstalk 安全组 (`AWSEBSecurityGroup`) 中的实例进行访问。（参数名称是 Elastic Beanstalk 提供的固定资源名称。`AWSEBSecurityGroup` 您必须`AWSEBSecurityGroup`向 ElastiCache 安全组添加入口规则，这样您的 Elastic Beanstalk 应用程序才能连接到集群中的实例。） ElastiCache
EC2 安全组的传入规则还定义缓存节点可以用于接受连接的 IP 协议和端口号。对于 Redis，默认端口号是 `6379`。最后，此示例为 ElastiCache 群集创建了一个子网组。我们定义此资源的名称，声明其类型，并在子网组中添加子网的描述和 ID。
**注意**
我们建议您为 ElastiCache 集群使用私有子网。有关具有私有子网的 VPC 的更多信息，请参阅 [https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Scenario2.html](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Scenario2.html)。
```
#This sample requires you to create a separate configuration file that defines the custom option settings for CacheCluster properties.
Resources:
MyElastiCache:
Type: "AWS::ElastiCache::CacheCluster"
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName : "CacheNodeType"
DefaultValue : "cache.t2.micro"
NumCacheNodes:
Fn::GetOptionSetting:
OptionName : "NumCacheNodes"
DefaultValue : "1"
Engine:
Fn::GetOptionSetting:
OptionName : "Engine"
DefaultValue : "redis"
CacheSubnetGroupName:
Ref: "MyCacheSubnets"
VpcSecurityGroupIds:
- Ref: "MyCacheSecurityGroup"
MyCacheSecurityGroup:
Type: "AWS::EC2::SecurityGroup"
Properties:
GroupDescription: "Lock cache down to webserver access only"
VpcId:
Fn::GetOptionSetting:
OptionName : "VpcId"
SecurityGroupIngress :
- IpProtocol : "tcp"
FromPort :
Fn::GetOptionSetting:
OptionName : "CachePort"
DefaultValue: "6379"
ToPort :
Fn::GetOptionSetting:
OptionName : "CachePort"
DefaultValue: "6379"
SourceSecurityGroupId:
Ref: "AWSEBSecurityGroup"
MyCacheSubnets:
Type: "AWS::ElastiCache::SubnetGroup"
Properties:
Description: "Subnets for ElastiCache"
SubnetIds:
Fn::GetOptionSetting:
OptionName : "CacheSubnets"
Outputs:
ElastiCache:
Description : "ID of ElastiCache Cache Cluster with Redis Engine"
Value :
Ref : "MyElastiCache"
```
有关此示例配置文件中使用的资源的更多信息，请参阅以下参考：
+ [AWS::ElastiCache::CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html)
+ [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html)
+ [AWS::ElastiCache::SubnetGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-subnetgroup.html)
接下来，将选项配置文件命名为 `options.config`，然后定义自定义选项设置。
**注意**
在以下示例中，将示例 `CacheSubnets` 和 `VpcId` 值替换为自己的子网和 VPC。
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType : cache.t2.micro
NumCacheNodes : 1
Engine : redis
CachePort : 6379
CacheSubnets:
- subnet-1a1a1a1a
- subnet-2b2b2b2b
- subnet-3c3c3c3c
VpcId: vpc-4d4d4d4d
```
这些行告知 Elastic Beanstalk 从配置文件（在我们的示例中为 `options.config`）中的 `CacheNodeType`、`NumCacheNodes`、`Engine`、`CachePort`、`CacheSubnets` 和 `VpcId` 值获取 `CacheNodeType`、`NumCacheNodes`、`Engine`、`CachePort`、`CacheSubnets` 和 `VpcId` 属性的值。该文件包含 `aws:elasticbeanstalk:customoption` 节 (在 `option_settings` 下)，其中含有具有示例值的名称/值对。在以上示例中，对这些值使用 `cache.t2.micro`、`1`、`redis`、`6379`、`subnet-1a1a1a1a`、`subnet-2b2b2b2b`、`subnet-3c3c3c3c` 和 `vpc-4d4d4d4d`。有关 `Fn::GetOptionSetting` 的更多信息，请参阅 [函数](ebextensions-functions.md)。
# 示例：SQS CloudWatch、和 SNS
此示例给环境添加 Amazon SQS 队列以及有关队列深度的警报。此示例中显示的属性是必须具备的最低程度的属性，必须为每个资源进行设置。您可以在 [SQS、SNS 和](https://elasticbeanstalk.s3.amazonaws.com/extensions/SNS.config)上下载该示例。 CloudWatch
**注意**
此示例创建了 AWS 资源，您可能需要为此付费。有关 AWS 定价的更多信息，请参阅[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)。有些服务属于 AWS 免费使用套餐的一部分。如果您是新客户，则可免费试用这些服务。请参阅[https://aws.amazon.com/free/](https://aws.amazon.com/free/)了解更多信息。
要使用此示例，请执行下列操作：
1. 在源包的顶级目录中创建 `[.ebextensions](ebextensions.md)` 目录。
1. 创建两个扩展名为 `.config` 的配置文件并将其放入您的 `.ebextensions` 目录。一个配置文件定义资源，另一个配置文件定义选项。
1. 将应用程序部署到 Elastic Beanstalk。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
创建定义资源的配置文件 (例如，sqs.config)。在此示例中，我们创建 SQS 队列并定义 `VisbilityTimeout` 资源中的 `MySQSQueue` 属性。下一步，我们创建 SNS `Topic`，并指定电子邮件在警报激发时发送到 `someone@example.com`。最后，如果队列超过 10 条消息，我们会创建 CloudWatch警报。在 `Dimensions` 属性中，我们指定维度的名称以及代表维度度量的值。我们使用 `Fn::GetAtt` 从 `QueueName` 中返回 `MySQSQueue` 的值。
```
#This sample requires you to create a separate configuration file to define the custom options for the SNS topic and SQS queue.
Resources:
MySQSQueue:
Type: AWS::SQS::Queue
Properties:
VisibilityTimeout:
Fn::GetOptionSetting:
OptionName: VisibilityTimeout
DefaultValue: 30
AlarmTopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Endpoint:
Fn::GetOptionSetting:
OptionName: AlarmEmail
DefaultValue: "nobody@amazon.com"
Protocol: email
QueueDepthAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmDescription: "Alarm if queue depth grows beyond 10 messages"
Namespace: "AWS/SQS"
MetricName: ApproximateNumberOfMessagesVisible
Dimensions:
- Name: QueueName
Value : { "Fn::GetAtt" : [ "MySQSQueue", "QueueName"] }
Statistic: Sum
Period: 300
EvaluationPeriods: 1
Threshold: 10
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- Ref: AlarmTopic
InsufficientDataActions:
- Ref: AlarmTopic
Outputs :
QueueURL:
Description : "URL of newly created SQS Queue"
Value : { Ref : "MySQSQueue" }
QueueARN :
Description : "ARN of newly created SQS Queue"
Value : { "Fn::GetAtt" : [ "MySQSQueue", "Arn"]}
QueueName :
Description : "Name newly created SQS Queue"
Value : { "Fn::GetAtt" : [ "MySQSQueue", "QueueName"]}
```
有关此示例配置文件中使用的资源的更多信息，请参阅以下参考：
+ [AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sqs-queues.html)
+ [AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html)
+ [AWS::CloudWatch::Alarm](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html)
创建名为 `options.config` 的单独配置文件，并定义自定义选项设置。
```
option_settings:
"aws:elasticbeanstalk:customoption":
VisibilityTimeout : 30
AlarmEmail : "nobody@example.com"
```
**这些行告诉 Elastic Beanstalk **VisibilityTimeout 从配置文件（我们的示例中**VisibilityTimeout 为 options.config）中获取和**订阅端点属性的值，该**文件包含一个 option\$1settings 部分，其中有一个 aws: elasticbeanstalk: customoption 部分，其中包含包含要使用的实际值的名称-值对。**在以上示例中，这意味着 30 和“nobody@amazon.com”将用于这些值。有关 `Fn::GetOptionSetting` 的更多信息，请参阅 [函数](ebextensions-functions.md)。
# 示例：DynamoDB CloudWatch、和 SNS
此配置文件将 DynamoDB 表设置为使用适用于 PHP 的 SDK 2 的基于 PHP 的应用程序的 AWS 会话处理程序。要使用此示例，您必须拥有 IAM 实例配置文件，该文件会添加到环境中的实例，并用来访问 DynamoDB 表。
您可以在 [DynamoDB 会话支持示例](https://elasticbeanstalk.s3.amazonaws.com/extensions/PHP-DynamoDB-Session-Support.zip)中下载该示例，我们在本步骤会用到这个示例。此示例包含以下文件：
+ 示例应用程序 `index.php`
+ 一个配置文件`dynamodb.config`，用于创建和配置 DynamoDB 表 AWS 和其他资源，并在 Elastic Beanstalk 环境中托管应用程序的 EC2 实例上安装软件
+ 配置文件 `options.config`，该文件会使用此特定安装的特定设置覆盖 `dynamodb.config` 中的默认设置
**`index.php`**
```
$region));
$handler = $dynamodb->registerSessionHandler(array('table_name' => $tableName, 'hash_key' => 'username'));
// Grab the instance ID so we can display the EC2 instance that services the request
$instanceId = file_get_contents("http://169.254.169.254/latest/meta-data/instance-id");
?>
Elastic Beanstalk PHP Sessions Sample
This sample application shows the integration of the Elastic Beanstalk PHP
container and the session support for DynamoDB from the AWS SDK for PHP 2.
Using DynamoDB session support, the application can be scaled out across
multiple web servers. For more details, see the
PHP Developer Center.
```
**`.ebextensions/dynamodb.config`**
```
Resources:
SessionTable:
Type: AWS::DynamoDB::Table
Properties:
KeySchema:
HashKeyElement:
AttributeName:
Fn::GetOptionSetting:
OptionName : SessionHashKeyName
DefaultValue: "username"
AttributeType:
Fn::GetOptionSetting:
OptionName : SessionHashKeyType
DefaultValue: "S"
ProvisionedThroughput:
ReadCapacityUnits:
Fn::GetOptionSetting:
OptionName : SessionReadCapacityUnits
DefaultValue: 1
WriteCapacityUnits:
Fn::GetOptionSetting:
OptionName : SessionWriteCapacityUnits
DefaultValue: 1
SessionWriteCapacityUnitsLimit:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmDescription: { "Fn::Join" : ["", [{ "Ref" : "AWSEBEnvironmentName" }, " write capacity limit on the session table." ]]}
Namespace: "AWS/DynamoDB"
MetricName: ConsumedWriteCapacityUnits
Dimensions:
- Name: TableName
Value: { "Ref" : "SessionTable" }
Statistic: Sum
Period: 300
EvaluationPeriods: 12
Threshold:
Fn::GetOptionSetting:
OptionName : SessionWriteCapacityUnitsAlarmThreshold
DefaultValue: 240
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- Ref: SessionAlarmTopic
InsufficientDataActions:
- Ref: SessionAlarmTopic
SessionReadCapacityUnitsLimit:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmDescription: { "Fn::Join" : ["", [{ "Ref" : "AWSEBEnvironmentName" }, " read capacity limit on the session table." ]]}
Namespace: "AWS/DynamoDB"
MetricName: ConsumedReadCapacityUnits
Dimensions:
- Name: TableName
Value: { "Ref" : "SessionTable" }
Statistic: Sum
Period: 300
EvaluationPeriods: 12
Threshold:
Fn::GetOptionSetting:
OptionName : SessionReadCapacityUnitsAlarmThreshold
DefaultValue: 240
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- Ref: SessionAlarmTopic
InsufficientDataActions:
- Ref: SessionAlarmTopic
SessionThrottledRequestsAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmDescription: { "Fn::Join" : ["", [{ "Ref" : "AWSEBEnvironmentName" }, ": requests are being throttled." ]]}
Namespace: AWS/DynamoDB
MetricName: ThrottledRequests
Dimensions:
- Name: TableName
Value: { "Ref" : "SessionTable" }
Statistic: Sum
Period: 300
EvaluationPeriods: 1
Threshold:
Fn::GetOptionSetting:
OptionName: SessionThrottledRequestsThreshold
DefaultValue: 1
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- Ref: SessionAlarmTopic
InsufficientDataActions:
- Ref: SessionAlarmTopic
SessionAlarmTopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Endpoint:
Fn::GetOptionSetting:
OptionName: SessionAlarmEmail
DefaultValue: "nobody@amazon.com"
Protocol: email
files:
"/var/app/sessiontable":
mode: "000444"
content: |
`{"Ref" : "SessionTable"}`
`{"Ref" : "AWS::Region"}`
"/var/app/composer.json":
mode: "000744"
content:
{
"require": {
"aws/aws-sdk-php": "*"
}
}
container_commands:
"1-install-composer":
command: "cd /var/app; curl -s http://getcomposer.org/installer | php"
"2-install-dependencies":
command: "cd /var/app; php composer.phar install"
"3-cleanup-composer":
command: "rm -Rf /var/app/composer.*"
```
在示例配置文件中，我们首先创建 DynamoDB 表，并配置该表的主密钥结构和容量单位，以便分配足够的资源提供所要求的吞吐量。接下来，我们为`WriteCapacity`和创建 CloudWatch 警报`ReadCapacity`。我们会创建 SNS 主题，该主题会在警报阈值被突破时将电子邮件发送到“nobody@amazon.com”。
在我们为环境创建和配置 AWS 资源之后，我们需要自定义 EC2 实例。我们使用`files`密钥将 DynamoDB 表的详细信息传递给我们环境中的 EC2 实例，并在文件中`composer.json`为适用于 AWS PHP 的 SDK 2 添加一个 “要求”。最后，我们会运行容器命令安装编辑器和必需的依赖项，然后删除安装程序。
**`.ebextensions/options.config`**
```
option_settings:
"aws:elasticbeanstalk:customoption":
SessionHashKeyName : username
SessionHashKeyType : S
SessionReadCapacityUnits : 1
SessionReadCapacityUnitsAlarmThreshold : 240
SessionWriteCapacityUnits : 1
SessionWriteCapacityUnitsAlarmThreshold : 240
SessionThrottledRequestsThreshold : 1
SessionAlarmEmail : me@example.com
```
将该 SessionAlarmEmail 值替换为您想要发送警报通知的电子邮件。`options.config` 文件包含 `dynamodb.config` 中用于定义的部分变量的值。例如，`dynamodb.config` 包含以下行：
```
Subscription:
- Endpoint:
Fn::GetOptionSetting:
OptionName: SessionAlarmEmail
DefaultValue: "nobody@amazon.com"
```
****这些行告诉 Elastic Beanstalk **SessionAlarmEmail**从配置`options.config`文件（在我们的示例应用程序中）中的值中获取 Endpoint 属性的值，该文件包含一个 option\$1settings 部分，其中有一个 aws: elasticbeanstalk: customoption 部分，其中包含包含要使用的实际值的名称-值对。****在上面的示例中，这意味着**SessionAlarmEmail**将分配该值`nobody@amazon.com`。
有关本示例中使用的 CloudFormation 资源的更多信息，请参阅以下参考资料：
+ [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html)
+ [AWS::CloudWatch::Alarm](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html)
+ [AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html)
# 使用 Elastic Beanstalk 保存的配置
您可将环境的配置作为对象保存在 Amazon Simple Storage Service (Amazon S3) 中，以便在创建环境时应用于其他环境，或应用于正在运行的环境。*保存的配置* 是 YAML 格式的模板，用于定义环境的[平台版本](concepts.platforms.md)、[层](concepts.md#concepts-tier)、[配置选项](command-options.md)设置和标记。
您可以在创建保存的配置和编辑现有保存的配置的标签时向其应用标签。应用到保存的配置的标签与使用 `Tags:` 键在保存的配置中指定的标签无关。当您将保存的配置应用到环境时，后者将应用到环境。有关更多信息，请参阅 [标记保存的配置](environment-configuration-savedconfig-tagging.md)。
**注意**
您可以使用多种方法创建保存的配置并将其应用于您的 Elastic Beanstalk 环境。其中包括 Elastic Beanstalk 控制台、EB CLI 和 AWS CLI。
有关创建和应用保存的配置的替代方法示例，请参阅下列主题：
[在创建环境之前设置配置选项](environment-configuration-methods-before.md)
[在环境创建期间设置配置选项](environment-configuration-methods-during.md)
[在环境创建后设置配置选项](environment-configuration-methods-after.md)
在 Elastic Beanstalk 管理控制台中，从环境的当前状态创建保存的配置。
**保存环境的配置**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 选择 **Actions**（操作），然后选择 **Save configuration**（保存配置）。
1. 使用屏幕上的表单命名已保存的配置。（可选）提供简要说明，并添加标签键和值。
1. 选择**保存**。
![\[Elastic Beanstalk 控制台上的“Save Configuration (保存配置)”页面\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/images/environment-cfg-saveconfiguration-dialog.png)
保存的配置包括已应用于具有控制台的环境或任何其他使用 Elastic Beanstalk API 的客户端的任何设置。您可以稍后将保存的配置应用于您的环境以将它还原为上一个状态，也可以在[创建环境](environments-create-wizard.md)期间将保存的配置应用于新环境。
您可以使用 EB CLI [**eb config**](eb3-config.md) 命令下载配置，如以下示例所示。 *NAME*是您保存的配置的名称。
```
eb config get NAME
```
**在创建环境期间应用保存的配置（Elastic Beanstalk 控制台）**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Applications**（应用程序），然后从列表中选择应用程序的名称。
1. 在导航窗格中，找到应用程序的名称，然后选择 **Saved configurations**（已保存的配置）。
1. 选择要应用的已保存的配置，然后选择 **Launch environment**（启动环境）。
1. 继续执行向导以创建环境。
保存的配置不包括已与应用程序源代码中的[配置文件](ebextensions.md)一起应用的设置。如果在配置文件和保存的配置中应用相同的设置，则保存的配置中的设置优先。同样，Elastic Beanstalk 控制台中指定的选项将覆盖保存的配置中的选项。有关更多信息，请参阅 [优先级](command-options.md#configuration-options-precedence)。
保存的配置存储在 Elastic Beanstalk S3 存储桶中按照应用程序命名的文件夹中。例如，对于账号 123456789012，us-west-2 区域中名为 `my-app` 的应用程序的配置位于 `s3://elasticbeanstalk-us-west-2-123456789012/resources/templates/my-app/`。
通过在文本编辑器中打开保存的配置，可以查看其内容。以下示例配置显示使用 Elastic Beanstalk 管理控制台启动的 Web 服务器环境的配置。
```
EnvironmentConfigurationMetadata:
Description: Saved configuration from a multicontainer Docker environment created with the Elastic Beanstalk Management Console
DateCreated: '1520633151000'
DateModified: '1520633151000'
Platform:
PlatformArn: arn:aws:elasticbeanstalk:us-east-2::platform/Java 8 running on 64bit Amazon Linux/2.5.0
OptionSettings:
aws:elasticbeanstalk:command:
BatchSize: '30'
BatchSizeType: Percentage
aws:elasticbeanstalk:sns:topics:
Notification Endpoint: me@example.com
aws:elb:policies:
ConnectionDrainingEnabled: true
ConnectionDrainingTimeout: '20'
aws:elb:loadbalancer:
CrossZone: true
aws:elasticbeanstalk:environment:
ServiceRole: aws-elasticbeanstalk-service-role
aws:elasticbeanstalk:application:
Application Healthcheck URL: /
aws:elasticbeanstalk:healthreporting:system:
SystemType: enhanced
aws:autoscaling:launchconfiguration:
IamInstanceProfile: aws-elasticbeanstalk-ec2-role
InstanceType: t2.micro
EC2KeyName: workstation-uswest2
aws:autoscaling:updatepolicy:rollingupdate:
RollingUpdateType: Health
RollingUpdateEnabled: true
EnvironmentTier:
Type: Standard
Name: WebServer
AWSConfigurationTemplateVersion: 1.1.0.0
Tags:
Cost Center: WebApp Dev
```
您可修改保存的配置的内容并将其保存在 Amazon S3 中的同一位置。存储在正确位置的任何格式正确的保存的配置均可使用 Elastic Beanstalk 管理控制台应用于环境。
支持以下键。
+ **AWSConfigurationTemplateVersion**（必填）-配置模板版本 (1.1.0.0)。
```
AWSConfigurationTemplateVersion: 1.1.0.0
```
+ **Platform** – 环境的平台版本的 Amazon 资源名称 (ARN)。您可以按 ARN 或解决方案堆栈名称指定平台。
```
Platform:
PlatformArn: arn:aws:elasticbeanstalk:us-east-2::platform/Java 8 running on 64bit Amazon Linux/2.5.0
```
+ **SolutionStack**— 用于创建环境的[解决方案堆栈](concepts.platforms.md)的全名。
```
SolutionStack: 64bit Amazon Linux 2017.03 v2.5.0 running Java 8
```
+ **OptionSettings**— 要应用于环境的[配置选项](command-options.md)设置。例如，下面的条目将实例类型设为 t2.micro。
```
OptionSettings:
aws:autoscaling:launchconfiguration:
InstanceType: t2.micro
```
+ **Tags** - 多达 47 个标签，应用于在环境中创建的资源。
```
Tags:
Cost Center: WebApp Dev
```
+ **EnvironmentTier**— 要创建的环境类型。对于 Web 服务器环境，您可不包含此部分 (Web 服务器为默认值)。对于工作线程环境，请使用以下设置。
```
EnvironmentTier:
Name: Worker
Type: SQS/HTTP
```
**注意**
您可以使用多种方法创建保存的配置并将其应用于您的 Elastic Beanstalk 环境。其中包括 Elastic Beanstalk 控制台、EB CLI 和 AWS CLI。
有关创建和应用保存的配置的替代方法示例，请参阅下列主题：
[在创建环境之前设置配置选项](environment-configuration-methods-before.md)
[在环境创建期间设置配置选项](environment-configuration-methods-during.md)
[在环境创建后设置配置选项](environment-configuration-methods-after.md)
# 标记保存的配置
您可以将标签应用于 AWS Elastic Beanstalk 保存的配置。标签是与资源关联的键值对。 AWS 有关 Elastic Beanstalk 资源标记、使用案例、标签键和值约束以及支持的资源类型的信息，请参阅[标记 Elastic Beanstalk 应用程序资源](applications-tagging-resources.md)。
您可以在创建保存的配置时指定标签。在现有保存的配置中，您可以添加或删除标签，以及更新现有标签的值。您最多可以为每个保存的配置添加 50 个标签。
## 在创建保存的配置期间添加标签
在使用 Elastic Beanstalk 控制台[保存配置](environment-configuration-savedconfig.md)时，您可以在 **Save Configuration (保存配置)** 页面上指定标签键和值。
如果使用 EB CLI 保存配置，则可以使用 **[eb config](eb3-config.md)** 的 `--tags` 选项添加标签。
```
~/workspace/my-app$ eb config --tags mytag1=value1,mytag2=value2
```
对于 AWS CLI 或其他基于 API 的客户端，使用命令中的`--tags`参数添加标签。**[create-configuration-template](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/create-configuration-template.html)**
```
$ aws elasticbeanstalk create-configuration-template \
--tags Key=mytag1,Value=value1 Key=mytag2,Value=value2 \
--application-name my-app --template-name my-template --solution-stack-name solution-stack
```
## 管理现有保存的配置的标签
可以在现有的 Elastic Beanstalk 保存的配置中添加、更新和删除标签。
**使用 Elastic Beanstalk 控制台管理保存的配置的标签**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Applications**（应用程序），然后从列表中选择应用程序的名称。
1. 在导航窗格中，找到应用程序的名称，然后选择 **Saved configurations**（已保存的配置）。
1. 选择要管理的已保存配置。
1. 选择 **Actions (操作)**，然后选择 **Manage tags (管理标签)**。
1. 使用屏幕上的表单添加、更新或删除标签。
1. 要保存更改，请选择页面底部的 **Apply**（应用）。
如果使用 EB CLI 更新保存的配置，则可使用 **[eb tags](eb3-tags.md)** 来添加、更新、删除或列出标签。
例如，以下命令会列出保存的配置中的标签。
```
~/workspace/my-app$ eb tags --list --resource "arn:aws:elasticbeanstalk:us-east-2:my-account-id:configurationtemplate/my-app/my-template"
```
以下命令会更新标签 `mytag1` 并删除标签 `mytag2`。
```
~/workspace/my-app$ eb tags --update mytag1=newvalue --delete mytag2 \
--resource "arn:aws:elasticbeanstalk:us-east-2:my-account-id:configurationtemplate/my-app/my-template"
```
有关选项和更多示例的完整列表，请参阅 `eb tags`。
对于 AWS CLI 或其他基于 API 的客户端，使用**[list-tags-for-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/list-tags-for-resource.html)**命令列出已保存配置的标签。
```
$ aws elasticbeanstalk list-tags-for-resource --resource-arn "arn:aws:elasticbeanstalk:us-east-2:my-account-id:configurationtemplate/my-app/my-template"
```
使用 **[update-tags-for-resource](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/update-tags-for-resource.html)** 命令可在保存的配置中添加、更新或删除标签。
```
$ aws elasticbeanstalk update-tags-for-resource \
--tags-to-add Key=mytag1,Value=newvalue --tags-to-remove mytag2 \
--resource-arn "arn:aws:elasticbeanstalk:us-east-2:my-account-id:configurationtemplate/my-app/my-template"
```
在 `--tags-to-add` 的 **update-tags-for-resource** 参数中指定要添加的标签和要更新的标签。添加了一个不存在的标签，更新了现有标签的值。
**注意**
要将某些 EB CLI 和 AWS CLI 命令与 Elastic Beanstalk 保存的配置一起使用，您需要保存的配置的 ARN。要构造 ARN，首先请使用以下命令检索保存的配置的名称。
```
$ aws elasticbeanstalk describe-applications --application-names my-app
```
在命令输出中查找 `ConfigurationTemplates` 键。此元素显示保存的配置的名称。在本页面上提到的命令中指定 `my-template` 的地方使用此名称。
# 环境清单 (`env.yaml`)
您可以在应用程序源包的根目录中包含一个 YAML 格式的环境清单，以配置在创建环境时使用的环境名称、解决方案堆栈和[环境链接](environment-cfg-links.md)。
此文件格式包含对环境组的支持。要使用组，请在清单中指定环境名称并在末尾添加一个 \$1 号。创建或更新环境时，请使用 `--group-name`（AWS CLI）或 `--env-group-suffix`（EB CLI）指定组名称。有关组的更多信息，请参阅[创建和更新 Elastic Beanstalk 环境组](environment-mgmt-compose.md)。
以下示例清单定义一个 Web 服务器环境，并包含一个指向它依赖的工作线程环境组件的链接。此清单使用组以允许使用相同的源包创建多个环境：
**`~/myapp/frontend/env.yaml`**
```
AWSConfigurationTemplateVersion: 1.1.0.0
SolutionStack: 64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)
OptionSettings:
aws:elasticbeanstalk:command:
BatchSize: '30'
BatchSizeType: Percentage
aws:elasticbeanstalk:sns:topics:
Notification Endpoint: me@example.com
aws:elb:policies:
ConnectionDrainingEnabled: true
ConnectionDrainingTimeout: '20'
aws:elb:loadbalancer:
CrossZone: true
aws:elasticbeanstalk:environment:
ServiceRole: aws-elasticbeanstalk-service-role
aws:elasticbeanstalk:application:
Application Healthcheck URL: /
aws:elasticbeanstalk:healthreporting:system:
SystemType: enhanced
aws:autoscaling:launchconfiguration:
IamInstanceProfile: aws-elasticbeanstalk-ec2-role
InstanceType: t2.micro
EC2KeyName: workstation-uswest2
aws:autoscaling:updatepolicy:rollingupdate:
RollingUpdateType: Health
RollingUpdateEnabled: true
Tags:
Cost Center: WebApp Dev
CName: front-A08G28LG+
EnvironmentName: front+
EnvironmentLinks:
"WORKERQUEUE" : "worker+"
```
支持以下键。
+ **AWSConfigurationTemplateVersion**（必填）-配置模板版本 (1.1.0.0)。
```
AWSConfigurationTemplateVersion: 1.1.0.0
```
+ **Platform** – 环境的平台版本的 Amazon 资源名称 (ARN)。您可以按 ARN 或解决方案堆栈名称指定平台。
```
Platform:
PlatformArn: arn:aws:elasticbeanstalk:us-east-2::platform/Java 8 running on 64bit Amazon Linux/2.5.0
```
+ **SolutionStack**— 用于创建环境的[解决方案堆栈](concepts.platforms.md)的全名。
```
SolutionStack: 64bit Amazon Linux 2017.03 v2.5.0 running Java 8
```
+ **OptionSettings**— 要应用于环境的[配置选项](command-options.md)设置。例如，下面的条目将实例类型设为 t2.micro。
```
OptionSettings:
aws:autoscaling:launchconfiguration:
InstanceType: t2.micro
```
+ **Tags** - 多达 47 个标签，应用于在环境中创建的资源。
```
Tags:
Cost Center: WebApp Dev
```
+ **EnvironmentTier**— 要创建的环境类型。对于 Web 服务器环境，您可不包含此部分 (Web 服务器为默认值)。对于工作线程环境，请使用以下设置。
```
EnvironmentTier:
Name: Worker
Type: SQS/HTTP
```
+ **CName**— 环境的别名记录。在名称末尾包含一个 \$1 号以启用组。
```
CName: front-A08G28LG+
```
+ **EnvironmentName**-要创建的环境的名称。在名称末尾包含一个 \$1 号以启用组。
```
EnvironmentName: front+
```
如果启用组，则在创建环境时必须指定组名称。Elastic Beanstalk 使用连字符将组名称追加到环境名称。例如，对于环境名称 `front+` 和组名称 `dev`，Elastic Beanstalk 会创建名为 `front-dev` 的环境。
+ **EnvironmentLinks**— 变量名和依赖关系环境名称的映射。下面的示例使 `worker+` 环境成为依赖项并告知 Elastic Beanstalk 将链接信息保存到名为 `WORKERQUEUE` 的变量。
```
EnvironmentLinks:
"WORKERQUEUE" : "worker+"
```
链接变量的值因被链接环境的类型而异。对于 Web 服务器环境，链接为环境的别名记录。对于工作线程环境，链接为环境的 Amazon Simple Queue Service (Amazon SQS) 队列的名称。
**CName**、**EnvironmentName**和**EnvironmentLinks**密钥可用于创建[环境组](environment-mgmt-compose.md)和[指向其他环境的链接](environment-cfg-links.md)。当前，使用 EB CLI AWS CLI 或 SDK 时支持这些功能。
# 在 Elastic Beanstalk 环境中使用自定义亚马逊机器映像（AMI）
本节介绍何时考虑使用自定义 AMI，并提供在您的环境中配置和管理自定义 AMI 的过程。创建 AWS Elastic Beanstalk 环境时，您可以指定要使用的亚马逊系统映像 (AMI)，而不是平台版本中包含的标准 Elastic Beanstalk AMI。如果您需要安装大量未包含在标准中的软件，则自定义 AMI 可以缩短在您的环境中启动实例时的配置时间 AMIs。
使用[配置文件](ebextensions.md)能够有效、快速且一致地自定义您的环境。但在环境创建和更新期间应用配置可能需要很长时间。如果您需要在配置文件中进行大量的服务器配置，可以制作一份包含所需软件和配置的自定义 AMI，以缩短配置耗时。
此外，您还可以借助自定义 AMI 对底层组件 (如 Linux 内核) 进行更改，这在配置文件中很难实现或需要很长时间才能完成。要创建自定义 AMI，请在 Amazon EC2 中启动 Elastic Beanstalk 平台 AMI，根据需要自定义软件和配置，然后停止该实例并据之保存一个 AMI。
## 创建自定义 AMI
您可以使用 [EC2 Image Builder](https://aws.amazon.com/image-builder) 来创建和管理自定义， AMIs 作为这些过程的替代方案。有关更多信息，请参阅 [Image Builder User Guide](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html)。
**识别基本 Elastic Beanstalk AMI**
1. 在命令窗口中，运行以下命令。有关更多信息，请参阅《AWS CLI 命令参考》**中的 [describe-platform-version](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/describe-platform-version.html)。
指定您要使用自定义 AMI 的 AWS 区域，并将平台 ARN 和版本号替换为您的应用程序所基于的 Elastic Beanstalk 平台。
**Example - Mac OS / Linux OS**
```
$ aws elasticbeanstalk describe-platform-version --region us-east-2 \
--platform-arn "arn:aws:elasticbeanstalk:us-east-2::platform/Node.js 20 running on 64bit Amazon Linux 2023/6.1.7" \
--query PlatformDescription.CustomAmiList
[
{
"VirtualizationType": "pv",
"ImageId": ""
},
{
"VirtualizationType": "hvm",
"ImageId": "ami-020ae06fdda6a0f66"
}
]
```
**Example - Windows OS**
```
C:\> aws elasticbeanstalk describe-platform-version --region us-east-2 --platform-arn"arn:aws:elasticbeanstalk:us-east-2::platform/
IIS 10.0 running on 64bit Windows Server 2022/2.15.3" --query PlatformDescription.CustomAmiList
[
{
"VirtualizationType": "pv",
"ImageId": ""
},
{
"VirtualizationType": "hvm",
"ImageId": "ami-020ae06fdda6a0f66"
}
]
```
1. 记下结果中类似于 `ami-020ae06fdda6a0f66` 的 `ImageId` 值。
该值是与您的应用程序相关的平台版本、EC2 实例架构 AWS 和区域的现货 Elastic Beanstalk AMI。如果您需要 AMIs 为多个平台、架构或 AWS 区域进行创建，请重复此过程，为每种组合确定正确的基础 AMI。
**注意**
不要从已在 Elastic Beanstalk 环境中启动的实例创建 AMI。Elastic Beanstalk 会在配置期间修改实例，这可能导致所保存的 AMI 出现问题。从 Elastic Beanstalk 环境中的实例保存映像还会使此实例上部署的应用程序版本成为映像的固定部分。
对于 Linux，也可以从并非由 Elastic Beanstalk 发布的社区 AMI 创建自定义 AMI。您可以使用最新的 [Amazon Linux](https://aws.amazon.com/amazon-linux-ami/) AMI 作为起点。使用不由 Elastic Beanstalk 管理的 Linux AMI 启动环境时，Elastic Beanstalk 会尝试安装平台软件（语言、框架、代理服务器等）及其他组件，以支持[增强型运行状况报告](health-enhanced.md)等功能。
**注意**
AMIs 基于 Windows Server 的定制需要`describe-platform-version`退回的库存 Elastic Beanstalk AMI，如前面的步骤 1 所示。
虽然 Elastic Beanstalk 可以使用不由 Elastic Beanstalk 管理的 AMI，但 Elastic Beanstalk 安装缺失的组件会导致配置时间增加，因而减少或抵消当初创建自定义 AMI 的优势。其他 Linux 发行版也许能够进行某些故障诊断操作，但不受官方支持。如果您的应用程序需要特定的 Linux 发行版，一个替代方案是创建 Docker 映像并在 [Docker 平台](docker.md)或[多容器 Docker 平台](create_deploy_docker_ecs.md)上运行该映像。
**创建自定义 AMI**
1. 打开位于 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 的 Amazon EC2 控制台。
1. 选择**启动实例**。
1. 如果您确定了基础 Elastic Beanstalk AMI（使用 `describe-platform-version`）或 Amazon Linux AMI，请在搜索框中输入其 AMI ID。然后按 **Enter**。
您也可以搜索满足需要的其他社区 AMI 的列表。
**注意**
我们建议您选择使用 HVM 虚拟化的 AMI。它们在描述中 AMIs 显示**虚拟化类型：hvm**。
有关更多信息，请参阅《*Amazon EC2 用户指南*》中的[虚拟化类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ComponentsAMIs.html#virtualization_types)。
1. 选择 **Select (选择)** 以选择此 AMI。
1. 选择实例类型，然后选择**下一步：配置实例详细信息**。
1. **（适用于已停用的 Amazon Linux AMI (AL1) 平台）**如果您的环境在支持的基于 Linux 的平台或 Windows 平台上运行，请跳过此步骤。
展开**高级详细信息**部分并将以下文本粘贴到**用户数据**字段中。
```
#cloud-config
repo_releasever: repository version number
repo_upgrade: none
```
*存储库版本号* 是指 AMI 名称中的年份和月份版本。例如， AMIs 基于 2015 年 3 月发布的 Amazon Linux 有一个存储库版本号`2015.03`。对于 Elastic Beanstalk 映像，该版本号是基于 Amazon Linux AMI（在 Amazon Linux 2 之前）的[平台版本](concepts.platforms.md)的解决方案堆栈名称中显示的日期。
**注意**
该`repo_releasever`设置为亚马逊 Linux AMI 配置该 lock-on-launch功能。这会导致 AMI 在启动时固定使用特定的存储库版本。Amazon Linux 2 不支持此功能 - 如果您的环境使用最新的 Amazon Linux 2 平台分支，请不要指定此功能。如果您仅在 Amazon Linux AMI 平台分支（在 Amazon Linux 2 之前）上将自定义 AMI 与 Elastic Beanstalk 结合使用，则需要此设置。
`repo_upgrade` 设置会禁止自动安装安全更新。它需要将自定义 AMI 与 Elastic Beanstalk 结合使用。
1. 根据向导指示进行操作，以[启动此 EC2 实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/launching-an-instance.html)。当系统提示时，选择您能够访问的密钥对，以便能够连接此实例来执行后续步骤。
1. 使用 SSH 或 RDP [连接到此实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html)。
1. 执行任何所需的自定义操作。
1. **（Windows 平台）**运行 EC2 Config 服务 Sysprep。有关 EC2 Config 的信息，请参阅[使用配置服务 EC2配置 Windows 实例](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/UsingConfig_WinAMI.html)。确保 Sysprep 配置为生成可从 AWS 管理控制台检索的随机密码。
1. 在 Amazon EC2 控制台中，停止 EC2 实例。然后，在 **Instance Actions (实例操作)** 菜单上，选择 **Create Image (EBS AMI) (创建映像(EBS AMI))**。
1. 为避免产生额外 AWS 费用，请[终止 EC2 实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html)。
**在 Elastic Beanstalk 环境中使用您的自定义 AMI**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 在导航窗格中，选择 **Configuration (配置)**。
1. 在 **Capacity (容量)** 配置类别中，选择 **Edit (编辑)**。
1. 对于 **AMI ID**，请输入您的自定义 AMI ID。
1. 要保存更改，请选择页面底部的 **Apply**（应用）。
当您使用自定义 AMI 创建新环境时，应该使用您用作创建 AMI 的基础的相同平台版本。
## 使用自定义 AMI 管理环境
### 平台更新
使用自定义 AMI 时，Elastic Beanstalk 将在其平台版本更新时继续在环境中使用相同的自定义 AMI，无论是手动应用更新还是通过托管平台更新应用更新。环境**不会**重置为使用新平台版本的常用 AMI。
我们建议您基于新平台版本的常用 AMI 创建新的自定义 AMI。这样做将应用新平台版本中可用的补丁，并将最大限度地减少由于包或库版本不兼容而导致的部署失败。
有关创建新的自定义 AMI 的更多信息，请参阅本主题前面的 [创建自定义 AMI](#using-features.customenv.create)。
### 移除自定义 AMI
如果想要从环境中移除自定义 AMI 并将其重置为使用环境平台版本的常用 AMI，请使用以下 CLI 命令。
```
aws elasticbeanstalk update-environment \
--application-name my-application \
--environment-name my-environment \
--region us-east-1 \
--options-to-remove Namespace=aws:autoscaling:launchconfiguration,OptionName=ImageId
```
**注意**
为了避免服务中断，请在将此更改应用到生产环境之前使用常用 AMI 测试您的应用程序。
## 清除自定义 AMI
在您使用完自定义 AMI 并且不再需要它来启动 Elastic Beanstalk 环境时，请考虑将其清除以最大程度地减少存储成本。清除自定义 AMI 涉及到从 Amazon EC2 取消注册它并删除其他关联的资源。有关详细信息，请参阅[取消注册您的 Linux AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/deregister-ami.html) 或[取消注册您的 Windows AMI](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/deregister-ami.html)。
# 保持能够访问适用于已停用平台的亚马逊机器映像（AMI）的方法
当分支使用的操作系统或主要组件达到生命周期终点时，Elastic Beanstalk 将平台分支状态设置为*停用*。也可以将平台分支机构的*基本* Elastic Beanstalk AMI 设为私有，以防止使用此 AMI。 out-of-date使用 AMIs 已设为私有内容的环境将无法再启动实例。
如果无法在应用程序停用之前将其迁移到受支持的环境，则您的环境可能就会出现这种情况。可能需要更新 Beanstalk 平台分支的环境，在这个环境中，基础 Elastic Beanstalk AMI 已私有化。可以采用另一种方法。您可以根据环境使用的基础 Elastic Beanstalk AMI *副本*更新现有环境。
本主题提供了一些步骤和一个独立脚本，用于根据环境使用的基础 Elastic Beanstalk AMI *副本*更新现有环境。一旦将应用程序迁移到受支持的平台，您就可以继续使用标准过程来维护您的应用程序和受支持的环境。
## 手动步骤
**要基于基础 Elastic Beanstalk AMI 的 AMI 副本更新环境**
1. **确定环境使用的 AMI。**此命令返回您在参数中提供的 Elastic Beanstalk 环境使用的 AMI。返回的值将用作下一步*source-ami-id*中的。
在命令窗口中，运行以下命令。有关更多信息，请参阅《AWS CLI 命令参考》**中的 [describe-configuration-settings](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/describe-configuration-settings.html)。
指定存储要复制的源 AMI 的 AWS 区域。将应用程序名称和环境名称替换为基于源 AMI 的名称。输入查询参数的文本，如下所示。
**Example**
```
>aws elasticbeanstalk describe-configuration-settings \
--application-name my-application \
--environment-name my-environment \
--region us-east-2 \
--query "ConfigurationSettings[0].OptionSettings[?OptionName=='ImageId'] | [0].Value"
```
1. **将 AMI 复制到您的账户。**此命令返回通过复制上一步返回*source-ami-id*的新 AMI。
**注意**
请务必记下此命令输出的新 AMI id。你需要在下一步中输入它，在示例命令*copied-ami-id*中进行替换。
在命令窗口中，运行以下命令。有关更多信息，请参见《AWS CLI 命令参考》**中的 [copy-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/copy-image.html)。
**指定要复制的源 AMI 的 AWS 区域（**--source-** region）和要使用新自定义 AMI 的区域（--region）。***source-ami-id *替换为您正在复制的图像的 AMI。*source-ami-id*已在上一步中由命令返回。*new-ami-name*替换为描述目标区域中的新 AMI 的名称。*此过程之后的脚本通过在名称的开头附加字符串 “*Copy o* f” 来生成新的 AMI 名称。source-ami-id*
```
>aws ec2 copy-image \
--region us-east-2 \
--source-image-id source-ami-id \
--source-region us-east-2 \
--name new-ami-name
```
1. **更新环境以使用复制的 AMI。**该命令运行后，将返回环境的状态。
在命令窗口中，运行以下命令。有关更多信息，请参阅《AWS CLI 命令参考》**中的 [update-environment](https://docs.aws.amazon.com/cli/latest/reference/elasticbeanstalk/update-environment.html)。
指定需要更新的环境和应用程序的 AWS 区域。将应用程序名称和环境名称替换为上一步*copied-ami-id*中需要与关联的名称。对于 **--option-setting** s参数，*copied-ami-id*请替换为你在前一个命令的输出中记下的 AMI ID。
```
>aws elasticbeanstalk update-environment \
--application-name my-application \
--environment-name my-environment \
--region us-east-2 \
--option-settings "Namespace=aws:autoscaling:launchconfiguration,OptionName=ImageId,Value=copied-ami-id"
```
**注意**
为了最大限度地降低存储成本，当您不再需要它来启动 Elastic Beanstalk 环境时，可以考虑清理您的自定义 AMI。有关更多信息，请参阅 [清除自定义 AMI](using-features.customenv.md#using-features.customenv.cleanup)。
## 独立脚本
以下脚本提供了与前面的手动步骤相同的结果。选择以下链接下载脚本：[copy\$1ami\$1and\$1update\$1env.zip](samples/copy_ami_and_update_env.zip)。
### 脚本源：copy\$1ami\$1and\$1update\$1env.sh
```
#!/bin/bash
set -ue
USAGE="This script is used to copy an AMI used by your Elastic Beanstalk environment into your account to use in your environment.\n\n"
USAGE+="Usage:\n\n"
USAGE+="./$(basename $0) [OPTIONS]\n"
USAGE+="OPTIONS:\n"
USAGE+="\t--application-name \tThe name of your Elastic Beanstalk application.\n"
USAGE+="\t--environment-name \tThe name of your Elastic Beanstalk environment.\n"
USAGE+="\t--region \t\t\tThe AWS region your Elastic Beanstalk environment is deployed to.\n"
USAGE+="\n\n"
USAGE+="Script Usage Example(s):\n"
USAGE+="./$(basename $0) --application-name my-application --environment-name my-environment --region us-east-1\n"
if [ $# -eq 0 ]; then
echo -e $USAGE
exit
fi
while [[ $# -gt 0 ]]; do
case $1 in
--application-name) APPLICATION_NAME="$2"; shift ;;
--environment-name) ENVIRONMENT_NAME="$2"; shift ;;
--region) REGION="$2"; shift ;;
*) echo "Unknown option $1" ; echo -e $USAGE ; exit ;;
esac
shift
done
aws_cli_version="$(aws --version)"
if [ $? -ne 0 ]; then
echo "aws CLI not found. Please install it: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html. Exiting."
exit 1
fi
echo "Using aws CLI version: ${aws_cli_version}"
account=$(aws sts get-caller-identity --query "Account" --output text)
echo "Using account ${account}"
environment_ami_id=$(aws elasticbeanstalk describe-configuration-settings \
--application-name "$APPLICATION_NAME" \
--environment-name "$ENVIRONMENT_NAME" \
--region "$REGION" \
--query "ConfigurationSettings[0].OptionSettings[?OptionName=='ImageId'] | [0].Value" \
--output text)
echo "Image associated with environment ${ENVIRONMENT_NAME} is ${environment_ami_id}"
owned_image=$(aws ec2 describe-images \
--owners self \
--image-ids "$environment_ami_id" \
--region "$REGION" \
--query "Images[0]" \
--output text)
if [ "$owned_image" != "None" ]; then
echo "${environment_ami_id} is already owned by account ${account}. Exiting."
exit
fi
source_image_name=$(aws ec2 describe-images \
--image-ids "$environment_ami_id" \
--region "$REGION" \
--query "Images[0].Name" \
--output text)
if [ "$source_image_name" = "None" ]; then
echo "Cannot find ${environment_ami_id}. Please contact AWS support if you need additional help: https://aws.amazon.com/support."
exit 1
fi
copied_image_name="Copy of ${source_image_name}"
copied_ami_id=$(aws ec2 describe-images \
--owners self \
--filters Name=name,Values="${copied_image_name}" \
--region "$REGION" \
--query "Images[0].ImageId" \
--output text)
if [ "$copied_ami_id" != "None" ]; then
echo "Detected that ${environment_ami_id} has already been copied by account ${account}. Skipping image copy."
else
echo "Copying ${environment_ami_id} to account ${account} with name ${copied_image_name}"
copied_ami_id=$(aws ec2 copy-image \
--source-image-id "$environment_ami_id" \
--source-region "$REGION" \
--name "$copied_image_name" \
--region "$REGION" \
--query "ImageId" \
--output text)
echo "New AMI ID is ${copied_ami_id}"
echo "Waiting for ${copied_ami_id} to become available"
aws ec2 wait image-available \
--image-ids "$copied_ami_id" \
--region "$REGION"
echo "${copied_ami_id} is now available"
fi
echo "Updating environment ${ENVIRONMENT_NAME} to use ${copied_ami_id}"
environment_status=$(aws elasticbeanstalk update-environment \
--application-name "$APPLICATION_NAME" \
--environment-name "$ENVIRONMENT_NAME" \
--option-settings "Namespace=aws:autoscaling:launchconfiguration,OptionName=ImageId,Value=${copied_ami_id}" \
--region "$REGION" \
--query "Status" \
--output text)
echo "Environment ${ENVIRONMENT_NAME} is now ${environment_status}"
echo "Waiting for environment ${ENVIRONMENT_NAME} update to complete"
aws elasticbeanstalk wait environment-updated \
--application-name "$APPLICATION_NAME" \
--environment-names "$ENVIRONMENT_NAME" \
--region "$REGION"
echo "Environment ${ENVIRONMENT_NAME} update complete"
```
**注意**
必须 AWS CLI 安装才能执行脚本。有关安装说明，请参见《AWS Command Line Interface 用户指南》**中的[安装或更新最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)。
安装完成后 AWS CLI，您还必须将其配置为使用拥有该环境的 AWS 帐户。有关更多信息，请参阅《AWS Command Line Interface 用户指南》**中的[配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)。该账户还必须具有创建 AMI 和更新 Elastic Beanstalk 环境的权限。
这些步骤描述了脚本遵循的过程。
1. 打印正在使用的账户。
1. 确定环境使用的 AMI（源 AMI）。
1. 检查源 AMI 是否已由账户拥有。如果是，请退出。
1. 确定源 AMI 的名称，以便在新 AMI 名称中使用。这也用于确认对源 AMI 的访问。
1. 检查源 AMI 是否已复制到账户。这是通过使用账户所 AMIs 拥有的复制的 AMI 的名称进行搜索来完成的。如果在脚本执行之间更改了 AMI 名称，则需再次复制映像。
1. 如果尚未复制源 AMI，请将源 AMI 复制到账户，然后等待新的 AMI 可用。
1. 更新环境配置以使用新的 AMI。
1. 等待环境更新完成。
从 [copy\$1ami\$1and\$1update\$1env.zip](samples/copy_ami_and_update_env.zip) 文件中提取脚本后，执行以下示例运行脚本。将示例中的应用程序名称和环境名称替换为您自己的值。
```
>sh copy_ami_and_update_env.sh \
--application-name my-application \
--environment-name my-environment \
--region us-east-1
```
**注意**
为了最大限度地降低存储成本，当您不再需要它来启动 Elastic Beanstalk 环境时，可以考虑清理您的自定义 AMI。有关更多信息，请参阅 [清除自定义 AMI](using-features.customenv.md#using-features.customenv.cleanup)。
# 提供静态文件
为了提高性能，您可以配置代理服务器，从 Web 应用程序内的一组目录中提供静态文件（例如 HTML 或图像）。当代理服务器收到对指定路径下的某个文件的请求时，它将直接提供此文件，而不是将请求路由至您的应用程序。
Elastic Beanstalk 支持将代理配置为在基于 Amazon Linux 2 的大多数平台分支上提供静态文件。唯一的例外是 Docker。
**注意**
默认情况下，在 Python 和 Ruby 平台上，Elastic Beanstalk 配置一些静态文件夹。有关详细信息，请参阅 [Python](create-deploy-python-container.md#python-platform-staticfiles) 和 [Ruby](create_deploy_Ruby.container.md#create_deploy_Ruby.container.console.staticfiles) 的静态文件配置部分。您可以按照本页中的说明配置其他文件夹。
## 使用控制台配置静态文件
**配置代理服务器提供静态文件**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 在导航窗格中，选择 **Configuration**（配置）。
1. 在 **Updates, monitoring, and logging**（更新、监控和日志记录）配置类别中，选择 **Edit**（编辑）。
1. 滚动到 **Platform software**（平台软件）部分并找到 **Static files**（静态文件）组。
1. 要添加静态文件映射，请选择 **Add static files**（添加静态文件）。在出现的额外一行中，您将输入提供静态文件的*路径*和包含要提供的静态文件的*目录*。
+ 在 **Path**（路径）字段中，路径名称以斜杠 (`/`) 开头（例如，“*/images*”）。
+ 在 **Directory**（目录）字段中，指定位于应用程序源代码根目录中的目录名称。不要用斜杠开头（例如，“*static/image-files*”）。
**注意**
如果看不到**静态文件**部分，您必须使用[配置文件](ebextensions.md)至少添加一个映射。有关详细信息，请参阅此页上的 [使用配置选项配置静态文件](#environment-cfg-staticfiles.namespace)。
1. 要删除映射，请选择 **Remove**（删除）。
1. 要保存更改，请选择页面底部的 **Apply**（应用）。
## 使用配置选项配置静态文件
您可以使用[配置文件](ebextensions.md)来配置静态文件路径，以及使用配置选项来配置目录位置。您可以将配置文件添加到应用程序的源包中，并在创建环境时或稍后的部署期间进行部署。
如果您的环境使用基于 Amazon Linux 2 的平台分支，请使用 `aws:elasticbeanstalk:environment:proxy:staticfiles` 命名空间。
以下示例配置文件告诉代理服务器在 `/html` 路径的文件夹 `statichtml` 中提供文件，并在路径 `/images` 的 `staticimages` 文件夹中提供文件。
**Example .ebextensions/static-files.config**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:staticfiles:
/html: statichtml
/images: staticimages
```
如果您的 Elastic Beanstalk 环境使用 Amazon Linux AMI 平台版本（在 Amazon Linux 2 之前），请阅读以下附加信息：
### Amazon Linux AMI 平台特定的命名空间
在 Amazon Linux AMI 平台分支上，静态文件配置命名空间因平台而异。如需了解详情，请参考以下页面之一：
+ [Go 配置命名空间](go-environment.md#go-namespaces)
+ [Java SE 配置命名空间](java-se-platform.md#java-se-namespaces)
+ [Tomcat 配置命名空间](java-tomcat-platform.md#java-tomcat-namespaces)
+ [Node.js 配置命名空间](create_deploy_nodejs.container.md#nodejs-namespaces)
+ [Python 配置命名空间](create-deploy-python-container.md#python-namespaces)
# 为 Elastic Beanstalk 环境配置 HTTPS
本节中的主题介绍如何为您的 Elastic Beanstalk 环境配置 HTTPS。HTTPS 是传输用户数据或登录信息的任何应用程序而言都必不可少。
如果您已为 Elastic Beanstalk 环境购买并配置了[自定义域名](customdomains.md)，您可以使用 HTTPS 来允许用户安全连接到网站。
如果您没有域名，仍可将包含自签名证书的 HTTPS 用于开发和测试目的。有关更多信息，请参阅 [服务器证书](configuring-https.certificate.md)。
**在负载均衡器上配置 HTTPS 终止**
负载均衡器将请求分配到运行您的应用程序的 EC2 实例。负载均衡器还使您无需将实例直接公开在 Internet 上。在 Elastic Beanstalk 多实例环境中使用 HTTPS 的最简单方法是为负载均衡器配置一个安全侦听器。客户端和负载均衡器之间的连接仍然是安全的，因此您可以将负载均衡器配置为终止 HTTPS。负载均衡器和 EC2 实例之间的后端连接使用 HTTP，因此不需要实例的其他配置。有关配置安全侦听器的详细说明，请参阅 [在负载均衡器上配置 HTTPS 终止](configuring-https-elb.md)。
**在 EC2 实例上配置 HTTPS 终止**
如果您在单实例环境中运行应用程序，或需要确保可一直连接到负载均衡器背后的 EC2 实例，您可配置在实例上运行的代理服务器以终止 HTTPS。配置实例以终止 HTTPS 连接要求使用[配置文件](ebextensions.md)来更改在实例上运行的软件，并修改安全组，以允许安全连接。有关更多信息，请参阅 [在实例上配置 HTTPS 终止](https-singleinstance.md)。
**配置 HTTPS end-to-end**
对于负载平衡环境中的 end-to-end HTTPS，您可以结合使用实例和负载均衡器终止来加密两个连接。默认情况下，如果您使用 HTTPS 配置负载均衡器以转发流量，它将信任由后端实例向其提交的所有证书。为了实现最高安全性，您将策略与负载均衡器连接，避免其连接未提交其信任的公有证书的实例。有关更多信息，请参阅 [在负载均衡的 Elastic Beanstalk 环境中配置 end-to-end加密](configuring-https-endtoend.md)。
**为 HTTPS 配置 TCP 传递**
您也可将负载均衡器配置为传递 HTTPS 流量，无需解密。有关更多信息，请参阅 [为 TCP 传递配置环境的负载均衡器](https-tcp-passthrough.md)。
**注意**
[它有蛇](https://github.com/awslabs/eb-tomcat-snakes)吗？ 上的示例应用程序 GitHub 包括使用 Tomcat Web 应用程序配置 HTTPS 的每种方法的配置文件和说明。请参阅 [readme](https://github.com/awslabs/eb-tomcat-snakes/blob/master/README.md) 文件和 [HTTPS 说明](https://github.com/awslabs/eb-tomcat-snakes/blob/master/src/.ebextensions/inactive/HTTPS.md)以了解详细信息。
**Topics**
+ [服务器证书](configuring-https.certificate.md)
+ [在负载均衡器上配置 HTTPS 终止](configuring-https-elb.md)
+ [在实例上配置 HTTPS 终止](https-singleinstance.md)
+ [在负载均衡的 Elastic Beanstalk 环境中配置 end-to-end加密](configuring-https-endtoend.md)
+ [为 TCP 传递配置环境的负载均衡器](https-tcp-passthrough.md)
+ [配置 HTTP 到 HTTPS 重定向](configuring-https-httpredirect.md)
# 服务器证书
本主题介绍可用于配置 HTTPS 的不同类型的证书以及何时应用每种证书。本节中的子主题提供了有关创建您自己的证书以及如何上传它的说明。
**AWS Certificate Manager (ACM)**
ACM 是预置、管理和部署您的服务器证书的首选工具。您可以通过编程或使用. AWS CLI使用 ACM，您可为自己的域名免费创建可信证书。
ACM 证书只能用于 AWS 负载均衡器和 Amazon CloudFront 分配，而且 ACM 仅在某些地区可用。 AWS 要将 ACM 证书与 Elastic Beanstalk 结合使用，请参阅[在负载均衡器上配置 HTTPS 终止](configuring-https-elb.md)。有关 ACM 的更多信息，请参阅《[https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html](https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html)》。
**注意**
有关可使用 ACM 的区域列表，请参阅 *Amazon Web Services 一般参考* 中的 [ACM endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/acm.html)。
如果 ACM 在您 AWS 所在的地区不可用，您可以将第三方或自签名证书和私钥上传到 AWS Identity and Access Management (IAM)。您可以使用 AWS CLI 上传证书。存储在 IAM 中的证书可用于负载均衡器和 CloudFront 分配。有关更多信息，请参阅 [上传证书至 IAM](configuring-https-ssl-upload.md)。
**第三方证书**
如果 ACM 在您所在的区域不可用，您可从第三方购买的可信证书。第三方证书可用于在负载均衡器、后端实例或负载均衡器及后端实例上解密 HTTPS 流量。
**自签名证书**
对于开发和测试，您可使用开源工具自行[创建和签署证书](configuring-https-ssl.md)。自签名证书可免费轻松创建，但无法用于公共站点的前端解密。如果您试图通过客户端为 HTTPS 连接使用自签名证书，用户的浏览器将会显示错误消息，表示网站不安全。但您可使用自签名证书来确保后端连接，不会出现问题。
# 创建和签名 X509 证书
您可以使用 `OpenSSL` 为应用程序创建 X509 证书。OpenSSL 一种支持广泛加密功能的标准开源库，其功能包括创建和签名 X509 证书。有关 OpenSSL 的更多信息，请访问 [www.openssl.org/](https://www.openssl.org/)。
**注意**
如果要[在单实例环境中使用 HTTPS](https-singleinstance.md) 或使用自签名证书[在后端上重新加密](configuring-https-endtoend.md)，您只需在本地创建证书。如果您拥有域名，则可以使用 AWS Certificate Manager (ACM) 在中创建证书 AWS 并免费将其用于负载平衡的环境。有关说明，请参阅 *AWS Certificate Manager 用户指南*中的[请求证书](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html)。
在命令行运行 `openssl version`，查看是否已安装 OpenSSL。如果你不这样做，你可以按照[公共 GitHub 存储库](https://github.com/openssl/openssl)中的说明来构建和安装源代码，或者使用你最喜欢的包管理器。[OpenSSL 也安装在 Elastic Beanstalk 的 Linux 映像上，因此一种快速的替代方法是使用 EB CLI 的命令连接到运行环境中的 EC2 实例：](eb-cli3.md)**eb ssh**
```
~/eb$ eb ssh
[ec2-user@ip-255-55-55-255 ~]$ openssl version
OpenSSL 1.0.1k-fips 8 Jan 2015
```
您需要创建 RSA 私有密钥才能创建证书签名请求 (CSR)。要创建私有密钥，请使用 **openssl genrsa** 命令：
```
[ec2-user@ip-255-55-55-255 ~]$ openssl genrsa 2048 > privatekey.pem
Generating RSA private key, 2048 bit long modulus
.................................................................................................................................+++
...............+++
e is 65537 (0x10001)
```
*privatekey.pem*
要用于保存私有密钥的文件的名称。通常，**openssl genrsa** 命令将私有密钥内容输出到屏幕，但此命令将输出通过管道传送到文件。选择任何文件名，并将文件存储在安全位置，以便您以后可以检索它。如果您丢失私有密钥，则无法使用您的证书。
CSR 是指您为申请数字服务器证书而发送至证书颁发机构 (CA) 的文件。要创建 CSR，请使用 **openssl req** 命令：
```
$ openssl req -new -key privatekey.pem -out csr.pem
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
```
输入所请求的信息并按 **Enter**。下表描述并显示每个字段的示例。
****
| Name | 说明 | 示例 |
| --- | --- | --- |
| 国家/地区名称 | 代表国家/地区的两个字母 ISO 缩写。 | US = 美国 |
| 州或省 | 组织所在州或省的名称。不能缩写此名称。 | Washington |
| 所在地名称 | 组织所在城市的名称。 | Seattle |
| 组织名称 | 组织的法定全称。请勿缩写组织名称。 | Example Corporation |
| 组织部门 | 可选，用于提供额外的组织信息。 | 市场营销 |
| 公用名 | 网站的完全限定域名。这必须与用户访问站点时看到的域名相符，否则将显示证书错误。 | www.example.com |
| 电子邮件地址 | 站点管理员的电子邮件地址。 | someone@example.com |
您可向第三方提交签名请求以供签名，或自行签名以供开发和测试。自签名证书也可用于负载均衡器和 EC2 实例之间的后端 HTTPS。
要对证书进行签名，请使用 **openssl x509** 命令。以下示例使用上一步中的私钥 (*privatekey.pem*) 和签名请求 (*csr.pem*) 来创建有效期为*365*数天的名*public.crt*为的公有证书。
```
$ openssl x509 -req -days 365 -in csr.pem -signkey privatekey.pem -out public.crt
Signature ok
subject=/C=us/ST=washington/L=seattle/O=example corporation/OU=marketing/CN=www.example.com/emailAddress=someone@example.com
Getting Private key
```
保存私钥和公有证书以待将来使用。您可放弃签名请求。请始终[将私有密钥存储在安全位置](https-storingprivatekeys.md)并避免将其添加到源代码。
要将证书用于 Windows Server 平台，您必须将证书转换为 PFX 格式。使用以下命令可在私有密钥和公有证书文件中创建 PFX 证书：
```
$ openssl pkcs12 -export -out example.com.pfx -inkey privatekey.pem -in public.crt
Enter Export Password: password
Verifying - Enter Export Password: password
```
既然您已经拥有了证书，您可以[将其上传到 IAM](configuring-https-ssl-upload.md)以与负载均衡器结合使用，或者[在您的环境中配置实例以终止 HTTPS](https-singleinstance.md)。
# 上传证书至 IAM
要将您的证书与 Elastic Beanstalk 环境的负载均衡器配合使用，请将证书和私 AWS Identity and Access Management 钥上传到 (IAM)。您可以将存储在 IAM 中的证书与 Elastic Load Balancing 负载均衡器和亚马逊 CloudFront 分配配合使用。
**注意**
AWS Certificate Manager (ACM) 是预置、管理和部署服务器证书的首选工具。有关请求 ACM 证书的更多信息，请参阅 *AWS Certificate Manager 用户指南*中的[请求证书](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request.html)。有关将第三方证书导入 ACM 中的更多信息，请参阅 *AWS Certificate Manager 用户指南*中的[导入证书](https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html)。只有在[您所在的 AWS 地区没有 ACM 时，才使用](https://docs.aws.amazon.com/general/latest/gr/acm.html) IAM 上传证书。
您可以使用 AWS Command Line Interface (AWS CLI) 上传您的证书。以下命令上传名为的自签名证书，*https-cert.crt*其私钥名为：*private-key.pem*
```
$ aws iam upload-server-certificate --server-certificate-name elastic-beanstalk-x509 --certificate-body file://https-cert.crt --private-key file://private-key.pem
{
"ServerCertificateMetadata": {
"ServerCertificateId": "AS5YBEIONO2Q7CAIHKNGC",
"ServerCertificateName": "elastic-beanstalk-x509",
"Expiration": "2017-01-31T23:06:22Z",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:server-certificate/elastic-beanstalk-x509",
"UploadDate": "2016-02-01T23:10:34.167Z"
}
}
```
前`file://`缀告诉 AWS CLI 将文件内容加载到当前目录中。 *elastic-beanstalk-x509*指定在 IAM 中调用证书的名称。
如果您已从证书颁发机构购买了证书并已收到证书链文件，请包括 `--certificate-chain` 选项，将证书链文件同样上传：
```
$ aws iam upload-server-certificate --server-certificate-name elastic-beanstalk-x509 --certificate-chain file://certificate-chain.pem --certificate-body file://https-cert.crt --private-key file://private-key.pem
```
记下证书的 Amazon Resource Name (ARN)。当您更新负载均衡器配置设置以使用 HTTPS 时，您会使用它。
**注意**
上传到 IAM 的证书保持存储状态，即使在任何环境的负载均衡器中不再使用它也如此。它包含敏感数据。当您对于任何环境都不再需要该证书时，请务必将其删除。有关从 IAM 中删除证书的详细信息，请参阅[https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html#delete-server-certificate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html#delete-server-certificate)。
有关 IAM 中的服务器证书的更多信息，请参阅《*IAM 用户指南*》中的[使用服务器证书](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)。
# 在 Amazon S3 中安全地存储私有密钥
用于对公有证书签名的私有密钥是私有的，不应提交到源代码。通过将私有密钥上传到 Amazon S3，然后将 Elastic Beanstalk 配置为在应用程序部署期间从 Amazon S3 下载文件，可以避免将私有密钥存储在配置文件中。
以下示例显示了[配置文件](ebextensions.md)的[资源](environment-resources.md)和[文件](customize-containers-ec2.md#linux-files)部分，并从 Amazon S3 存储桶下载私有密钥文件。
**Example .ebextensions/privatekey.config**
```
Resources:
AWSEBAutoScalingGroup:
Metadata:
AWS::CloudFormation::Authentication:
S3Auth:
type: "s3"
buckets: ["elasticbeanstalk-us-west-2-123456789012"]
roleName:
"Fn::GetOptionSetting":
Namespace: "aws:autoscaling:launchconfiguration"
OptionName: "IamInstanceProfile"
DefaultValue: "aws-elasticbeanstalk-ec2-role"
files:
# Private key
"/etc/pki/tls/certs/server.key":
mode: "000400"
owner: root
group: root
authentication: "S3Auth"
source: https://elasticbeanstalk-us-west-2-123456789012.s3.us-west-2.amazonaws.com/server.key
```
将示例中的存储桶名称和 URL 替换为您自己的。此文件中的第一个条目将名为 `S3Auth` 的身份验证方法添加到环境的 Auto Scaling 组的元数据中。如果您为环境配置了自定义[实例配置文件](concepts-roles-instance.md)，则将使用自定义实例配置文件，否则应用默认值 `aws-elasticbeanstalk-ec2-role`。默认实例配置文件具有从 Elastic Beanstalk 存储桶读取的权限。如果您使用不同的存储桶，请[向实例配置文件添加权限](iam-instanceprofile.md#iam-instanceprofile-addperms)。
第二个条目使用 `S3Auth` 身份验证方法从指定 URL 下载私有密钥并将其保存到 `/etc/pki/tls/certs/server.key`。然后，代理服务器可以从此位置读取私有密钥以[终止实例的 HTTPS 连接](https-singleinstance.md)。
分配给您的环境实例的 EC2 实例配置文件必须具有从指定存储桶读取密钥对象的权限。[验证实例配置文件有权](iam-instanceprofile.md#iam-instanceprofile-verify)读取 IAM 中的对象，并且存储桶和对象上的权限不禁止实例配置文件。
**查看存储桶的权限**
1. 打开 [Amazon S3 管理控制台](https://console.aws.amazon.com/s3/home)。
1. 选择存储桶。
1. 选择**属性**，然后选择**权限**。
1. 验证您的账户已被授予存储桶的读取权限。
1. 如果已附加存储桶策略，请选择**存储桶策略**以查看分配到存储桶的权限。
# 在负载均衡器上配置 HTTPS 终止
要更新您的 AWS Elastic Beanstalk 环境以使用 HTTPS，您需要为环境中的负载均衡器配置 HTTPS 侦听器。两种类型的负载均衡器支持 HTTPS 侦听器：经典负载均衡器和 Application Load Balancer。
您可以使用 Elastic Beanstalk 控制台或配置文件配置安全侦听器和分配证书。
**注意**
单实例环境没有负载均衡器并且不支持负载均衡器上的 HTTPS 终止。
## 使用 Elastic Beanstalk 控制台配置安全侦听器
**将证书分配至环境的负载均衡器**
1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域
1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。
1. 在导航窗格中，选择 **Configuration**（配置）。
1. 在 **Load balancer (负载均衡器)** 配置类别中，选择 **Edit (编辑)**。
**注意**
如果 **Load balancer (负载均衡器)** 配置类别没有 **Edit (编辑)** 按钮，则表示您的环境没有[负载均衡器](using-features-managing-env-types.md#using-features.managing.changetype)。
1. 在**修改负载均衡器**页上，根据与您的环境关联的负载均衡器类型，该过程将会有所不同。
+ **经典负载均衡器**
1. 选择**添加侦听器**。
1. 在 **经典负载均衡器 listener (经典负载均衡器侦听器)** 对话框中，配置以下设置：
+ 对于**侦听器端口**，请键入传入流量端口，通常为 `443`。
+ 对于**侦听器协议**，选择 **HTTPS**。
+ 对于**实例端口**，请键入 `80`。
+ 对于**实例协议**，选择 **HTTP**。
+ 对于 **SSL 证书**，选择您的证书。
1. 选择**添加**。
+ **应用程序负载均衡器**
1. 选择**添加侦听器**。
1. 在 **Application Load Balancer listener (Application Load Balancer 侦听器)** 对话框中，配置以下设置：
+ 对于**端口**，请键入传入流量端口，通常为 `443`。
+ 对于**协议**，选择 **HTTPS**。
+ 对于 **SSL 证书**，选择您的证书。
1. 选择**添加**。
**注意**
对于经典负载均衡器和应用程序负载均衡器，如果下拉菜单中未显示任何证书，您应在 [AWS Certificate Manager (ACM)](https://docs.aws.amazon.com/acm/latest/userguide/) 中为您的[自定义域名](customdomains.md)创建或上传证书（首选）。或者，使用 AWS CLI将证书上传到 IAM。
+ **Network Load Balancer**
1. 选择**添加侦听器**。
1. 在 **Network Load Balancer listener (Network Load Balancer 侦听器)** 对话框中，对于 **Port (端口)**，请键入传入流量端口，通常为 `443`。
1. 选择**添加**。
1. 要保存更改，请选择页面底部的 **Apply**（应用）。
## 使用配置文件配置安全侦听器
您可以使用以下[配置文件](ebextensions.md)之一在负载均衡器上配置安全侦听器。
**Example .ebextensions/securelistener-clb.config**
当您的环境具有经典负载均衡器时，请使用此示例。该示例使用 `aws:elb:listener` 命名空间中的选项通过指定的证书在端口 443 上配置 HTTPS 侦听器，并将解密的流量转发到端口 80 上的环境实例。
```
option_settings:
aws:elb:listener:443:
SSLCertificateId: arn:aws:acm:us-east-2:1234567890123:certificate/####################################
ListenerProtocol: HTTPS
InstancePort: 80
```
将突出显示的文本替换为您的证书的 ARN。该证书可以是您在 AWS Certificate Manager (ACM) 中创建或上传的证书（首选），也可以是您使用上传到 IAM 的 AWS CLI证书。
有关经典负载均衡器配置选项的更多信息，请参阅[经典负载均衡器配置命名空间](environments-cfg-clb.md#environments-cfg-clb-namespace)。
**Example .ebextensions/securelistener-alb.config**
当您的环境具有 Application Load Balancer 时，请使用此示例。该示例使用 `aws:elbv2:listener` 命名空间中的选项通过指定的证书在端口 443 上配置 HTTPS 侦听器。该侦听器将流量路由到默认进程。
```
option_settings:
aws:elbv2:listener:443:
ListenerEnabled: 'true'
Protocol: HTTPS
SSLCertificateArns: arn:aws:acm:us-east-2:1234567890123:certificate/####################################
```
**Example .ebextensions/securelistener-nlb.config**
当您的环境具有 Network Load Balancer 时，请使用此示例。该示例使用 `aws:elbv2:listener` 命名空间中的选项在端口 443 上配置侦听器。该侦听器将流量路由到默认进程。
```
option_settings:
aws:elbv2:listener:443:
ListenerEnabled: 'true'
```
## 配置安全组
如果将负载均衡器配置为将流量转发到除端口 80 外的实例端口，则必须向安全组添加一个规则来允许来自负载均衡器的入站流量通过该实例端口。如果您在自定义 VPC 中创建环境，则 Elastic Beanstalk 会为您添加此规则。
您可以在 `.ebextensions` 目录的[配置文件](ebextensions.md)中为您的应用程序添加 `Resources` 键，从而添加此规则。
以下示例配置文件添加传入规则到 `AWSEBSecurityGroup` 安全组。这样将允许端口 1000 上来自负载均衡器安全组的流量。
**Example .ebextensions/sg-ingressfromlb.config**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 1000
FromPort: 1000
SourceSecurityGroupId: {"Fn::GetAtt" : ["AWSEBLoadBalancerSecurityGroup", "GroupId"]}
```
# 在实例上配置 HTTPS 终止
您可使用[配置文件](ebextensions.md)配置将流量传递至应用程序的代理服务器，使其终止 HTTPS 连接。如果您希望在单一实例环境中使用 HTTPS，或如果您配置负载均衡器为传递流量而无需解密，这种方式将会十分有用。
要启用 HTTPS，您必须允许端口 443 上的传入流量流向运行 Elastic Beanstalk 应用程序的 EC2 实例。为此，您可以使用配置文件中的`Resources`密钥将端口 443 的规则添加到 AWSEBSecurity组安全组的入口规则中。
以下代码段将传入规则添加到 `AWSEBSecurityGroup` 安全组，该安全组为单一实例环境的所有流量打开端口 443。
**`.ebextensions/https-instance-securitygroup.config`**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
在默认 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) 的负载均衡环境中，您可以将此策略修改为仅接受来自负载均衡器的流量。有关示例，请参阅 [在负载均衡的 Elastic Beanstalk 环境中配置 end-to-end加密](configuring-https-endtoend.md)。
**Topics**
+ [在运行 Docker 的 EC2 实例上终止 HTTPS](https-singleinstance-docker.md)
+ [在运行 Go 的 EC2 实例上终止 HTTPS](https-singleinstance-go.md)
+ [终止运行 Java SE 的 EC2 实例上的 HTTPS](https-singleinstance-java.md)
+ [在运行 Node.js 的 EC2 实例上终止 HTTPS](https-singleinstance-nodejs.md)
+ [在运行 PHP 的 EC2 实例上终止 HTTPS](https-singleinstance-php.md)
+ [在运行 Python 的 EC2 实例上终止 HTTPS](https-singleinstance-python.md)
+ [在运行 Ruby 的 EC2 实例上终止 HTTPS](https-singleinstance-ruby.md)
+ [在运行 Tomcat 的 EC2 实例上终止 HTTPS](https-singleinstance-tomcat.md)
+ [在运行 .NET Core on Linux 的 Amazon EC2 实例上终止 HTTPS](https-singleinstance-dotnet-linux.md)
+ [在运行.NET 的亚马逊 EC2 实例上终止 HTTPS](SSLNET.SingleInstance.md)
# 在运行 Docker 的 EC2 实例上终止 HTTPS
对于 Docker 容器，您使用[配置文件](ebextensions.md)启用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/nginx/conf.d/https.conf`
配置 nginx 服务器。nginx 服务启动时加载此文件。
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
mode: "000644"
owner: root
group: root
content: |
# HTTPS Server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://docker;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 Go 的 EC2 实例上终止 HTTPS
对于 Go 容器类型，您可以使用[配置文件](ebextensions.md)和 nginx 配置文件（用于将 nginx 服务器配置为使用 HTTPS）来启用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `Resources` 密钥在您的环境实例使用的安全组上启用端口 443。
+ `files` 密钥在实例上创建以下文件：
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
将以下内容放置在源包的 `.conf` 目录内扩展名为 `.ebextensions/nginx/conf.d/` 的文件中 (例如 `.ebextensions/nginx/conf.d/https.conf`)。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 Go 平台上的这些配置文件的更多信息，请参阅 [配置代理服务器](go-nginx.md)。
**Example 。 ebextensions/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 终止运行 Java SE 的 EC2 实例上的 HTTPS
对于 Java SE 容器类型，您可使用 .ebextensions [配置文件](ebextensions.md)和 nginx 配置文件（用于将 nginx 服务器配置为使用 HTTPS）来启用 HTTPS。
所有 AL2023/AL2 平台都支持统一的代理配置功能。有关在运行 AL2023 /的平台版本上配置代理服务器的更多信息AL2，请参阅[反向代理配置](platforms-linux-extend.proxy.md)。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
将以下内容放置在源包的 `.conf` 目录内扩展名为 `.ebextensions/nginx/conf.d/` 的文件中 (例如 `.ebextensions/nginx/conf.d/https.conf`)。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 Java SE 平台上的这些配置文件的更多信息，请参阅 [配置代理服务器](java-se-nginx.md)。
**Example 。 ebextensions/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 Node.js 的 EC2 实例上终止 HTTPS
以下示例配置文件[扩展了默认 nginx](nodejs-platform-proxy.md) 配置，使其监听端口 443 并 SSL/TLS 终止使用公有证书和私钥的连接。
如果已为[增强型运行状况报告](health-enhanced.md)配置环境，则需要配置 nginx 以生成访问日志。为此，通过删除前导 `# For enhanced health...` 字符，在显示为 `#` 的注释下方取消对行块的注释。
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
mode: "000644"
owner: root
group: root
content: |
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
# For enhanced health reporting support, uncomment this block:
#if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
# set $year $1;
# set $month $2;
# set $day $3;
# set $hour $4;
#}
#access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
#access_log /var/log/nginx/access.log main;
location / {
proxy_pass http://nodejs;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
`files` 密钥在实例上创建以下文件：
`/etc/nginx/conf.d/https.conf`
配置 nginx 服务器。nginx 服务启动时加载此文件。
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 PHP 的 EC2 实例上终止 HTTPS
对于 PHP 容器类型，您可使用[配置文件](ebextensions.md)来允许 Apache HTTP Server 使用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。
该配置文件执行以下任务：
+ `packages` 密钥使用 yum 安装 `mod24_ssl`。
+ `files` 密钥在实例上创建以下文件：
`/etc/httpd/conf.d/ssl.conf`
配置 Apache 服务器。此文件在 Apache 服务启动时加载。
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
packages:
yum:
mod24_ssl : []
files:
/etc/httpd/conf.d/ssl.conf:
mode: "000644"
owner: root
group: root
content: |
LoadModule ssl_module modules/mod_ssl.so
Listen 443
Order deny,allow
Allow from all
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3
SSLHonorCipherOrder On
SSLSessionTickets Off
Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload"
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
ProxyPass / http://localhost:80/ retry=0
ProxyPassReverse / http://localhost:80/
ProxyPreserveHost on
RequestHeader set X-Forwarded-Proto "https" early
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 Python 的 EC2 实例上终止 HTTPS
对于使用 Apache HTTP Server 和 Web Server Gateway Interface (WSGI) 的 Python 容器类型，您可使用[配置文件](ebextensions.md)来允许 Apache HTTP Server 使用 HTTPS。
将以下代码段添加到您的[配置文件](ebextensions.md)中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `packages` 密钥使用 yum 安装 `mod_ssl`。
+ `files` 密钥在实例上创建以下文件：
`/etc/httpd/conf.d/ssl.conf`
配置 Apache 服务器。如果您的应用程序的名称不是 `application.py`，请将 `WSGIScriptAlias` 的值中突出显示的文本替换为您的应用程序的本地路径。例如，django 应用程序的路径可能是 `django/wsgi.py`。此位置应与您为环境设置的 `WSGIPath` 选项值相符。
根据您的应用程序的要求，您可能还需要向 **python-path** 参数添加其他目录。
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
+ `container_commands` 密钥在一切配置完成后停止 httpd 服务，以便该服务使用新的 `https.conf` 文件和证书。
**注意**
该示例仅可用于使用 [Python](create-deploy-python-container.md) 平台的环境。
**Example .ebextensions/https-instance.config**
```
packages:
yum:
mod_ssl: []
files:
/etc/httpd/conf.d/ssl.conf:
mode: "000644"
owner: root
group: root
content: |
LoadModule wsgi_module modules/mod_wsgi.so
WSGIPythonHome /var/app/venv/staging-LQM1lest
WSGISocketPrefix run/wsgi
WSGIRestrictEmbedded On
Listen 443
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
Alias /static/ /var/app/current/static/
Order allow,deny
Allow from all
WSGIScriptAlias / /var/app/current/application.py
Require all granted
WSGIDaemonProcess wsgi-ssl processes=1 threads=15 display-name=%{GROUP} \
python-path=/var/app/current \
python-home=/var/app/venv/staging-LQM1lest \
home=/var/app/current \
user=webapp \
group=webapp
WSGIProcessGroup wsgi-ssl
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
container_commands:
01killhttpd:
command: "killall httpd"
02waitforhttpddeath:
command: "sleep 3"
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
**Amazon Linux 2023 环境注意事项**
在 Amazon Linux 2023 上，必须单独安装 `mod_wsgi`，因为它在软件包存储库中不可用。有关安装说明，请参阅 PyPI 上的 [mod\$1wsgi](https://pypi.org/project/mod-wsgi/)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 Ruby 的 EC2 实例上终止 HTTPS
对于 Ruby 容器类型，启用 HTTPS 的方式取决于所用应用程序服务器的类型。
**Topics**
+ [为使用 Puma 的 Ruby 配置 HTTPS](#Puma)
+ [为使用 Passenger 的 Ruby 配置 HTTPS](#Passenger)
## 为使用 Puma 的 Ruby 配置 HTTPS
对于使用 Puma 作为应用程序服务器的 Ruby 容器类型，您可使用[配置文件](ebextensions.md)启用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/nginx/conf.d/https.conf`
配置 nginx 服务器。nginx 服务启动时加载此文件。
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
files:
/etc/nginx/conf.d/https.conf:
content: |
# HTTPS server
server {
listen 443;
server_name localhost;
ssl on;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://my_app;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
location /assets {
alias /var/app/current/public/assets;
gzip_static on;
gzip on;
expires max;
add_header Cache-Control public;
}
location /public {
alias /var/app/current/public;
gzip_static on;
gzip on;
expires max;
add_header Cache-Control public;
}
}
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
## 为使用 Passenger 的 Ruby 配置 HTTPS
对于使用 Passenger 作为应用程序服务器的 Ruby 容器类型，您可同时使用配置文件和 JSON 文件启用 HTTPS。
**为使用 Passenger 的 Ruby 配置 HTTPS**
1. 将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example 用于为使用 Passenger 的 Ruby 配置 HTTPS 的 .Ebextensions 代码段**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
1. 创建一个文本文件并将以下 JSON 添加到该文件。将该文件保存在源包的名为 `passenger-standalone.json` 的根目录中。此 JSON 文件将 Passenger 配置为使用 HTTPS。
**重要**
此 JSON 文件不得包含字节顺序标记 (BOM)。如果此文件包含字节顺序标记，则 Passenger JSON 库将不会正确读取此文件，并且 Passenger 服务将不会启动。
**Example passenger-standalone.json**
```
{
"ssl" : true,
"ssl_port" : 443,
"ssl_certificate" : "/etc/pki/tls/certs/server.crt",
"ssl_certificate_key" : "/etc/pki/tls/certs/server.key"
}
```
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 Tomcat 的 EC2 实例上终止 HTTPS
对于 Tomcat 容器类型，您可使用[配置文件](ebextensions.md)来允许 HTTP Server 在充当 Tomcat 的反向代理时使用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
`/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh`
创建部署后挂钩脚本以重新启动 httpd 服务。
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh:
mode: "000755"
owner: root
group: root
content: |
#!/usr/bin/env bash
sudo service httpd restart
```
您还必须将环境的代理服务器配置为在端口 443 上进行侦听。以下 Apache 2.4 配置将在端口 443 上添加一个侦听器。要了解更多信息，请参阅[配置代理服务器](java-tomcat-proxy.md)。
**Example 。 ebextensions/httpd/conf.d/ssl.conf**
```
Listen 443
ServerName server-name
SSLEngine on
SSLCertificateFile "/etc/pki/tls/certs/server.crt"
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
Require all granted
ProxyPass / http://localhost:8080/ retry=0
ProxyPassReverse / http://localhost:8080/
ProxyPreserveHost on
ErrorLog /var/log/httpd/elasticbeanstalk-ssl-error_log
```
您的证书供应商可能包含中间证书，可安装此证书以提高与移动客户端的兼容性。使用中间证书颁发机构 (CA) 捆绑配置 Apache，方法是将以下内容添加到您的 SSL 配置文件 (如需了解位置，请参阅[扩展并覆盖默认 Apache 配置 — 亚马逊 Linux AMI () AL1](java-tomcat-proxy.md#java-tomcat-proxy-apache))：
+ 在 `ssl.conf` 文件内容中，指定链文件：
```
SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
SSLCertificateChainFile "/etc/pki/tls/certs/gd_bundle.crt"
SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
```
+ 使用中间证书的内容向 `files` 密钥添加新条目：
```
files:
/etc/pki/tls/certs/gd_bundle.crt:
mode: "000400"
owner: root
group: root
content: |
-----BEGIN CERTIFICATE-----
First intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
Second intermediate certificate
-----END CERTIFICATE-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行 .NET Core on Linux 的 Amazon EC2 实例上终止 HTTPS
对于 .NET Core on Linux 容器类型，您可以使用 `.ebextensions`[配置文件](ebextensions.md)和 nginx 配置文件（用于配置 nginx 服务器以使用 HTTPS）来启用 HTTPS。
将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：
`/etc/pki/tls/certs/server.crt`
在实例上创建证书文件。*certificate file contents*替换为证书的内容。
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：
```
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
first intermediate certificate
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
second intermediate certificate
-----END CERTIFICATE-----
```
`/etc/pki/tls/certs/server.key`
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
**Example .ebextensions/https-instance.config**
```
files:
/etc/pki/tls/certs/server.crt:
content: |
-----BEGIN CERTIFICATE-----
certificate file contents
-----END CERTIFICATE-----
/etc/pki/tls/certs/server.key:
content: |
-----BEGIN RSA PRIVATE KEY-----
private key contents # See note below.
-----END RSA PRIVATE KEY-----
```
**注意**
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。
将以下内容放置在源代码包的 `.platform/nginx/conf.d/` 目录内扩展名为 `.conf` 的文件中（例如 `.platform/nginx/conf.d/https.conf`）。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 .NET Core on Linux 平台上的这些配置文件的更多信息，请参阅[配置代理服务器](dotnet-linux-platform-nginx.md)。
**Example 。 platform/nginx/conf.d/https.conf**
```
# HTTPS server
server {
listen 443 ssl;
server_name localhost;
ssl_certificate /etc/pki/tls/certs/server.crt;
ssl_certificate_key /etc/pki/tls/certs/server.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_pass http://localhost:app_port;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
}
}
```
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在运行.NET 的亚马逊 EC2 实例上终止 HTTPS
以下[配置文件](ebextensions.md)创建并运行用于执行以下任务的 Windows PowerShell 脚本：
+ 检查现有 HTTPS 证书是否已绑定到端口 443。
+ 从 Amazon S3 存储桶获取 [PFX 证书](configuring-https-ssl.md)。
**注意**
向 `aws-elasticbeanstalk-ec2-role` 添加 `AmazonS3ReadOnlyAccess` 策略，以访问 Amazon S3 存储桶中的 SSL 证书。
+ 从中获取密码 AWS Secrets Manager。
**注意**
在 `aws-elasticbeanstalk-ec2-role` 中添加一条语句，以允许对包含证书密码的密钥执行 `secretsmanager:GetSecretValue` 操作
+ 安装证书。
+ 将证书绑定到端口 443。
**注意**
要删除 HTTP 终端节点（端口 80），请在示例的**删除 HTTP 绑定** 部分中包括 `Remove-WebBinding` 命令。
**Example .ebextensions/ .config https-instance-dotnet**
```
files:
"C:\\certs\\install-cert.ps1":
content: |
import-module webadministration
## Settings - replace the following values with your own
$bucket = "amzn-s3-demo-bucket" ## S3 bucket name
$certkey = "example.com.pfx" ## S3 object key for your PFX certificate
$secretname = "example_secret" ## AWS Secrets Manager name for a secret that contains the certificate's password
##
# Set variables
$certfile = "C:\cert.pfx"
$pwd = Get-SECSecretValue -SecretId $secretname | select -expand SecretString
# Clean up existing binding
if ( Get-WebBinding "Default Web Site" -Port 443 ) {
Echo "Removing WebBinding"
Remove-WebBinding -Name "Default Web Site" -BindingInformation *:443:
}
if ( Get-Item -path IIS:\SslBindings\0.0.0.0!443 ) {
Echo "Deregistering WebBinding from IIS"
Remove-Item -path IIS:\SslBindings\0.0.0.0!443
}
# Download certificate from S3
Read-S3Object -BucketName $bucket -Key $certkey -File $certfile
# Install certificate
Echo "Installing cert..."
$securepwd = ConvertTo-SecureString -String $pwd -Force -AsPlainText
$cert = Import-PfxCertificate -FilePath $certfile cert:\localMachine\my -Password $securepwd
# Create site binding
Echo "Creating and registering WebBinding"
New-WebBinding -Name "Default Web Site" -IP "*" -Port 443 -Protocol https
New-Item -path IIS:\SslBindings\0.0.0.0!443 -value $cert -Force
## Remove the HTTP binding
## (optional) Uncomment the following line to unbind port 80
# Remove-WebBinding -Name "Default Web Site" -BindingInformation *:80:
##
# Update firewall
netsh advfirewall firewall add rule name="Open port 443" protocol=TCP localport=443 action=allow dir=OUT
commands:
00_install_ssl:
command: powershell -NoProfile -ExecutionPolicy Bypass -file C:\\certs\\install-cert.ps1
```
在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。
**Example .ebextensions/ .config https-instance-single**
```
Resources:
sslSecurityGroupIngress:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
CidrIp: 0.0.0.0/0
```
对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end
# 在负载均衡的 Elastic Beanstalk 环境中配置 end-to-end加密
终止负载均衡器的安全连接并在后端上使用 HTTP 可能对应用程序已经足够。即使在同一账户下运行， AWS 资源之间的网络流量也不会被不属于连接的实例侦听。
但是，如果您正在开发需要遵守严格外部规定的应用程序，则可能需要保护所有网络连接。您可以使用 Elastic Beanstalk 控制台或[配置文件](ebextensions.md)，将 Elastic Beanstalk 环境的负载均衡器安全地连接到后端实例以满足这些要求。以下过程将重点放在配置文件上。
首先，[在负载均衡器中添加一个安全侦听器](configuring-https-elb.md)（如果尚未添加）。
您还必须配置环境中的实例，以侦听安全端口并终止 HTTPS 连接。此配置根据不同平台而有所变化。有关说明，请参阅[在实例上配置 HTTPS 终止](https-singleinstance.md)：您可以毫无问题地为 EC2 实例使用[自签名证书](configuring-https-ssl.md)。
接下来，配置侦听器在应用程序使用的端口上使用 HTTPS 转发流量。根据您的环境使用的负载均衡器类型，使用以下配置文件之一。
**`.ebextensions/https-reencrypt-clb.config`**
将此配置文件与经典负载均衡器配合使用。除了配置负载均衡器以外，该配置文件还更改默认运行状况检查以使用端口 443 和 HTTPS，以确保负载均衡器可以安全地进行连接。
```
option_settings:
aws:elb:listener:443:
InstancePort: 443
InstanceProtocol: HTTPS
aws:elasticbeanstalk:application:
Application Healthcheck URL: HTTPS:443/
```
**`.ebextensions/https-reencrypt-alb.config`**
将此配置文件与 Application Load Balancer 配合使用。
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
Protocol: HTTPS
aws:elasticbeanstalk:environment:process:https:
Port: '443'
Protocol: HTTPS
```
**`.ebextensions/https-reencrypt-nlb.config`**
将此配置文件与 Network Load Balancer 配合使用。
```
option_settings:
aws:elbv2:listener:443:
DefaultProcess: https
ListenerEnabled: 'true'
aws:elasticbeanstalk:environment:process:https:
Port: '443'
```
`DefaultProcess` 选项以此方式命名是因为 Application Load Balancer，它可能在同一端口上具有非默认侦听器，以用于侦听到特定路径的流量（如需详细信息，请参阅 [应用程序负载均衡器](environments-cfg-alb.md)）。对于 Network Load Balancer，该选项为该侦听器指定唯一的目标进程。
在此示例中，我们将进程命名为 `https`，因为它侦听安全 (HTTPS) 流量。由于 Network Load Balancer 只能使用 TCP，因此该侦听器使用 TCP 协议将流量发送到指定端口上的进程。由于 HTTP 和 HTTPS 网络流量是在 TCP 上实施的，因此，可以这样做。
**注意**
EB CLI 和 Elastic Beanstalk 控制台会对前面的选项应用建议的值。如果您需要使用配置文件来配置相同的项，则必须删除这些设置。有关更多信息，请参阅 [建议值](command-options.md#configuration-options-recommendedvalues)。
在下一个任务中，您需要将负载均衡器的安全组修改为允许流量。根据您启动环境所在的 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC)（默认 VPC 或自定义 VPC），负载均衡器的安全组将有所不同。在默认 VPC 中，Elastic Load Balancing 提供可供所有负载均衡器使用的默认安全组。在您创建的 Amazon VPC 中，Elastic Beanstalk 会创建一个安全组供负载均衡器使用。
为了同时支持两种方案，您可创建一个安全组并告知 Elastic Beanstalk 使用该安全组。以下配置文件创建安全组并将其连接到负载均衡器。
**`.ebextensions/https-lbsecuritygroup.config`**
```
option_settings:
# Use the custom security group for the load balancer
aws:elb:loadbalancer:
SecurityGroups: '`{ "Ref" : "loadbalancersg" }`'
ManagedSecurityGroup: '`{ "Ref" : "loadbalancersg" }`'
Resources:
loadbalancersg:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: load balancer security group
VpcId: vpc-########
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 443
ToPort: 443
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
SecurityGroupEgress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
```
用默认或自定义 VPC ID 替换突出显示的文本。上述示例包括通过端口 80 的入口和出口，以允许 HTTP 连接。如果您只想要允许安全连接，则可删除这些属性。
最后，添加允许在负载均衡器的安全组和实例的安全组之间通过端口 443 进行通信的入口和出口规则。
**`.ebextensions/https-backendsecurity.config`**
```
Resources:
# Add 443-inbound to instance security group (AWSEBSecurityGroup)
httpsFromLoadBalancerSG:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
SourceSecurityGroupId: {"Fn::GetAtt" : ["loadbalancersg", "GroupId"]}
# Add 443-outbound to load balancer security group (loadbalancersg)
httpsToBackendInstances:
Type: AWS::EC2::SecurityGroupEgress
Properties:
GroupId: {"Fn::GetAtt" : ["loadbalancersg", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
DestinationSecurityGroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
```
与创建安全组分离执行这一步骤允许您限制源位置和目标位置安全组，而无需创建循环依赖项。
完成以上所有任务后，负载均衡器可使用 HTTPS 安全地连接至后端实例。负载均衡器不关心实例证书为自签名还有由可信赖的证书颁发机构颁发，并将接受向它提交的任何证书。
您可为负载均衡器添加策略，告知它只可信任某个特定证书，从而更改此行为。以下配置文件创建两个策略。一个策略指定公有证书，另一个策略则告知负载均衡器只可为实例端口 443 的连接信任该证书。
**`.ebextensions/https-backendauth.config`**
```
option_settings:
# Backend Encryption Policy
aws:elb:policies:backendencryption:
PublicKeyPolicyNames: backendkey
InstancePorts: 443
# Public Key Policy
aws:elb:policies:backendkey:
PublicKey: |
-----BEGIN CERTIFICATE-----
################################################################
################################################################
################################################################
################################################################
################################################
-----END CERTIFICATE-----
```
将突出显示的文本替换为您的 EC2 实例的公共证书的内容。
# 为 TCP 传递配置环境的负载均衡器
如果您不希望 AWS Elastic Beanstalk 环境中的负载均衡器解密 HTTPS 流量，则可以将安全侦听器配置为按原样将请求中继到后端实例。
**重要**
将负载均衡器配置为中继 HTTPS 流量而不解密存在一个缺点。负载均衡器无法看到加密的请求，因此无法优化路由或报告响应指标。
首先[将您的环境 EC2 实例配置为终止 HTTPS](https-singleinstance.md)。在为组合添加负载均衡器之前，在单一实例环境中测试配置，以确保一切正常运行。
将[配置文件](ebextensions.md)添加到您的项目，以便在端口 443 上配置监听器，该端口将 TCP 包原样传递至后端实例上的端口 443：
**`.ebextensions/https-lb-passthrough.config`**
```
option_settings:
aws:elb:listener:443:
ListenerProtocol: TCP
InstancePort: 443
InstanceProtocol: TCP
```
在默认的 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) 中，您还需要向实例的安全组添加规则，以允许端口 443 上来自负载均衡器的入站流量：
**`.ebextensions/https-instance-securitygroup.config`**
```
Resources:
443inboundfromloadbalancer:
Type: AWS::EC2::SecurityGroupIngress
Properties:
GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
IpProtocol: tcp
ToPort: 443
FromPort: 443
SourceSecurityGroupName: { "Fn::GetAtt": ["AWSEBLoadBalancer", "SourceSecurityGroup.GroupName"] }
```
在自定义 VPC 中，Elastic Beanstalk 会为您更新安全组配置。
# 配置 HTTP 到 HTTPS 重定向
本主题介绍如何在最终用户仍在启动应用程序时处理到该应用程序的 HTTP 流量。为此，您需要配置 *HTTP to HTTPS redirection (HTTP 到 HTTPS 重定向)*，有时也称为*强制 HTTPS*。
要配置重定向，您首先将环境配置为处理 HTTPS 流量。然后，您可以将 HTTP 流量重定向到 HTTPS。下面的小节将讨论这两个步骤。
## 配置您的环境以处理 HTTPS 流量
根据环境的负载均衡配置，执行以下操作之一：
+ **负载均衡环境** – [配置负载均衡器以终止 HTTPS](configuring-https-elb.md)。
+ **单实例环境** – [配置您的应用程序以终止实例中的 HTTPS 连接](https-singleinstance.md)。此配置取决于您环境的平台。
## 将 HTTP 流量重定向到 HTTPS
要将应用程序的 HTTP 流量重定向到 HTTPS，您可以配置环境实例上的 Web 服务器，也可以配置环境的应用程序负载均衡器。
**配置实例 Web 服务器**
此方法适用于任何 Web 服务器环境。在您的 Amazon EC2 实例上配置网络服务器，使其以 HTTP 重定向响应状态响应 HTTP 流量。
此配置取决于您环境的平台。在上的[https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect](https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect)集合中找到适用于您平台的文件夹 GitHub，然后使用该文件夹中的示例配置文件。
如果您的环境使用 [Elastic Load Balancing 运行状况检查](using-features.healthstatus.md#using-features.healthstatus.understanding)，负载均衡器需要运行状况良好的实例用 HTTP 200 (OK) 响应来响应 HTTP 运行状况检查消息。因此，您的 Web 服务器不应将这些消息重定向到 HTTPS。[https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect](https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect) 中的示例配置文件可正确处理这一需求。
**配置负载均衡器**
如果您拥有使用[应用程序负载均衡器](environments-cfg-alb.md)的负载均衡环境，则此方法有效。当 HTTP 流量进入时，应用程序负载均衡器可以发送重定向响应。在这种情况下，不需要在您环境的实例上配置重定向。
我们有两个示例配置文件 GitHub ，它们显示了如何配置 Application Load Balancer 以进行重定向。
+ [https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection-full.config](https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection-full.config) 配置文件在端口 443 上创建 HTTPS 侦听器，并修改默认端口 80 侦听器以将传入的 HTTP 流量重定向到 HTTPS。
+ [https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection.config](https://github.com/awsdocs/elastic-beanstalk-samples/blob/master/configuration-files/aws-provided/resource-configuration/alb-http-to-https-redirection.config) 配置文件需要定义 443 侦听器。要定义它，您可以使用标准 Elastic Beanstalk 配置命名空间或 Elastic Beanstalk 控制台。然后，它负责修改端口 80 侦听器以便执行重定向。