# EC2 实例集和竞价型实例集
EC2 实例集和竞价型实例集非常实用，可在单次操作中启动几十、几百或几千个 Amazon EC2 实例的实例集。实例集中的每个实例由[启动模板](ec2-launch-templates.md)或您在启动时手动配置的启动参数集配置。
**Topics**
+ [
## 功能和优势
](#ec2-fleet-features-and-benefits)
+ [
# 哪种是实例集最佳使用方法？
](which-fleet-method-to-use.md)
+ [
# EC2 实例集或竞价型实例集配置选项
](ec2-fleet-configuration-strategies.md)
+ [
# 使用 EC2 实例集
](manage-ec2-fleet.md)
+ [
# 使用竞价型实例集
](work-with-spot-fleets.md)
+ [
# 监控 EC2 实例集或竞价型实例集
](fleet-monitor.md)
+ [
# EC2 实例集的教程
](fleet-tutorials.md)
+ [
# EC2 实例集 CLI 配置示例
](ec2-fleet-examples.md)
+ [
# 竞价型实例集 CLI 配置示例
](spot-fleet-examples.md)
+ [
# EC2 实例集和竞价型实例集的限额
](fleet-quotas.md)
## 功能和优势
实例集提供以下功能和优势，让您能够在多个 EC2 实例上运行应用程序时，最大限度地节省成本并优化可用性和性能。
**多种实例类型**
一个实例集可以启动多种实例类型，避免依赖一种实例类型的可用性。这可以提高实例集中实例的总体可用性。
**在可用区之间分配实例**
一个实例集可以启动到多个可用区，从而使您能够降低成本并提高可用性。如果您的实例集包含竞价型实例，则实例集会根据您对价格和中断的偏好自动选择可用区。
**多种购买选项**
一个实例集可以启动多种购买选项（竞价型实例和按需型实例），以便让您通过竞价型实例的使用来优化成本。您还可以将预留实例和节省计划折扣与实例集中的按需型实例结合使用，从而享受这些折扣。
**自动替换竞价型实例**
如果实例集包含竞价型实例，则当竞价型实例中断时，可以自动请求替换竞价型容量。通过[容量再平衡](ec2-fleet-capacity-rebalance.md)功能，实例集还可以监控和主动替换中断风险较高的竞价型实例。
**预留按需型容量**
实例集可以使用[按需容量预留](ec2-fleet-on-demand-capacity-reservations.md)来预留按需型容量。实例集还可以包含[适用于机器学习的容量块](ec2-capacity-blocks.md)，让您能在未来某个日期预留 GPU 实例，从而支持短期机器学习（ML）工作负载。
# 哪种是实例集最佳使用方法？
作为一般最佳实践，我们建议使用 Amazon EC2 Auto Scaling 启动竞价型实例和按需型实例实例集，因为其能够提供可用于管理实例集的其他功能。其他功能列表包括竞价型实例和按需型实例的自动运行状况检查替换、基于应用程序的运行状况检查，以及与弹性负载均衡器的集成，可确保将应用程序流量均匀分配到运行正常的实例。在使用 Amazon ECS、Amazon EKS（自管理式节点组）和 Amazon VPC Lattice 等 AWS 服务时，也可以使用自动扩缩组。有关更多信息，请参阅 [Amazon EC2 Auto Scaling 用户指南](https://docs.aws.amazon.com/autoscaling/ec2/userguide/)。
如果您无法使用 Amazon EC2 Auto Scaling，则可以考虑使用 EC2 实例集或竞价型实例集。EC2 实例集和竞价型实例集提供相同的核心功能。不过，EC2 实例集仅可通过命令行使用，不提供控制台支持。竞价型实例集提供控制台支持，但其基于不具有计划投资的旧式 API。
使用下表来确定要使用哪种实例集方法。
****
| 实例集方法 | 何时使用？ | 使用案例 |
| --- | --- | --- |
| [Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/what-is-amazon-ec2-auto-scaling.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AWSEC2/latest/UserGuide/which-fleet-method-to-use.html) | 创建一个 Auto Scaling 组，以管理实例的生命周期，同时保持所需的实例数量。支持在指定的最小和最大限值之间的水平扩展（添加更多实例）。 |
| [EC2 Fleet](manage-ec2-fleet.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AWSEC2/latest/UserGuide/which-fleet-method-to-use.html) | 在单次操作中创建一个由按需型实例和竞价型实例组成的 `instant` 实例集，并具有多个因实例类型、AMI、可用区或子网而异的启动规范。竞价型实例分配策略默认按单位计算 `lowest-price`，但建议将其改为 `price-capacity-optimized`。 |
| [竞价型实例集](work-with-spot-fleets.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AWSEC2/latest/UserGuide/which-fleet-method-to-use.html) | 仅在使用 EC2 实例集的用例中需要控制台支持时，才使用竞价型实例集。 |
# EC2 实例集或竞价型实例集配置选项
规划 EC2 实例集或竞价型实例集时，建议在决定如何配置实例集时考虑以下选项。
****
| 配置选项 | 问题 | 文档 |
| --- | --- | --- |
| 实例集请求类型 | 您想要提交对所需目标容量的一次性请求的实例集，还是随着时间推移维持目标容量的实例集？ | [EC2 实例集和竞价型实例集请求类型](ec2-fleet-request-type.md) |
| 竞价型实例 | 您是否计划在实例集中包含竞价型实例？ 查看竞价型实例的最佳实践，使用这些最佳实践规划您的实例集，以便以可能的最低价预置实例。 | [Amazon EC2 竞价型实例的最佳实践](spot-best-practices.md) |
| 实例集的支出限额 | 您是否想限制每小时为实例集支付的费用？ | [为 EC2 实例集或竞价型实例集设置支出限额](ec2-fleet-control-spending.md) |
| 实例类型和基于属性的实例类型选择 | 您想要在实例集中指定实例类型，还是让 Amazon EC2 选择符合应用程序要求的实例类型？ | [指定 EC2 实例集或竞价型实例集的实例类型选择属性](ec2-fleet-attribute-based-instance-type-selection.md) |
| 实例权重 | 您是否想为每种实例类型分配权重来表示其计算容量和性能，以便 Amazon EC2 可以选择任何可用实例类型的组合来满足所需的目标容量？ | [使用实例权重来管理 EC2 实例集或竞价型实例集的成本和性能](ec2-fleet-instance-weighting.md) |
| 分配策略 | 您是否想决定是否针对可用容量、价格或实例类型进行优化，以便用于实例集中的竞价型实例和按需型实例？ | [使用分配策略确定 EC2 实例集或竞价型实例集如何满足竞价型和按需型容量](ec2-fleet-allocation-strategy.md) |
| 容量再平衡 | 您是否想要实例集自动替换存在风险的竞价型实例？ | [在 EC2 实例集和竞价型实例集中使用“容量再平衡”功能来替换存在风险的竞价型实例](ec2-fleet-capacity-rebalance.md) |
| 按需容量预留 | 您是否想为实例集中的按需型实例预留容量？ | [使用容量预留来预留 EC2 实例集中的按需型容量](ec2-fleet-on-demand-capacity-reservations.md) |
# EC2 实例集和竞价型实例集请求类型
EC2 实例集或竞价型实例集的请求类型决定了请求是同步还是异步的，以及是针对所需目标容量发出一次性请求，还是随着时间推移持续努力维持容量。配置实例集时，必须指定请求类型。
EC2 实例集和竞价型实例集都提供两种请求类型：`request` 和 `maintain`。此外，EC2 实例集还提供名为 `instant` 的第三种请求类型。实例集请求类型
`instant`（仅适用于 EC2 实例集）
如果您将请求类型配置为 `instant`，EC2 队列会针对所需容量发出同步一次性请求。在 API 响应中，它返回已启动的实例并为那些无法启动实例提供错误。有关更多信息，请参阅 [配置 instant 类型的 EC2 实例集](instant-fleet.md)。
`request`
如果将请求类型配置为 `request`，则实例集针对所需容量发出异步一次性请求。如果因竞价型实例中断导致容量减少，实例集不会尝试补充竞价型实例，也不会在容量不可用时于其他竞价型容量池中提交请求。在使用控制台创建类型为 `request` 的竞价型实例集时，请清除**保持目标容量**复选框。
`maintain`（默认）
如果将请求类型配置为 `maintain`，实例集会针对所需容量发出异步请求，并自动补充任何中断的竞价型实例来维持容量。在使用控制台创建类型为 `maintain` 的竞价型实例集时，请选中**保持目标容量**复选框
# 配置 instant 类型的 EC2 实例集
*instant* 类型的 EC2 队列是同步一次性请求，该请求只尝试启动所需容量一次。API 响应列出已启动的实例，以及那些无法启动实例的错误。使用 *instant* 类型的 EC2 队列有几个益处，本文会对其进行介绍。本文末尾提供了配置示例。
对于需要仅启动 API 来启动 EC2 实例的工作负载，您可以使用 RunInstances API。但是，通过 RunInstances，您只能启动按需实例或 Spot 实例，但不能在同一请求中启动两者。此外，当您使用 RunInstances 启动 Spot 实例时，您的 Spot 实例请求仅限于一个实例类型和一个可用区。此操作针对单个 Spot 容量池（一组具有相同实例类型和可用区的未使用实例）。如果 Spot 容量池没有足够的 Spot 实例容量来满足您的请求，则 RunInstances 调用将失败。
相比使用 RunInstances 启动 Spot 实例，我们建议您使用具有设为 `instant` 的 `type` 参数的 CreateFleet API，以获得以下益处：
+ **在一个请求中启动按需实例和 Spot 实例。**EC2 队列可以启动按需实例和/或 Spot 实例。如果具有可用的容量，并且您的请求的每小时最高价格超过 Spot 价格，则会满足竞价型实例请求。
+ **提高 Spot 实例的可用性。**通过使用类型为 `instant` 的 EC2 阶段，您可以根据 [Spot 最佳实践](spot-best-practices.md)启动 Spot 实例，获得以下益处：
+ **Spot 最佳实践：灵活地选择实例类型和可用区。**
益处：通过指定多个实例类型和可用区，您可以增加 Spot 容量池的数量。这让 Spot 服务有更好的机会查找和分配所需的 Spot 计算容量。一条很好的经验法则是，对于每种工作负载，灵活地在至少 10 种实例类型之间进行选择，并确保所有可用区配置为在 VPC 中使用。
+ **竞价型实例最佳实践：使用 price-capacity-optimized 分配策略。**
益处：`price-capacity-optimized` 分配策略可从可用性最佳的竞价型实例容量池中识别实例，然后在这些容量池中自动预置价格最低的实例。由于 Spot 实例容量来自于具有最佳容量的池，因此，这会降低在 Amazon EC2 需要回收容量时，将中断 Spot 实例的可能性。
+ **获得更广泛功能集的访问权限。**对于需要仅启动 API 的工作负载，并且您希望管理实例的生命周期，而不是让 EC2 队列为您进行管理，请使用类型为 `instant` 的 EC2 队列，而不是 [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html) API。EC2 队列提供相比 RunInstances 更广泛的功能组，如以下示例所示。对于所有其他工作负载，您应该使用 Amazon EC2 Auto Scaling，因为它为各种工作负载（如 ELB 支持的应用程序、容器化工作负载和队列处理作业）提供了更全面的功能集。
您可以使用类型为 *instant* 的 EC2 实例集在容量块中启动实例。有关更多信息，请参阅 [教程：将 EC2 实例集配置为将实例启动到容量块中](ec2-fleet-launch-instances-capacity-blocks-walkthrough.md)。
Amazon EC2 Auto Scaling 和 Amazon EMR 等 AWS 服务使用类型为 *instant* 的 EC2 队列启动 EC2 实例。
## 类型为 instant 的 EC2 队列的先决条件
有关创建 EC2 实例集的先决条件，请参阅 [EC2 队列先决条件](ec2-fleet-prerequisites.md)。
## instant EC2 队列如何工作
使用类型为 `instant` 的 EC2 队列时，事件序列如下所示：
1. **配置：**将 [CreateFleet](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet.html) 请求类型配置为 `instant`。有关更多信息，请参阅 [创建 EC2 实例集](create-ec2-fleet.md)。请注意，在进行 API 调用之后，您无法修改它。
1. **请求：**当您进行 API 调用时，Amazon EC2 队列会针对所需容量发出同步一次性请求。
1. **响应：**API 响应列出已启动的实例，以及那些无法启动实例的错误。
1. **描述：**您可以描述 EC2 队列、列出与 EC2 队列关联的实例，以及查看 EC2 队列的历史记录。
1. **终止实例：**您可以随时终止实例。
1. **删除实例集请求：**可以手动或自动删除实例集请求：
+ 手动：您可以在实例启动后[删除实例集请求](delete-fleet.md)。
请注意，不支持包含正在运行实例的已删除 `instant` 实例集。当您删除 `instant` 实例集时，Amazon EC2 会自动终止其所有实例。对于具有超过 1000 个实例的 实例集，删除请求可能会失败。如果您的实例集有超过 1000 个实例，请先手动终止大多数实例，留下 1000 个或更少的实例。然后删除实例集，剩余的实例将自动终止。
+ 自动：Amazon EC2 会在以下任一时间后删除实例集请求：
+ 所有实例均已终止。
+ 实例集未能启动任何实例。
## 示例
以下示例显示如何使用类型为 `instant` 的 EC2 队列，以获取不同使用案例。有关使用 EC2 CreateFleet API 参数的更多信息，请参阅 *Amazon EC2 API 引用*中的 [CreateFleet](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet.html)。
**Topics**
+ [
### 示例 1：使用容量优化的分配策略启动 Spot 实例
](#instant-fleet-example-1)
+ [
### 示例 2：使用容量优化分配策略启动单个 Spot 实例
](#instant-fleet-example-2)
+ [
### 示例 3：使用实例权重启动 Spot 实例
](#instant-fleet-example-3)
+ [
### 示例 4：在单个可用区内启动竞价型实例
](#instant-fleet-example-4)
+ [
### 示例 5：在单个可用区内启动单个实例类型的 Spot 实例
](#instant-fleet-example-5)
+ [
### 示例 6：仅当可以启动最小目标容量时才启动 Spot 实例
](#instant-fleet-example-6)
+ [
### 示例 7：仅当可在单个可用区中启动相同实例类型的最低目标容量时，才能启动 Spot 实例
](#instant-fleet-example-7)
+ [
### 示例 8：启动具有多个启动模板的实例
](#instant-fleet-example-8)
+ [
### 示例 9：启动基于按需实例的 Spot 实例
](#instant-fleet-example-9)
+ [
### 示例 10：基于使用容量预留和优先分配策略的按需实例，使用容量优化分配策略启动 Spot 实例
](#instant-fleet-example-10)
+ [
### 示例 11：使用容量优化优先级分配策略启动 Spot 实例
](#instant-fleet-example-11)
+ [
### 示例 12：指定 Systems Manager 参数而非 AMI ID
](#instant-fleet-example-12)
### 示例 1：使用容量优化的分配策略启动 Spot 实例
下面的示例指定了类型为 `instant` 的 EC2 队列中所需的参数：启动模板、目标容量、原定设置购买选项，并启动模板覆盖。
+ 启动模板由其启动模板名称和版本号标识。
+ 12 个启动模板覆盖指定了 4 个不同的实例类型和 3 个不同的子网，每个子网都位于单独的可用区中。每个实例类型和子网组合都定义了 Spot 容量池，从而生成 12 个 Spot 容量池。
+ 队列的目标容量为 20 个实例。
+ 原定设置购买选项为 `spot`，这会导致实例集尝试在 Spot 容量池中启动 20 个 Spot 实例，并为启动的实例数量提供最佳容量。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 2：使用容量优化分配策略启动单个 Spot 实例
您可以通过进行类型为 `instant` 的多个 EC2 队列 API 调用，将 TotalTargetCapacity 设置为 1，以最佳方式一次启动一个 Spot 实例。
下面的示例指定了类型为 instant 的 EC2 队列中所需的参数：启动模板、目标容量、原定设置购买选项和启动模板覆盖。启动模板由其启动模板名称和版本号标识。12 个启动模板覆盖有 4 个不同的实例类型和 3 个不同的子网，每个子网位于单独的可用区域中。实例集的目标容量为 1 个实例，并且原定设置购买选项为 Spot，这导致实例集尝试根据容量优化分配策略，从 12 个 Spot 容量池之一启动 Spot 实例，从最可用的容量池启动 Spot 实例。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 3：使用实例权重启动 Spot 实例
以下示例使用实例权重，这意味着价格是每单位小时价格，而不是每实例小时价格。假定一个工作负载单位需要 15 GB 内存和 4 个 vCPU，每个启动配置列出不同的实例类型和不同的权重，具体取决于实例上可以运行的工作负载单位数。例如，m5.xlarge（4 个 vCPU 和 16 GB 内存）可以运行 1 个单位且权重为 1，m5.2xlarge（8 个 vCPUs 和 32 GB 内存）可以运行 2 个单位，且权重为 2，依此类推。总目标容量设置为 40 个单位。原定设置购买选项为 Spot，并且分配策略为容量优化，这会导致 40 个 m5.xlarge（40 除以 1），20 个 m5.2xlarge（40 除以 2），10 个 m5.4xlarge（40 除以 4），5 个 m5.8xlarge（40 除以 8），或基于容量优化分配策略，权重相加达到所需容量的实例类型的混合。
有关更多信息，请参阅 [使用实例权重来管理 EC2 实例集或竞价型实例集的成本和性能](ec2-fleet-instance-weighting.md)。
```
{
"SpotOptions":{
"AllocationStrategy":"capacity-optimized"
},
"LaunchTemplateConfigs":[
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"m5.xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":1
},
{
"InstanceType":"m5.xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":1
},
{
"InstanceType":"m5.xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":1
},
{
"InstanceType":"m5.2xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":2
},
{
"InstanceType":"m5.2xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":2
},
{
"InstanceType":"m5.2xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":2
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":4
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":4
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":4
},
{
"InstanceType":"m5.8xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":8
},
{
"InstanceType":"m5.8xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":8
},
{
"InstanceType":"m5.8xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":8
}
]
}
],
"TargetCapacitySpecification":{
"TotalTargetCapacity":40,
"DefaultTargetCapacityType":"spot"
},
"Type":"instant"
}
```
### 示例 4：在单个可用区内启动竞价型实例
您可以通过将 Spot 选项 SingleAvailabilityZone 设置为 true（真），将实例集配置为启动单个可用区中的所有实例。
12 个启动模板覆盖具有不同的实例类型和子网（每个都位于单独的可用区），但权重容量相同。总目标容量为 20 个实例，原定设置购买选项为 Spot，并且 Spot 分配策略为容量优化。EC2 队列使用启动规范，从具有最佳容量的 Spot 容量池启动全部在单个可用区中的 20 个 Spot 实例。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"SingleAvailabilityZone": true
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 5：在单个可用区内启动单个实例类型的 Spot 实例
您可以通过将 SpotOptions SingleInstanceType 和 SingleAvailabilityZone 设置为 true（真），将队列配置为启动单个可用区中相同实例类型的所有实例。
12 个启动模板覆盖具有不同的实例类型和子网（每个都位于单独的可用区），但权重容量相同。总目标容量为 20 个实例，原定设置购买选项为 Spot，Spot 分配策略为容量优化。EC2 队列使用启动规范，从具有最佳容量的 Spot 容量池启动全部在单个可用区中相同实例类型的 20 个 Spot 实例。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"SingleInstanceType": true,
"SingleAvailabilityZone": true
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 6：仅当可以启动最小目标容量时才启动 Spot 实例
只有通过将 Spot 选项 MinTargetCapacity 设置为要同时启动的最小目标容量，以启动最小目标容量，您才可以将队列配置为启动实例。
指定 MinTargetCapacity 时，必须至少指定下列参数中的一个：SingleInstanceType 或 SingleAvailabilityZone。此示例中指定的是 SingleInstanceType，因此所有这 20 个实例必须使用相同的实例类型。
12 个启动模板覆盖具有不同的实例类型和子网（每个都位于单独的可用区），但权重容量相同。总目标容量和最小目标容量均设置为 20 个实例，默认购买选项为竞价型，竞价型分配策略为容量优化。只有在能够同时启动所有 20 个实例时，EC2 队列才能使用启动模板覆盖，从具有最佳容量的 Spot 容量池启动 20 个 Spot 实例。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"SingleInstanceType": true,
"MinTargetCapacity": 20
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 7：仅当可在单个可用区中启动相同实例类型的最低目标容量时，才能启动 Spot 实例
只有通过将 Spot 选项 MinTargetCapacity，以及 SingleInstanceType 和 SingleAvailabilityZone 选项设置为要同时启动的最小目标容量，以在单个可用区中，以单个实例类型启动最小目标容量，您才可以将队列配置为启动实例。
覆盖启动模板的 12 个启动规范具有不同的实例类型和子网（每个都位于单独的可用区），但权重容量相同。总目标容量和最小目标容量均为 20 个实例，原定设置购买选项为 Spot，Spot 分配策略为容量优化，SingleInstanceType 和 SingleAvailabilityZone 均为 true（真）。只有在能够同时启动所有 20 个实例时，EC2 队列才能使用启动规范，从具有最佳容量的 Spot 容量池，启动全部在单个可用区中相同实例类型的 20 个 Spot 实例。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"SingleInstanceType": true,
"SingleAvailabilityZone": true,
"MinTargetCapacity": 20
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.4xlarge",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.4xlarge",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 8：启动具有多个启动模板的实例
您可以通过指定多个启动模板来配置队列，以便为不同的实例类型或一组实例类型启动具有不同启动规范的实例。在此示例中，我们希望为不同实例类型提供不同的 EBS 卷大小，并且我们已经在启动模板 ec2-fleet-lt-4xl、ec2-fleet-lt-9xl 和 ec2-fleet-lt-18xl 中进行配置。
在此示例中，我们根据大小为 3 种实例类型使用了 3 种不同启动模板。所有启动模板上的启动规范覆盖使用基于实例类型上 vCPU 的实例权重。总目标容量为 144 个单位，原定设置购买选项为 Spot，并且 Spot 分配策略为容量优化。EC2 队列可以使用启动模板 ec2-fleet-4xl 启动 9 个 c5n.4xlarge（144 除以 16），或者使用启动模板 ec2-fleet-9xl 启动 4 个 c5n.9xlarge（144 除以 36），或者使用启动模板 ec2-fleet-18xl 启动 2 个 c5n.18xlarge（144 除以 72），或基于容量优化分配策略，权重相加达到所需容量的实例类型的混合。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt-18xl",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5n.18xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":72
},
{
"InstanceType":"c5n.18xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":72
},
{
"InstanceType":"c5n.18xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":72
}
]
},
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt-9xl",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5n.9xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":36
},
{
"InstanceType":"c5n.9xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":36
},
{
"InstanceType":"c5n.9xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":36
}
]
},
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt-4xl",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5n.4xlarge",
"SubnetId":"subnet-fae8c380",
"WeightedCapacity":16
},
{
"InstanceType":"c5n.4xlarge",
"SubnetId":"subnet-e7188bab",
"WeightedCapacity":16
},
{
"InstanceType":"c5n.4xlarge",
"SubnetId":"subnet-49e41922",
"WeightedCapacity":16
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 144,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 9：启动基于按需实例的 Spot 实例
下面的示例为队列指定 20 个实例的总目标容量和 5 个按需实例的目标容量。原定设置购买选项为 Spot。队列按照指定的方式启动 5 个按需实例，但需要再启动 15 个实例以满足总目标容量要求。差值购买选项的计算公式为 TotalTargetCapacity – OnDemandTargetCapacity = DefaultTargetCapacityType，这使得启动 15 个 Spot 实例的队列根据容量优化分配策略构成 12 个 Spot 容量池之一。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-49e41922"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-fae8c380"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-e7188bab"
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-49e41922"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"OnDemandTargetCapacity": 5,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 10：基于使用容量预留和优先分配策略的按需实例，使用容量优化分配策略启动 Spot 实例
您可以通过将容量预留的使用策略配置为 use-capacity-reservations-first（首先使用容量预留），来将队列配置为在以原定设置目标容量类型作为 Spot 启动按需实例的基础时，首先使用按需容量预留。此外，如果多个实例池具有未使用的 容量预留，则应用选定的按需分配策略。在此示例中，按需分配策略为优先级。
在该示例中，有 6 个可用的未使用容量预留。此数目少于队列的 10 个按需实例的目标按需容量。
账户在 2 个池中有以下 6 个未使用的容量预留。每个池中的容量预留数由 AvailableInstanceCount 指示。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 3,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "c5.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 3,
"InstanceMatchCriteria": "open",
"State": "active"
}
```
以下队列配置仅显示该示例的相关配置。按需分配策略为优先级，容量预留的使用策略为 use-capacity-reservations-first（首先使用容量预留）。Spot 分配策略为容量优化。总目标容量为 20，按需目标容量为 10，原定设置目标容量类型为 Spot。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized"
},
"OnDemandOptions":{
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
},
"AllocationStrategy":"prioritized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.large",
"SubnetId":"subnet-fae8c380",
"Priority": 1.0
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-e7188bab",
"Priority": 2.0
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-49e41922",
"Priority": 3.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-fae8c380",
"Priority": 4.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-e7188bab",
"Priority": 5.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-49e41922",
"Priority": 6.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-fae8c380",
"Priority": 7.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-e7188bab",
"Priority": 8.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-49e41922",
"Priority": 9.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-fae8c380",
"Priority": 10.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-e7188bab",
"Priority": 11.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-49e41922",
"Priority": 12.0
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"OnDemandTargetCapacity": 10,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
在使用上述配置创建 instant 队列后，将启动下面的 20 个实例来满足目标容量：
+ us-east-1a 中的 7 个 c5.large 按需实例 – us-east-1a 中的 c5.large 的优先级第一，并且有 3 个可用的未使用 c5.large 容量预留。首先使用容量预留启动 3 个按需实例，并根据按需分配策略（此示例中为优先级）启动另 4 个按需实例。
+ us-east-1a 中的 3 个 m5.large 按需型实例：us-east-1a 中的 m5.large 实例优先级第二，并且有 3 个未使用的 m5.large 容量预留可用。
+ 来自 12 个 Spot 容量池之一的 10 个 Spot 实例，该容量池根据容量优化的分配策略具有最佳容量。
在启动队列后，您可以运行 [describe-capacity-reservations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-capacity-reservations.html) 来查看保留的未使用的 容量预留 的数目。在此示例中，您该看到以下响应，该响应指示已使用所有 c5.large 和 m5.large 容量预留。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "c5.large",
"AvailableInstanceCount": 0
}
```
### 示例 11：使用容量优化优先级分配策略启动 Spot 实例
下面的示例指定了类型为 instant 的 EC2 队列中所需的参数：启动模板、目标容量、原定设置购买选项和启动模板覆盖。启动模板由其启动模板名称和版本号标识。覆盖启动模板的 12 个启动规范具有分配了优先级的 4 个不同的实例类型，以及 3 个不同的子网（每个都位于单独的可用区）。队列的目标容量是 20 个实例，原定设置购买选项为 Spot，这导致队列尝试根据容量优化优先级的分配策略，从 12 个 Spot 容量池之一启动 20 个 Spot 实例，该策略会尽最大努力实施优先级，但首先会针对容量进行优化。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized-prioritized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification":{
"LaunchTemplateName":"ec2-fleet-lt1",
"Version":"$Latest"
},
"Overrides":[
{
"InstanceType":"c5.large",
"SubnetId":"subnet-fae8c380",
"Priority": 1.0
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-e7188bab",
"Priority": 1.0
},
{
"InstanceType":"c5.large",
"SubnetId":"subnet-49e41922",
"Priority": 1.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-fae8c380",
"Priority": 2.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-e7188bab",
"Priority": 2.0
},
{
"InstanceType":"c5d.large",
"SubnetId":"subnet-49e41922",
"Priority": 2.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-fae8c380",
"Priority": 3.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-e7188bab",
"Priority": 3.0
},
{
"InstanceType":"m5.large",
"SubnetId":"subnet-49e41922",
"Priority": 3.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-fae8c380",
"Priority": 4.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-e7188bab",
"Priority": 4.0
},
{
"InstanceType":"m5d.large",
"SubnetId":"subnet-49e41922",
"Priority": 4.0
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
### 示例 12：指定 Systems Manager 参数而非 AMI ID
以下示例使用启动模板来指定实例集中实例的配置。在本示例中，不是为 `ImageId` 指定 AMI ID，而是使用 System Manager 参数来引用 AMI。在实例启动时，Systems Manager 参数会解析为 AMI ID。
在本示例中，Systems Manager 参数以有效格式指定：`resolve:ssm:golden-ami`。Systems Manager 参数也有其他有效格式。有关更多信息，请参阅 [使用 Systems Manager 参数而非 AMI ID](create-launch-template.md#use-an-ssm-parameter-instead-of-an-ami-id)。
**注意**
队列类型必须为类型 `instant`。其他实例集类型不支持指定 Systems Manager 参数来代替 AMI ID。
```
{
"LaunchTemplateData": {
"ImageId": "resolve:ssm:golden-ami",
"InstanceType": "m5.4xlarge",
"TagSpecifications": [{
"ResourceType": "instance",
"Tags": [{
"Key": "Name",
"Value": "webserver"
}]
}]
}
}
```
# 为 EC2 实例集或竞价型实例集设置支出限额
您可以设置每小时愿意为 EC2 实例集或竞价型实例集支出的限额。在达到支出限额时，即使尚未达到目标容量，实例集也会停止启动实例。
按需型实例和竞价型实例有单独的支出限额。
**为 EC2 实例集中的按需型实例和竞价型实例配置支出限额**
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令和以下参数：
+ 若为按需型实例：在 `OnDemandOptions` 结构中，在 `MaxTotalPrice` 字段中指定支出限额。
+ 若为竞价型实例：在 `SpotOptions` 结构中，在 `MaxTotalPrice` 字段中指定支出限额。
**为竞价型实例集中的按需型实例和竞价型实例配置支出限额**
Amazon EC2 控制台和 AWS CLI 都可用于配置支出限额。
（控制台）创建竞价型实例集时，请选中**设置 Spot 实例的最大成本**复选框，然后在**设置您的最大成本(每小时)**中输入一个值。有关更多信息，请参阅[使用已定义的参数创建竞价型实例集请求](create-spot-fleet.md#create-spot-fleet-advanced)中的步骤 6.e.。
（AWS CLI）使用 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) 命令和以下参数：
+ 若为按需型实例：在 `OnDemandMaxTotalPrice` 字段中指定支出限额。
+ 若为竞价型实例：在 `SpotMaxTotalPrice` 字段中指定支出限额。
## 示例
以下示例显示了两个不同的方案。在第一个示例中，实例集在满足按需型实例的目标容量 (`OnDemandTargetCapacity`) 后停止启动按需型实例。在第二个示例中，实例集在达到每小时愿意为按需型实例支付的最高金额 (`MaxTotalPrice`) 时停止启动实例。
**示例：在达到目标容量时停止启动按需型实例**
假设发出 `m4.large` 按需实例请求，其中：
+ 按需价格：每小时 0.10 美元
+ `OnDemandTargetCapacity`: 10
+ `MaxTotalPrice`：1.50 美元
实例集启动 10 个按需型实例，因为总费用 1.00 美元（10 个实例 x 0.10 美元）未超过实例的 `MaxTotalPrice` 1.50 美元。
**示例：在达到最高总费用时停止启动按需型实例**
假设发出 `m4.large` 按需实例请求，其中：
+ 按需价格：每小时 0.10 美元
+ `OnDemandTargetCapacity`: 10
+ `MaxTotalPrice`：0.80 美元
如果实例集启动按需型目标容量（10 个按需型实例），则每小时的总成本为 1.00 美元。这超过了为按需实例的 `MaxTotalPrice` 指定的金额（0.80 美元）。为了防止支出超过您愿意支付的金额，实例集仅启动 8 个按需型实例（低于按需型目标容量），因为启动更多实例将超过按需型实例的 `MaxTotalPrice`。
## 具爆发能力的实例
如果您使用[可突增性能的实例类型](burstable-performance-instances.md)启动您的 Spot 实例，并打算立即并短时间使用可突增性能的 Spot 实例，且没有空闲时间来积累 CPU 积分，建议您以[标准模式](burstable-performance-instances-standard-mode.md)启动实例，以避免支付更高的成本。如果您以[无限模式](burstable-performance-instances-unlimited-mode.md)启动可突增性能的 Spot 实例并立即突增 CPU，您将会为突增花费超额积分。如果使用实例的时间很短，使得实例没有时间积累 CPU 积分来支付超额积分，则您将在终止实例时为超额积分付费。
仅当实例的运行时间较长，足以积累进行突增的 CPU 积分时，针对可突增性能的竞价型实例的无限模式才适用。否则，支付剩余积分会使可突增性能的竞价型实例比使用其他实例更加昂贵。有关更多信息，请参阅[何时使用无限模式与固定 CPU](burstable-performance-instances-unlimited-mode-concepts.md#when-to-use-unlimited-mode)。
通过提供足够的计算资源来配置实例，启动积分旨在为 T2 实例提供有成效的初始启动体验。不允许重复启动 T2 实例以访问新的启动积分。如果您需要持续的 CPU，您可以赚取积分（通过空转一段时间），将[无限模式](burstable-performance-instances-unlimited-mode.md)用于 T2 Spot 实例，或将实例类型和专用 CPU 一起使用。
# 指定 EC2 实例集或竞价型实例集的实例类型选择属性
创建 EC2 实例集或竞价型实例集时，必须指定一种或多种实例类型，以便配置实例集中的按需型实例和竞价型实例。除了手动指定实例类型外，还可以指定实例必须具有的属性，Amazon EC2 将使用这些属性标识所有实例类型。这称为*基于属性的实例类型选择*。例如，您可以指定实例所需的最小和最大 vCPU 数量，实例集将使用满足这些 vCPU 要求的任何可用实例类型启动实例。
基于属性的实例类型选择是工作负载和框架的理想选择，这些工作负载和框架可以灵活地确定所用的实例类型，例如在运行容器或 Web 机群、处理大数据以及实施持续集成和部署 (CI/CD) 工具等情况下。
**优点**
基于属性的实例类型选择具有以下优势：
+ **轻松使用正确的实例类型** – 有如此多的实例类型可供使用，因此找到适用于您的工作负载的实例类型可能非常耗时。当您指定实例属性时，实例类型将自动具有工作负载所需的属性。
+ **简化配置** – 要为实例集手动指定多种实例类型，您必须为每种实例类型创建单独的启动模板覆盖。但是，借助基于属性的实例类型选择，要提供多种实例类型，您只需在启动模板或启动模板覆盖中指定实例属性即可。
+ **自动使用新实例类型** – 当您指定实例属性而不是实例类型时，您的实例集可以在新一代实例类型发布时使用这些实例类型，“满足未来”实例集配置的需求。
+ **实例类型灵活性** – 指定实例属性而不是实例类型时，实例集可以从各种实例类型中进行选择来启动竞价型实例，从而遵循[灵活选择竞价型实例类型的最佳实践](spot-best-practices.md#be-instance-type-flexible)。
**Topics**
+ [
## 基于属性的实例类型选择的工作原理
](#ec2fleet-abs-how-it-works)
+ [
## 价格保护
](#ec2fleet-abs-price-protection)
+ [
## 性能保护
](#ec2fleet-abis-performance-protection)
+ [
## 注意事项
](#ec2fleet-abs-considerations)
+ [
## 通过基于属性的实例类型选择创建 EC2 机群
](#abs-create-ec2-fleet)
+ [
## 通过基于属性的实例类型选择创建竞价型实例集
](#abs-create-spot-fleet)
+ [
## 有效 EC2 实例集配置示例和无效 EC2 实例集配置示例
](#ec2fleet-abs-example-configs)
+ [
## 有效竞价型实例集配置示例和无效竞价型实例集配置示例
](#spotfleet-abs-example-configs)
+ [
## 预览具有指定属性的实例类型
](#ec2fleet-get-instance-types-from-instance-requirements)
## 基于属性的实例类型选择的工作原理
要在机群配置中使用基于属性的实例类型选择，请将实例类型列表替换为实例所需的实例属性列表。EC2 实例集或竞价型实例集将在具有指定实例属性的任何可用实例类型上启动实例。
**Topics**
+ [
### 实例属性的类型
](#ef-abs-instance-attribute-types)
+ [
### 在何处配置基于属性的实例类型选择
](#ef-abs-where-to-configure)
+ [
### EC2 实例集或竞价型实例集如何在预置实例集时使用基于属性的实例类型选择
](#how-ef-uses-abs)
### 实例属性的类型
您可以指定多个实例属性来表达计算需求，例如：
+ **vCPU 数量** - 每个实例的最小和最大 vCPU 数量。
+ **内存** - 每个实例的最小和最大内存 GiB 数量。
+ **本地存储** - 是使用 EBS 还是实例存储卷作为本地存储。
+ **可突增性能** - 是否使用 T 实例系列（包括 T4g、T3a、T3 和 T2 类型）。
有关每个属性和默认值的描述，请参阅 *Amazon EC2 API 参考*中的 [InstanceRequirements](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceRequirements.html)。
### 在何处配置基于属性的实例类型选择
根据您使用的是控制台还是 AWS CLI，可以按如下方式为基于属性的实例类型选择指定实例属性：
在控制台中，您可以在以下实例集配置组件中指定实例属性：
+ 在启动模板中，并在实例集请求中引用启动模板
+ （仅适用于竞价型实例集）在实例集请求中
在 AWS CLI 中，您可以在以下一个或全部机群配置组件中指定实例属性：
+ 在启动模板中，并在实例集请求中引用启动模板
+ 在启动模板覆盖中
如果您想混合应用使用不同 AMI 的实例，则可以在多个启动模板覆盖中指定实例属性。例如，不同的实例类型可以使用 x86 和基于 ARM 的处理器。
+ （仅适用于竞价型实例集）在启动规范中
### EC2 实例集或竞价型实例集如何在预置实例集时使用基于属性的实例类型选择
EC2 实例集或竞价型实例集通过以下方式预置实例集：
+ 标识具有指定属性的实例类型。
+ 使用价格保护来确定要排除的实例类型。
+ 根据具有匹配实例类型的 AWS 区域或可用区确定将从中启动实例的容量池。
+ 应用指定的分配策略来确定从中启动实例的容量池。
请注意，基于属性的实例类型选择不会选择从中预置实例集的容量池；这是[分配策略](ec2-fleet-allocation-strategy.md)的任务。
如果您指定分配策略，实例集将根据指定的分配策略启动实例。
+ 若为竞价型实例，基于属性的实例类型选择支持**价格容量优化**、**容量优化**和**最低价格**分配策略。请注意，不推荐使用**最低价格**竞价型分配策略，因为这对竞价型实例造成的中断风险最高。
+ 若为按需型实例，基于属性的实例类型选择支持**最低价格**分配策略。
+ 如果没有适用于具有指定实例属性的实例类型的容量，则无法启动任何实例，并且机群返回错误。
## 价格保护
价格保护是一项功能，可以防止 EC2 实例集或竞价型实例集使用您认为成本过高的实例类型，即使它们恰好适合您指定的属性。要使用价格保护，您需要设置价格阈值。然后，当 Amazon EC2 选择具有您的属性的实例类型时，会排除定价高于阈值的实例类型。
Amazon EC2 计算价格阈值的方式如下：
+ Amazon EC2 首先从与您的属性匹配的实例类型中识别出价格最低的实例类型。
+ 然后，Amazon EC2 会使用您为价格保护参数指定的值（以百分比表示）乘以已识别的实例类型的价格。其结果就是用作价格阈值的价格。
按需型实例和竞价型实例有不同的价格阈值。
当您使用基于属性的实例类型选择创建实例集时，默认情况下会启用价格保护。您可以保留默认值，也可以指定自己的值。
您也可以关闭价格保护。要表明无价格保护阈值，请指定一个较高的百分比值，如 `999999`。
**Topics**
+ [
### 价格最低的实例类型的识别方式
](#ec2fleet-abs-price-protection-lowest-priced)
+ [
### 按需型实例价格保护
](#ec2fleet-abs-on-demand-price-protection)
+ [
### 竞价型实例价格保护
](#ec2fleet-abs-spot-price-protection)
+ [
### 指定价格保护阈值
](#ec2fleet-abs-specify-price-protection)
### 价格最低的实例类型的识别方式
Amazon EC2 会从与您指定的属性相匹配的实例类型中识别价格最低的实例类型，从而确定价格阈值所依据的价格。它的做法具体如下：
+ 它首先会从当前一代 C、M 或 R 实例类型中查找与您的属性相匹配的实例类型。如果找到匹配结果，它就会识别出价格最低的实例类型。
+ 如果没有匹配结果，它会从当前一代的任何实例类型中查找与您的属性相匹配的实例类型。如果找到匹配结果，它就会识别出价格最低的实例类型。
+ 如果没有匹配结果，它会从上一代的任何实例类型中查找与您的属性相匹配的实例类型，并识别出价格最低的实例类型。
### 按需型实例价格保护
按需型实例类型的价格保护阈值基于已识别的最低价格按需型实例类型(`OnDemandMaxPricePercentageOverLowestPrice`)，按照*高于其价格的百分比*计算。您可以指定该高出的百分比，表示您原意支付的价格。如果您未指定此参数，则使用默认值 `20` 计算价格保护阈值(即比已识别的价格高出 20%)。
例如，如果识别的按需型实例价格为 `0.4271`，并且您指定了 `25`，则价格阈值将比 `0.4271` 高 25%。按如下方式计算：`0.4271 * 1.25 = 0.533875`。计算出的价格是您愿意为按需型实例支付的最高价格，在本示例中，Amazon EC2 将排除任何价格高于 `0.533875` 的按需型实例类型。
### 竞价型实例价格保护
默认情况下，Amazon EC2 将自动应用最佳的竞价型实例价格保护，从而始终如一地从各种实例类型中进行选择。您也可以自行手动设置价格保护。但是，让 Amazon EC2 为您代劳可以提高竞价型容量得到满足的可能性。
您可以使用以下选项之一，手动指定价格保护。如果您手动设置价格保护，则建议您使用第一个选项。
+ **已识别的最低价格*按需型实例*类型的*百分比*** [`MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`]
例如，如果识别的按需型实例价格为 `0.4271`，并且您指定了 `60`，则价格阈值将是 `0.4271` 的 60%。按如下方式计算：`0.4271 * 0.60 = 0.25626`。计算出的价格是您愿意为竞价型实例支付的最高价格，在本示例中，Amazon EC2 将排除任何价格高于 `0.25626` 的竞价型实例类型。
+ **比已识别的最低价格*竞价型实例*实例类型*高出的百分比*** [`SpotMaxPricePercentageOverLowestPrice`]
例如，如果识别的竞价型实例价格为 `0.1808`，并且您指定了 `25`，则价格阈值将比 `0.1808` 高 25%。按如下方式计算：`0.1808 * 1.25 = 0.226`。计算出的价格是您愿意为竞价型实例支付的最高价格，在本示例中，Amazon EC2 将排除任何价格高于 `0.266` 的竞价型实例类型。我们不建议使用该参数，因为竞价型实例类型的价格可能会波动，因此您的价格保护阈值也可能会波动。
### 指定价格保护阈值
**使用 AWS CLI 指定价格保护阈值**
使用 AWS CLI 创建 EC2 实例集或竞价型实例集时，请配置实例集，以便使用基于属性的实例类型选择，然后执行以下操作：
+ 若要指定按需型实例价格保护阈值，请在 JSON 配置文件的 `InstanceRequirements` 结构中，为 `OnDemandMaxPricePercentageOverLowestPrice` 输入以百分比表示的价格保护阈值。
+ 要指定竞价型实例的价格保护阈值，请在 JSON 配置文件的 `InstanceRequirements` 结构中指定以下参数之*一*：
+ 对于 `MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`，输入以百分比表示的价格保护阈值。
+ 对于 `SpotMaxPricePercentageOverLowestPrice`，输入以百分比表示的价格保护阈值。
有关更多信息，请参阅 [通过基于属性的实例类型选择创建 EC2 机群](#abs-create-ec2-fleet) 或 [通过基于属性的实例类型选择创建竞价型实例集](#abs-create-spot-fleet)。
**（仅适用于竞价型实例集）使用控制台指定价格保护阈值**
在控制台中创建竞价型实例集时，请配置实例集，以便使用基于属性的实例类型选择，然后执行以下操作：
+ 若要指定按需型实例价格保护阈值，请在**其他实例属性**下选择**按需型价格保护**，随后选择**添加属性**，然后输入以百分比表示的价格保护阈值。
+ 若要指定竞价型实例价格保护阈值，请在**其他实例属性**下选择**竞价型价格保护**，随后选择**添加属性**，再选择作为价格依据的基值，然后输入以百分比表示的价格保护阈值。
**注意**
创建实例集时，如果将 `TargetCapacityUnitType` 设置为 `vcpu` 或 `memory-mib`，则会基于每个 vCPU 或每个内存的价格，而不是每个实例的价格应用价格保护阈值。
## 性能保护
*性能保护*是一项功能，可确保您的 EC2 实例集或竞价型实例集使用的实例类型类似于或超过指定的性能基准。要使用性能保护，请指定一个实例系列作为基准参考。指定的实例系列的功能确立了可接受的最低性能水平。当 Amazon EC2 为您的实例集选择实例类型时，它会考虑您指定的属性和性能基准。低于性能基准的实例类型将被自动排除在选择范围之外，即使它们与您指定的其他属性相匹配。这可确保所有选定的实例类型都提供与指定实例系列建立的基准相似或更好的性能。Amazon EC2 使用此基准来指导实例类型选择，但并不能保证选定实例类型始终会超过每个应用程序的基准。
目前，此功能仅支持将 CPU 性能作为基准性能因素。指定的实例系列的 CPU 处理器的 CPU 性能充当性能基准，确保选定的实例类型与该基准相似或超过该基准。具有相同 CPU 处理器的实例系列会产生相同的筛选结果，即使其网络或磁盘性能有所不同。例如，将 `c6in` 或 `c6i` 指定为基准参考将产生相同的基于性能的筛选结果，因为两个实例系列使用相同的 CPU 处理器。
**不支持的实例系列**
以下实例系列**不支持**性能保护：
+ **通用型**：Mac1 \$1 Mac2 \$1 Mac2-m1ultra \$1 Mac2-m2 \$1 Mac2-m2pro \$1 M1 \$1 M2 \$1 T1
+ **计算优化型：**C1
+ **内存优化型：**U-3tb1 \$1 U-6tb1 \$1 U-9tb1 \$1 U-12tb1 \$1 U-18tb1 \$1 u-24tb1 \$1 U7i-12tb \$1 U7in-16tb \$1 U7in-24tb \$1 U7in-32tb
+ **加速计算型：**G3 \$1 G3s \$1 P3dn \$1 P4d \$1 P5
+ **高性能计算型：**Hpc7g
如果您通过指定支持的实例系列来启用性能保护，则返回的实例类型将排除上述不受支持的实例系列。
如果您将不支持的实例系列指定为基准性能值，则 API 会针对 [GetInstanceTypesFromInstanceRequirements](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html) 返回空响应，对于 [CreateFleet](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet.html)、[RequestSpotFleet](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotFleet.html)、[ModifyFleet](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyFleet.html) 和 [ModifySpotFleetRequest](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifySpotFleetRequest.html) 返回异常。
**示例：设置 CPU 性能基准**
在以下示例中，实例要求是使用具有与 `c6i` 实例系列一样性能的 CPU 核心的实例类型启动。这将筛选掉 CPU 处理器性能较低的实例类型，即使它们满足您指定的其他实例要求（例如 vCPU 数量）。例如，如果您指定的实例属性包括 4 个 vCPU 和 16 GB 内存，则具有这些属性但 CPU 性能低于 `c6i` 的实例类型将被排除在选择范围之外。
```
"BaselinePerformanceFactors": {
"Cpu": {
"References": [
{
"InstanceFamily": "c6i"
}
]
}
```
## 注意事项
+ 您可以在 EC2 实例集或竞价型实例集中指定实例类型或实例属性，但不能同时指定两者。
使用 CLI 时，启动模板覆盖将覆盖启动模板。例如，如果启动模板包含实例类型，而启动模板覆盖包含实例属性，则由实例属性标识的实例将覆盖启动模板中的实例类型。
+ 使用 CLI 时，如果将实例属性指定为覆盖，也无法指定权重或优先级。
+ 在一个请求配置中，最多可以指定四个 `InstanceRequirements` 结构。
## 通过基于属性的实例类型选择创建 EC2 机群
可以配置 EC2 实例集以使用基于属性的实例类型选择。无法通过 Amazon EC2 控制台创建 EC2 实例集。
基于属性的实例类型选择的属性在 `InstanceRequirements` 结构中指定。如果实例集配置中包含 `InstanceRequirements`，则必须排除 `InstanceType` 和 `WeightedCapacity`，因为它们无法同时确定实例集配置与实例属性。
在 AWS CLI 和 PowerShell 示例中，指定了以下属性：
+ `VCpuCount`：最少 2 个 vCPU，最多 4 个 vCPU。如果不需要最大限制，则可省略最大值。
+ `MemoryMiB`：内存最小为 8 GiB，最大为 16 GiB。如果不需要最大限制，则可省略最大值。
此配置可识别具有 2 到 4 个 vCPU 和 8 到 16 GiB 内存的所有实例类型。然而，当 [EC2 实例集预置实例集](#how-ef-uses-abs)时，价格保护和分配策略可能会排除某些实例类型。
------
#### [ AWS CLI ]
**通过基于属性的实例类型选择创建 EC2 实例集**
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令创建 EC2 实例集。在 JSON 文件中指定机群配置。
```
aws ec2 create-fleet \
--region us-east-1 \
--cli-input-json file://file_name.json
```
以下示例 `file_name.json` 文件所含参数可配置 EC2 实例集以使用基于属性的实例类型选择。
```
{
"SpotOptions": {
"AllocationStrategy": "price-capacity-optimized"
},
"LaunchTemplateConfigs": [{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2,
"Max": 4
},
"MemoryMiB": {
"Min": 8192,
"Max": 16384
}
}
}]
}],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
------
#### [ PowerShell ]
**通过基于属性的实例类型选择创建 EC2 实例集**
使用 [New-EC2Fleet](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Fleet.html) cmdlet。
```
$vcpuCount = New-Object Amazon.EC2.Model.VCpuCountRangeRequest
$vcpuCount.Min = 2
$vcpuCount.Max = 4
$memoryMiB = New-Object Amazon.EC2.Model.MemoryMiBRequest
$memoryMiB.Min = 8192
$memoryMiB.Max = 16384
$instanceRequirements = New-Object Amazon.EC2.Model.InstanceRequirementsRequest
$instanceRequirements.VCpuCount = $vcpuCount
$instanceRequirements.MemoryMiB = $memoryMiB
$launchTemplateSpec = New-Object Amazon.EC2.Model.FleetLaunchTemplateSpecificationRequest
$launchTemplateSpec.LaunchTemplateName = "my-launch-template"
$launchTemplateSpec.Version = "1"
$override = New-Object Amazon.EC2.Model.FleetLaunchTemplateOverridesRequest
$override.InstanceRequirements = $instanceRequirements
$launchTemplateConfig = New-Object Amazon.EC2.Model.FleetLaunchTemplateConfigRequest
$launchTemplateConfig.LaunchTemplateSpecification = $launchTemplateSpec
$launchTemplateConfig.Overrides = @($override)
New-EC2Fleet `
-SpotOptions_AllocationStrategy "price-capacity-optimized" `
-LaunchTemplateConfig @($launchTemplateConfig) `
-TargetCapacitySpecification_DefaultTargetCapacityType "spot" `
-TargetCapacitySpecification_TotalTargetCapacity 20 `
-Type "instant"
```
------
## 通过基于属性的实例类型选择创建竞价型实例集
您可以配置实例集以使用基于属性的实例类型选择。
基于属性的实例类型选择的属性在 `InstanceRequirements` 结构中指定。如果实例集配置中包含 `InstanceRequirements`，则必须排除 `InstanceType` 和 `WeightedCapacity`，因为它们无法同时确定实例集配置与实例属性。
在 AWS CLI 和 PowerShell 示例中，指定了以下属性：
+ `VCpuCount`：最少 2 个 vCPU，最多 4 个 vCPU。如果不需要最大限制，则可省略最大值。
+ `MemoryMiB`：内存最小为 8 GiB，最大为 16 GiB。如果不需要最大限制，则可省略最大值。
此配置可识别具有 2 到 4 个 vCPU 和 8 到 16 GiB 内存的所有实例类型。然而，当[竞价型实例集预置实例集](#how-ef-uses-abs)时，价格保护和分配策略可能会排除某些实例类型。
------
#### [ Console ]
**配置竞价型实例集以使用基于属性的实例类型选择**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，选择 **Spot Requests**（竞价型请求），然后选择 **Request Spot Instances**（请求竞价型实例）。
1. 按照步骤创建竞价型实例集。有关更多信息，请参阅 [使用已定义的参数创建竞价型实例集请求](create-spot-fleet.md#create-spot-fleet-advanced)。
创建竞价型实例集时，按如下方式配置机群以使用基于属性的实例类型选择：
1. 对于 **Instance type requirements**（实例类型要求），选择 **Specify instance attributes that match your compute requirements**（指定符合计算要求的实例属性）。
1. 对于 **vCPU**，输入所需的最小和最大 vCPU 数。要指定没有限制，请选择 **No minimum**（没有最小值）和/或 **No maximum**（没有最大值）。
1. 对于 **Memory (GiB)**（内存 (GiB)），输入所需的最小和最大内存量。要指定没有限制，请选择 **No minimum**（没有最小值）和/或 **No maximum**（没有最大值）。
1. （可选）对于 **Additional instance attributes**（其它实例属性），您可以选择指定一个或多个属性以更详细地表达计算要求。每个额外属性都会进一步增加对您的请求的限制。
1. （可选）展开 **Preview matching instance types**（预览匹配的实例类型），查看具有指定属性的实例类型。
------
#### [ AWS CLI ]
**配置竞价型实例集以使用基于属性的实例类型选择**
使用 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) 命令创建竞价型实例集。在 JSON 文件中指定机群配置。
```
aws ec2 request-spot-fleet \
--region us-east-1 \
--spot-fleet-request-config file://file_name.json
```
以下示例 `file_name.json` 文件所含参数可配置竞价型实例集以使用基于属性的实例类型选择。
```
{
"AllocationStrategy": "priceCapacityOptimized",
"TargetCapacity": 20,
"Type": "request",
"LaunchTemplateConfigs": [{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2,
"Max": 4
},
"MemoryMiB": {
"Min": 8192,
"Max": 16384
}
}
}]
}]
}
```
------
#### [ PowerShell ]
**配置竞价型实例集以使用基于属性的实例类型选择**
使用 [Request-EC2SpotFleet](https://docs.aws.amazon.com/powershell/latest/reference/items/Request-EC2SpotFleet.html) cmdlet。
```
$vcpuCount = New-Object Amazon.EC2.Model.VCpuCountRange
$vcpuCount.Min = 2
$vcpuCount.Max = 4
$memoryMiB = New-Object Amazon.EC2.Model.MemoryMiB
$memoryMiB.Min = 8192
$memoryMiB.Max = 16384
$instanceRequirements = New-Object Amazon.EC2.Model.InstanceRequirements
$instanceRequirements.VCpuCount = $vcpuCount
$instanceRequirements.MemoryMiB = $memoryMiB
$launchTemplateSpec = New-Object Amazon.EC2.Model.FleetLaunchTemplateSpecification
$launchTemplateSpec.LaunchTemplateName = "my-launch-template"
$launchTemplateSpec.Version = "1"
$override = New-Object Amazon.EC2.Model.LaunchTemplateOverrides
$override.InstanceRequirements = $instanceRequirements
$launchTemplateConfig = New-Object Amazon.EC2.Model.LaunchTemplateConfig
$launchTemplateConfig.LaunchTemplateSpecification = $launchTemplateSpec
$launchTemplateConfig.Overrides = @($override)
Request-EC2SpotFleet `
-SpotFleetRequestConfig_AllocationStrategy "PriceCapacityOptimized" `
-SpotFleetRequestConfig_TargetCapacity 20 `
-SpotFleetRequestConfig_Type "Request" `
-SpotFleetRequestConfig_LaunchTemplateConfig $launchTemplateConfig
```
------
## 有效 EC2 实例集配置示例和无效 EC2 实例集配置示例
如果您使用 AWS CLI 创建 EC2 机群，必须确保机群配置有效。以下示例展示了有效配置和无效配置。
如果配置包含以下项，则视为无效：
+ 单个 `Overrides` 结构，但同时包含 `InstanceRequirements` 和 `InstanceType`
+ 两个 `Overrides` 结构，其中一个包含 `InstanceRequirements`，而另一个包含 `InstanceType`
+ 两个 `InstanceRequirements` 结构，但在同一 `LaunchTemplateSpecification` 中具有重叠的属性值
**Topics**
+ [
### 有效配置：具有覆盖的单个启动模板
](#ef-abs-example-config1)
+ [
### 有效配置：具有多个 InstanceRequirements 的单个启动模板
](#ef-abs-example-config2)
+ [
### 有效配置：两个启动模板，每个都具有覆盖
](#ef-abs-example-config3)
+ [
### 有效配置：仅指定 `InstanceRequirements`，且属性值不重叠
](#ef-abs-example-config4)
+ [
### 配置无效：`Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
](#ef-abs-example-config5)
+ [
### 配置无效：两个 `Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
](#ef-abs-example-config6)
+ [
### 配置无效：属性值重叠
](#ef-abs-example-config7)
### 有效配置：具有覆盖的单个启动模板
以下配置有效。包含一个启动模板和一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。下面是示例配置的文本说明。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "My-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2,
"Max": 8
},
"MemoryMib": {
"Min": 0,
"Max": 10240
},
"MemoryGiBPerVCpu": {
"Max": 10000
},
"RequireHibernateSupport": true
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 5000,
"DefaultTargetCapacityType": "spot",
"TargetCapacityUnitType": "vcpu"
}
}
}
```
****`InstanceRequirements`****
要使用基于属性的实例选择，您必须在机群配置中包含 `InstanceRequirements` 结构，并为机群中的实例指定所需的属性。
在上述示例中，指定了以下实例属性：
+ `VCpuCount` – 实例类型的 vCPU 数量必须最少为 2 个，最多为 8 个。
+ `MemoryMiB` – 实例类型的最大内存必须为 10240MiB。最小值 0 表示没有最低限制。
+ `MemoryGiBPerVCpu` – 实例类型的每个 vCPU 内存最大值必须为 10000GiB。`Min` 参数是可选的。省略此属性表示没有最低限制。
**`TargetCapacityUnitType`**
`TargetCapacityUnitType` 参数为目标容量指定单位。在该示例中，目标容量是 `5000`，目标容量单位类型是 `vcpu`，它们共同指定了所需的 5000 个 vCPU 目标容量。EC2 机群将启动足够多的实例，以便机群中的 vCPU 总数为 5000 个 vCPU。
### 有效配置：具有多个 InstanceRequirements 的单个启动模板
以下配置有效。包含一个启动模板和一个 `Overrides` 结构（包含两个 `InstanceRequirements` 结构）。`InstanceRequirements` 中指定的属性有效，因为值不重叠，第一个 `InstanceRequirements` 结构指定 `VCpuCount` 为 0-2 个 vCPU，而第二个 `InstanceRequirements` 结构指定 4-8 个 vCPU。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 8
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
### 有效配置：两个启动模板，每个都具有覆盖
以下配置有效。包含两个启动模板，每个模板都有一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。此配置适用于在同一机群中支持 `arm` 和 `x86` 架构。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "armLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "x86LaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
### 有效配置：仅指定 `InstanceRequirements`，且属性值不重叠
以下配置有效。包含两个 `LaunchTemplateSpecification` 结构，每个结构都有一个启动模板和一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。`InstanceRequirements` 中指定的属性有效，因为值不重叠，第一个 `InstanceRequirements` 结构指定 `VCpuCount` 为 0-2 个 vCPU，而第二个 `InstanceRequirements` 结构指定 4-8 个 vCPU。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyOtherLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 8
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
### 配置无效：`Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
以下配置无效。`Overrides` 结构同时包含 `InstanceRequirements` 和 `InstanceType`。对于 `Overrides`，可以指定 `InstanceRequirements` 或 `InstanceType`，但不能同时指定两者。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"InstanceType": "m5.large"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
### 配置无效：两个 `Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
以下配置无效。`Overrides` 结构同时包含 `InstanceRequirements` 和 `InstanceType`。您可以指定 `InstanceRequirements` 或 `InstanceType`，但不能同时指定两者，即使采用不同的 `Overrides` 结构也是如此。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyOtherLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "m5.large"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
### 配置无效：属性值重叠
以下配置无效。两个 `InstanceRequirements` 结构，每个结构都包含 `"VCpuCount": {"Min": 0, "Max": 2}`。这些属性的值重叠，这将导致容量池重复。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
},
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
}
```
## 有效竞价型实例集配置示例和无效竞价型实例集配置示例
如果您使用 AWS CLI 创建竞价型实例集，必须确保机群配置有效。以下示例展示了有效配置和无效配置。
如果配置包含以下项，则视为无效：
+ 单个 `Overrides` 结构，但同时包含 `InstanceRequirements` 和 `InstanceType`
+ 两个 `Overrides` 结构，其中一个包含 `InstanceRequirements`，而另一个包含 `InstanceType`
+ 两个 `InstanceRequirements` 结构，但在同一 `LaunchTemplateSpecification` 中具有重叠的属性值
**Topics**
+ [
### 有效配置：具有覆盖的单个启动模板
](#sf-abs-example-config1)
+ [
### 有效配置：具有多个 InstanceRequirements 的单个启动模板
](#sf-abs-example-config2)
+ [
### 有效配置：两个启动模板，每个都具有覆盖
](#sf-abs-example-config3)
+ [
### 有效配置：仅指定 `InstanceRequirements`，且属性值不重叠
](#sf-abs-example-config4)
+ [
### 配置无效：`Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
](#sf-abs-example-config5)
+ [
### 配置无效：两个 `Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
](#sf-abs-example-config6)
+ [
### 配置无效：属性值重叠
](#sf-abs-example-config7)
### 有效配置：具有覆盖的单个启动模板
以下配置有效。包含一个启动模板和一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。下面是示例配置的文本说明。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "My-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2,
"Max": 8
},
"MemoryMib": {
"Min": 0,
"Max": 10240
},
"MemoryGiBPerVCpu": {
"Max": 10000
},
"RequireHibernateSupport": true
}
}
]
}
],
"TargetCapacity": 5000,
"OnDemandTargetCapacity": 0,
"TargetCapacityUnitType": "vcpu"
}
}
```
****`InstanceRequirements`****
要使用基于属性的实例选择，您必须在机群配置中包含 `InstanceRequirements` 结构，并为机群中的实例指定所需的属性。
在上述示例中，指定了以下实例属性：
+ `VCpuCount` – 实例类型的 vCPU 数量必须最少为 2 个，最多为 8 个。
+ `MemoryMiB` – 实例类型的最大内存必须为 10240MiB。最小值 0 表示没有最低限制。
+ `MemoryGiBPerVCpu` – 实例类型的每个 vCPU 内存最大值必须为 10000GiB。`Min` 参数是可选的。省略此属性表示没有最低限制。
**`TargetCapacityUnitType`**
`TargetCapacityUnitType` 参数为目标容量指定单位。在该示例中，目标容量是 `5000`，目标容量单位类型是 `vcpu`，它们共同指定了所需的 5000 个 vCPU 目标容量。竞价型实例集将启动足够多的实例，以便机群中的 vCPU 总数为 5000 个 vCPU。
### 有效配置：具有多个 InstanceRequirements 的单个启动模板
以下配置有效。包含一个启动模板和一个 `Overrides` 结构（包含两个 `InstanceRequirements` 结构）。`InstanceRequirements` 中指定的属性有效，因为值不重叠，第一个 `InstanceRequirements` 结构指定 `VCpuCount` 为 0-2 个 vCPU，而第二个 `InstanceRequirements` 结构指定 4-8 个 vCPU。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 8
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
### 有效配置：两个启动模板，每个都具有覆盖
以下配置有效。包含两个启动模板，每个模板都有一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。此配置适用于在同一机群中支持 `arm` 和 `x86` 架构。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "armLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "x86LaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
### 有效配置：仅指定 `InstanceRequirements`，且属性值不重叠
以下配置有效。包含两个 `LaunchTemplateSpecification` 结构，每个结构都有一个启动模板和一个 `Overrides` 结构（包含一个 `InstanceRequirements` 结构）。`InstanceRequirements` 中指定的属性有效，因为值不重叠，第一个 `InstanceRequirements` 结构指定 `VCpuCount` 为 0-2 个 vCPU，而第二个 `InstanceRequirements` 结构指定 4-8 个 vCPU。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyOtherLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 8
},
"MemoryMiB": {
"Min": 0
}
}
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
### 配置无效：`Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
以下配置无效。`Overrides` 结构同时包含 `InstanceRequirements` 和 `InstanceType`。对于 `Overrides`，可以指定 `InstanceRequirements` 或 `InstanceType`，但不能同时指定两者。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
},
{
"InstanceType": "m5.large"
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
### 配置无效：两个 `Overrides` 包含 `InstanceRequirements` 和 `InstanceType`
以下配置无效。`Overrides` 结构同时包含 `InstanceRequirements` 和 `InstanceType`。您可以指定 `InstanceRequirements` 或 `InstanceType`，但不能同时指定两者，即使采用不同的 `Overrides` 结构也是如此。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
]
},
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyOtherLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "m5.large"
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
### 配置无效：属性值重叠
以下配置无效。两个 `InstanceRequirements` 结构，每个结构都包含 `"VCpuCount": {"Min": 0, "Max": 2}`。这些属性的值重叠，这将导致容量池重复。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "MyLaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
},
{
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 2
},
"MemoryMiB": {
"Min": 0
}
}
}
}
]
}
],
"TargetCapacity": 1,
"OnDemandTargetCapacity": 0,
"Type": "maintain"
}
}
```
## 预览具有指定属性的实例类型
您可以使用 [get-instance-types-from-instance-requirements](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-types-from-instance-requirements.html) 命令预览与您指定的属性匹配的实例类型。这对于在不启动任何实例的情况下确定要在请求配置中指定的属性尤其有用。请注意，该命令不考虑可用容量。
**通过使用 AWS CLI 指定属性来预览实例类型列表**
1. （可选）要生成所有可以指定的可能属性，请使用 [get-instance-types-from-instance-requirements](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-types-from-instance-requirements.html) 命令和 `--generate-cli-skeleton` 参数。您可以选择使用 `input > attributes.json` 将输出定向到某个文件以将其保存。
```
aws ec2 get-instance-types-from-instance-requirements \
--region us-east-1 \
--generate-cli-skeleton input > attributes.json
```
预期输出
```
{
"DryRun": true,
"ArchitectureTypes": [
"i386"
],
"VirtualizationTypes": [
"hvm"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 0
},
"MemoryMiB": {
"Min": 0,
"Max": 0
},
"CpuManufacturers": [
"intel"
],
"MemoryGiBPerVCpu": {
"Min": 0.0,
"Max": 0.0
},
"ExcludedInstanceTypes": [
""
],
"InstanceGenerations": [
"current"
],
"SpotMaxPricePercentageOverLowestPrice": 0,
"OnDemandMaxPricePercentageOverLowestPrice": 0,
"BareMetal": "included",
"BurstablePerformance": "included",
"RequireHibernateSupport": true,
"NetworkInterfaceCount": {
"Min": 0,
"Max": 0
},
"LocalStorage": "included",
"LocalStorageTypes": [
"hdd"
],
"TotalLocalStorageGB": {
"Min": 0.0,
"Max": 0.0
},
"BaselineEbsBandwidthMbps": {
"Min": 0,
"Max": 0
},
"AcceleratorTypes": [
"gpu"
],
"AcceleratorCount": {
"Min": 0,
"Max": 0
},
"AcceleratorManufacturers": [
"nvidia"
],
"AcceleratorNames": [
"a100"
],
"AcceleratorTotalMemoryMiB": {
"Min": 0,
"Max": 0
},
"NetworkBandwidthGbps": {
"Min": 0.0,
"Max": 0.0
},
"AllowedInstanceTypes": [
""
]
},
"MaxResults": 0,
"NextToken": ""
}
```
1. 使用上一步的输出创建 JSON 配置文件，然后按如下方式进行配置：
**注意**
您必须提供 `ArchitectureTypes`、`VirtualizationTypes`、`VCpuCount` 和 `MemoryMiB` 的值。您可以省略其它属性；如果省略，则使用默认值。
有关每个属性及其默认值的描述，请参阅 [get-instance-types-from-instance-requirements](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-types-from-instance-requirements.html)。
1. 对于 `ArchitectureTypes`，请指定一个或多个处理器架构类型。
1. 对于 `VirtualizationTypes`，请指定一个或多个虚拟化类型。
1. 对于 `VCpuCount`，请指定最小和最大 vCPU 数量。要指定没有最低限制，对于 `Min`，请指定 `0`。要指定没有最大限制，请省略 `Max` 参数。
1. 对于 `MemoryMiB`，请指定最小和最大内存量（以 MiB 为单位）。要指定没有最低限制，对于 `Min`，请指定 `0`。要指定没有最大限制，请省略 `Max` 参数。
1. 您可以选择指定一个或多个其他属性来进一步限制返回的实例类型列表。
1. 要预览具有您在 JSON 文件中所指定属性的实例类型，请使用 [get-instance-types-from-instance-requirements](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-types-from-instance-requirements.html) 命令，然后使用 `--cli-input-json` 参数指定 JSON 文件的名称和路径。您可以选择将输出格式设置为以表格格式显示。
```
aws ec2 get-instance-types-from-instance-requirements \
--cli-input-json file://attributes.json \
--output table
```
示例 *attributes.json* 文件
在此示例中，JSON 文件包含所需属性。它们是 `ArchitectureTypes`、`VirtualizationTypes`、`VCpuCount` 和 `MemoryMiB`。此外，还包含可选属性 `InstanceGenerations`。请注意，对于 `MemoryMiB`，可以省略 `Max` 值，指示没有限制。
```
{
"ArchitectureTypes": [
"x86_64"
],
"VirtualizationTypes": [
"hvm"
],
"InstanceRequirements": {
"VCpuCount": {
"Min": 4,
"Max": 6
},
"MemoryMiB": {
"Min": 2048
},
"InstanceGenerations": [
"current"
]
}
}
```
输出示例
```
------------------------------------------
|GetInstanceTypesFromInstanceRequirements|
+----------------------------------------+
|| InstanceTypes ||
|+--------------------------------------+|
|| InstanceType ||
|+--------------------------------------+|
|| c4.xlarge ||
|| c5.xlarge ||
|| c5a.xlarge ||
|| c5ad.xlarge ||
|| c5d.xlarge ||
|| c5n.xlarge ||
|| d2.xlarge ||
...
```
1. 在确定满足您的需求的实例类型后，请记下您使用的实例属性，以便在配置机群请求时可以使用。
# 使用实例权重来管理 EC2 实例集或竞价型实例集的成本和性能
您可以借助实例权重为 EC2 实例集或竞价型实例集中的每种实例类型分配权重，来表示它们相对于彼此的计算容量和性能。实例集可以根据权重使用指定实例类型的任意组合，前提是可以满足所需的目标容量。这有助于管理实例集的成本和性能。
权重表示实例类型占总目标容量的容量单位。
**示例：使用实例权重管理性能**
假设实例集包含两种实例类型，并且每种实例类型都分配到了不同的权重，来反映实现相同性能所需的每种实例类型的数量，如下所示：
+ `m5.large` – 权重：1
+ `m5.2xlarge` – 权重：4
如此分配权重，即表明需要 4 个 `m5.large` 实例才能实现与 1 个 `m5.2xlarge` 实例相同的性能。
要计算给定目标容量所需的每种实例类型的实例数量，请使用以下公式：
`target capacity / weight = number of instances`
如果目标容量为 8 个单位，则实例集可以通过 `m5.large` 或 `m5.2xlarge` 或混合使用两者来满足目标容量，如下所示：
+ 8 个 `m5.large` 实例（容量为 8/权重为 1，表示需要 8 个实例）
+ 2 个 `m5.2xlarge` 实例（容量为 8/权重为 4，表示需要 2 个实例）
+ 4 个 `m5.large` 和 1 个 `m5.2xlarge`
**示例：使用实例权重管理成本**
默认情况下，您指定的价格是*每实例小时* 价格。在使用实例权重功能时，您指定的价格是*每单位小时* 价格。您可以将某种实例类型的价格除以它表示的单位数来计算每单位小时价格。实例集通过将目标容量除以实例权重，计算出要启动的实例数。如果结果不是整数，则 队列会将其向上舍入到下一个整数，以便队列的大小不低于其目标容量。队列可以选择您在启动规范中指定的任意池，即使所启动实例的容量超过请求的目标容量也是如此。
下表提供了用于确定目标容量为 10 的实例集每单位价格的计算示例。
| 实例类型 | 实例权重 | 目标容量 | 启动的实例数 | 每实例小时价格 | 每单位小时价格 |
| --- | --- | --- | --- | --- | --- |
| r3.xlarge | 2 | 10 | 5 (10 除以 2) | 0.05 美元 | 0.025 美元 (0.05 除以 2) |
| r3.8xlarge | 8 | 10 | 2 (10 除以 8，结果向上舍入) | 0.10 美元 | 0.0125 美元 (0.10 除以 8) |
按如下所示使用实例集实例权重，在履行时以最低的单位价格预置池中所需的目标容量：
1. 采用实例（默认设置）或所选单位（如 vCPU、内存、存储或吞吐量）为实例集设置目标容量。
1. 设置每单位价格。
1. 为每个启动规范指定权重，这是实例类型向目标容量提供的单位数。
**实例权重示例**
考虑具有以下配置的实例集请求：
+ 目标容量为 24
+ 一个实例类型为 `r3.2xlarge` 且权重为 6 的启动规范
+ 一个实例类型为 `c3.xlarge` 且权重为 5 的启动规范
每个权重表示相应实例类型向目标容量提供的单位数。如果第一个启动规范提供了最低单位价格（`r3.2xlarge` 每实例小时价格除以 6），则实例集会启动 4 个这样的实例（24 除以 6）。
如果第二个启动规范提供了最低单位价格（`c3.xlarge` 每实例小时价格除以 5），则实例集会启动 5 个这样的实例（24 除以 5，结果向上取整）。
**实例权重和分配策略**
考虑具有以下配置的实例集请求：
+ 目标容量为 30 个竞价型实例
+ 一个实例类型为 `c3.2xlarge` 且权重为 8 的启动规范
+ 一个实例类型为 `m3.xlarge` 且权重为 8 的启动规范
+ 一个实例类型为 `r3.xlarge` 且权重为 8 的启动规范
实例集会启动四个实例（30 除以 8，结果向上取整）。使用 `diversified` 策略时，队列会在所有三个池中各启动一个实例，并在三个池中提供最低每单位价格的那个池中启动第四个实例。
# 使用分配策略确定 EC2 实例集或竞价型实例集如何满足竞价型和按需型容量
在 EC2 实例集或竞价型实例集中使用多个容量池（每个容量池都包含一个实例类型和可用区）时，可以使用*分配策略*来管理 Amazon EC2 如何利用这些容量池满足竞价型和按需型容量。分配策略可以针对可用容量、价格和要使用的实例类型进行优化。竞价型实例和按需型实例有不同的分配策略。
**Topics**
+ [
## 竞价型实例的分配策略
](#ec2-fleet-allocation-strategies-for-spot-instances)
+ [
## 按需型实例的分配策略
](#ec2-fleet-allocation-strategies-for-on-demand-instances)
+ [
## 选择合适的竞价型分配策略
](#ec2-fleet-allocation-use-cases)
+ [
## 维持竞价型实例的目标容量
](#ec2-fleet-maintain-fleet-capacity)
+ [
## 针对按需容量优化实例类型
](#ec2-fleet-on-demand-priority)
## 竞价型实例的分配策略
您的启动配置决定了 EC2 实例集或竞价型实例集可以从中启动竞价型实例的所有可能竞价型容量池（实例类型和可用区）。但在启动实例时，实例集将使用您指定的分配策略从所有可能的池中选择特定的池。
**注意**
（仅限 Linux 实例）如果将竞价型实例配置为启动并开启 [AMD SEV-SNP](sev-snp.md)，则您需要按小时支付额外的使用费，费率为所选实例类型[按需小时费率](https://aws.amazon.com/ec2/pricing/on-demand/)的 10%。如果分配策略使用价格作为输入，则实例集不包括这笔额外费用；只使用竞价型价格。
您可以为竞价型实例指定以下分配策略之一：
**价格容量优化**（推荐）
实例集根据正在启动的实例数确定具有最高可用容量的池。这意味着我们将从我们认为短期内中断概率最低的池中请求竞价型实例。然后，实例集从这些池中价格最低的池请求竞价型实例。
**价格容量优化**分配策略是大多数竞价型工作负载的最佳选择，例如无状态容器化应用程序、微服务、Web 应用程序、数据和分析任务以及批处理。
如果使用的是 AWS CLI，则 EC2 实例集的参数名称为 `price-capacity-optimized`，竞价型实例集的参数名称为 `priceCapacityOptimized`。
**容量优化**
实例集根据正在启动的实例数确定具有最高可用容量的池。这意味着我们将从我们认为短期内中断概率最低的池中请求竞价型实例。
使用竞价型实例，定价会根据长期供需趋势缓慢发生变化，但容量会实时波动。**容量优化**策略通过查看实时容量数据并预测可用性最高的池，自动在可用性最高的池中启动竞价型实例。这适用于因重启工作而导致中断成本更高的工作负载，例如长时间持续集成（CI）、图像和媒体渲染、深度学习以及高性能计算（HPC）工作负载，这些工作负载可能具有与重启工作相关的更高的中断成本。通过实现更低的中断可能性，**容量优化**策略可以降低工作负载的整体成本。
或者，您也可以使用**容量优化优先级**分配策略，该策略带有优先级参数，可从最高到最低优先级对实例类型进行排序。您可以为不同的实例类型设置相同的优先级。实例集首先会针对容量进行优化，但会尽力遵循实例类型的优先级（例如，如果遵循优先级不会显著影响实例集预置最佳容量的能力）。对于必须最大限度地减少中断可能性，同时对某些实例类型的偏好也很重要的工作负载来说，这是一个不错的选择。请注意，为竞价型容量的实例类型设置优先级时，如果按需型分配策略设置为**优先**，那么相同的优先级也会应用于按需型实例。对于竞价型实例集，仅当实例集使用启动模板时，才支持使用优先级。
如果使用的是 AWS CLI，则 EC2 实例集的参数名称为 `capacity-optimized` 和 `capacity-optimized-prioritized`，竞价型实例集的参数名称为 `capacityOptimized` 和 `capacityOptimizedPrioritized`。
**多元化**
竞价型实例 分布在所有 Spot 容量池中。如果使用的是 AWS CLI，则 EC2 实例集和竞价型实例集的参数名称皆为 `diversified`。
**最低价格**（不推荐）
不推荐使用**最低价格**分配策略，因为这对竞价型实例造成的中断风险最高。
竞价型实例来自价格最低并且具有可用容量的池。这是使用 AWS CLI 时的默认策略。不过，建议指定**价格容量优化**分配策略来覆盖默认值。
借助最低价格策略，如果价格最低的池没有可用容量，则竞价型实例将来自价格次低且具有可用容量的池。如果某个池在满足所需容量之前耗尽容量，则实例集将继续从价格次低的池中提取实例来满足请求。为确保达到所需容量，您可能会获得来自多个容量池的竞价型实例。
由于此策略仅考虑实例价格而不考虑容量可用性，因此可能会导致较高的中断率。
最低价格分配策略仅在使用 AWS CLI 时可用。EC2 实例集的参数名称为 `lowest-price`，竞价型实例集的参数名称为 `lowestPrice`。
**要使用的池数量**
在其中分配您的目标 Spot 容量的 Spot 池数量。仅当分配策略设置为**最低价格**时有效。实例集选择价格最低的竞价型池，并在指定数量的竞价型池之间平均分配目标竞价型容量。
请注意，实例集会尽力根据指定的池数量提取竞价型实例。如果池在满足目标容量之前耗尽竞价型容量，则实例集将继续从价格次低的池中提取实例来满足请求。为确保达到目标容量，您可能会从超过指定数量的池接收竞价型实例。同样，如果大多数池没有 Spot 容量，则您可能会从少于指定数量的池接收完整目标容量。
此参数仅在指定**最低价格**分配策略且使用 AWS CLI 时可用。EC2 实例集和竞价型实例集的参数名称皆为 `InstancePoolsToUseCount`。
## 按需型实例的分配策略
您的启动配置决定了 EC2 实例集或竞价型实例集可以从中启动按需型实例的所有可能容量池（实例类型和可用区）。但在启动实例时，实例集将使用您指定的分配策略从所有可能的池中选择特定的池。
您可以为按需型实例指定以下分配策略之一：
**最低价格**
按需型实例来自价格最低且具有可用容量的池。这是默认策略。
如果价格最低的池没有可用容量，则按需型实例将来自价格次低且具有可用容量的池。
如果某个池在满足所需容量之前耗尽容量，则实例集将继续从价格次低的池中提取实例来满足请求。为确保满足所需容量，您可能会获得来自多个容量池的按需型实例。
**优先级**
实例集使用为每个启动模板覆盖分配的优先级，先启动最高优先级的实例类型。此策略不能与基于属性的实例类型选择一起使用。有关如何使用此分配策略的示例，请参阅[针对按需容量优化实例类型](#ec2-fleet-on-demand-priority)。
## 选择合适的竞价型分配策略
您可以选择适当的 Spot 分配策略，从而根据您的使用案例来优化实例集。
### 平衡最低价格和可用容量
为了在价格最低的竞价型容量池与具有最高可用容量的竞价型容量池之间取得平衡，建议使用**价格容量优化**分配策略。该策略根据池的价格以及这些池中竞价型实例的可用容量来决定向哪些池请求竞价型实例。这意味着将从我们认为短期内中断概率最低的池中请求竞价型实例，同时还要考虑价格。
如果实例集运行弹性和无状态的工作负载（包括容器化应用程序、微服务、Web 应用程序、数据和分析作业以及批量处理），则使用**价格容量优化**分配策略来实现最大的成本节约和可用容量。
如果实例集运行的工作负载可能会因重启工作而导致更高的中断成本，则应设置检查点，以便应用程序中断时可从该点重启。通过使用检查点，可以让**价格容量优化**分配策略变得非常适用于这些工作负载，因为其会从价格最低的池中分配容量，这些池同时还具有较低的竞价型实例中断率。
有关使用**价格容量优化**分配策略的 JSON 配置示例，请参阅以下内容：
+ EC2 实例集 – [示例 10：在价格容量优化的实例集中启动竞价型实例](ec2-fleet-examples.md#ec2-fleet-config11)
+ 竞价型实例集 – [示例 11：在 priceCapacityOptimized 实例集中启动竞价型实例](spot-fleet-examples.md#fleet-config11)
### 当工作负载拥有较高中断成本时
如果您运行的工作负载使用价格相似的实例类型，或中断成本非常高，以至于任何成本节约都不足以负担一个轻微中断，则可以选择使用**容量优化**策略。此策略从可用容量最多的 Spot 容量池分配容量，这些容量池中断的可能性更低，从而可降低您工作负载的整体成本。
如果必须将中断的可能性降至最低，但某些实例类型的首选项又很紧要时，则可使用**容量优化优先级**分配策略来表达池的优先级，然后按从最高到最低优先级的顺序设置要使用的实例类型。
请注意，为**容量优化优先级**设置优先级时，如果按需型分配策略设置为**优先**，那么相同的优先级也会应用于按需型实例。另请注意，对于竞价型实例集，仅当实例集使用启动模板时，才支持使用优先级。
有关使用**容量优化**分配策略的 JSON 配置示例，请参阅以下内容：
+ EC2 实例集 – [示例 8：在容量优化的队列中启动竞价型实例](ec2-fleet-examples.md#ec2-fleet-config9)
+ 竞价型实例集 – [示例 9：在容量优化的队列中启动竞价型实例](spot-fleet-examples.md#fleet-config9)
有关使用**容量优化优先级**分配策略的 JSON 配置示例，请参阅以下内容：
+ EC2 实例集 – [示例 9：在具有优先级的容量优化队列中启动竞价型实例](ec2-fleet-examples.md#ec2-fleet-config10)
+ 竞价型实例集 – [示例 10：在具有优先级的容量优化队列中启动竞价型实例](spot-fleet-examples.md#fleet-config10)
### 当您的工作负载时间灵活且可用容量不是一个因素时
如果实例集较小或运行时间较短，则可以使用**价格容量优化**来最大限度地节省成本，同时还要考虑可用容量。
### 当您的实例集较大或运行时间较长时
如果实例集较大或运行时间较长，则可以使用**多元化**策略在多个池间分配竞价型实例来提高实例集的可用性。例如，如果实例集指定 10 个池，目标容量为 100 个实例，则实例集会在每个池中启动 10 个竞价型实例。如果某个池的 Spot 价格超过您在该池中的最高价，您的队列仅 10% 受到影响。使用此策略还可降低您的队列对单个池的 Spot 价格随时间上涨的敏感度。使用**多元化**策略时，实例集不会在竞价型价格等于或高于[按需型价格](https://aws.amazon.com/ec2/pricing/)的任何池中启动竞价型实例。
## 维持竞价型实例的目标容量
在竞价型实例因竞价型价格或竞价型容量池的可用容量发生变化而终止之后，`maintain` 类型的实例集会启动替换竞价型实例。分配策略确定从哪个池启动替换实例，如下所示：
+ 如果分配策略为**价格容量优化**，则实例集在具有最高竞价型实例可用容量的池中启动替换实例，同时还要考虑价格，并确定价格最低且具有高可用容量的池。
+ 如果分配策略为**容量优化**，则实例集在具有最高竞价型实例可用容量的池中启动替换实例。
+ 如果分配策略为**多元化**，则实例集在其余池间分配替换竞价型实例。
## 针对按需容量优化实例类型
EC2 实例集或竞价型实例集尝试满足按需型容量时，默认首先启动价格最低的实例类型。如果按需型分配策略设置为**优先**，则实例集使用优先级确定在满足按需型容量时先使用哪个实例类型。优先级分配给启动模板覆盖，优先级最高的最先启动。
**示例：确定实例类型的优先级**
在本例中，您可以配置三个启动模板覆盖，每个覆盖具有不同的实例类型。
实例类型的按需价格在价格范围内。以下是本例中使用的实例类型，按价格顺序列出，从价格最低的实例类型开始：
+ `m4.large` – 价格最低
+ `m5.large`
+ `m5a.large`
如果您不使用优先级来确定顺序，则实例集将从价格最低的实例类型开始满足按需容量。
但是，假设您有想要先使用的未用 `m5.large` 预留实例。您可以设置启动模板覆盖优先级，以便按优先级顺序使用实例类型，如下所示：
+ `m5.large` – 优先级 1
+ `m4.large` – 优先级 2
+ `m5a.large` – 优先级 3
# 在 EC2 实例集和竞价型实例集中使用“容量再平衡”功能来替换存在风险的竞价型实例
借助“容量再平衡”功能，EC2 实例集或竞价型实例集可以通过主动替换存在中断风险的竞价型实例来维持所需的竞价型容量。竞价型实例面临较高的中断风险时，Amazon EC2 会发送[再平衡建议](rebalance-recommendations.md)。如果启用了“容量再平衡”功能，则再平衡建议会在存在风险的实例中断之前，触发启动新的竞价型实例。
“容量再平衡”功能可在运行中的实例被 Amazon EC2 中断之前，主动使用新竞价型实例扩展实例集，从而帮助维持工作负载的可用性。
**配置 EC2 实例集使用“容量再平衡”功能来启动替换竞价型实例**
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令和 `MaintenanceStrategies` 结构中的相关参数。有关 JSON 配置示例，请参阅[示例 7：配置容量再平衡以启动替换竞价型实例](ec2-fleet-examples.md#ec2-fleet-config8)。
**配置竞价型实例集使用“容量再平衡”功能来启动替换竞价型实例**
您可以使用 Amazon EC2 控制台或 AWS CLI 来配置“容量再平衡”功能。
（控制台）创建竞价型实例集时，选中**容量重新平衡**复选框。有关更多信息，请参阅[使用已定义的参数创建竞价型实例集请求](create-spot-fleet.md#create-spot-fleet-advanced)中的步骤 6.d..
（AWS CLI）使用 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) 命令和 `SpotMaintenanceStrategies` 结构中的相关参数。有关 JSON 配置示例，请参阅[示例 8：配置容量再平衡以启动替换竞价型实例](spot-fleet-examples.md#fleet-config8)。
**Topics**
+ [
## 限制
](#ec2-fleet-capacity-rebalance-limitations)
+ [
## 配置选项
](#ec2-fleet-capacity-rebalance-config-options)
+ [
## 注意事项
](#ec2-fleet-capacity-rebalance-considerations)
## 限制
+ 容量再平衡仅适用于类型为 `maintain` 的机群。
+ 队列运行时，您无法修改容量再平衡设置。要更改容量再平衡设置，您必须删除此队列并创建新队列。
## 配置选项
EC2 实例集和竞价型实例集的 `ReplacementStrategy` 支持以下两个值：
`launch-before-terminate`
Amazon EC2 可以在新的替换竞价型实例启动后终止接收再平衡通知的竞价型实例。如果指定 `launch-before-terminate`，还必须为 `termination-delay` 指定值。启动新的替换实例后，Amazon EC2 将等待 `termination-delay` 的持续时间，然后终止旧实例。对于 `termination-delay`，最短为 120 秒（2 分钟），最长为 7200 秒（2 小时）。
建议仅当您可以预测实例关闭过程完成所需的时长时才使用 `launch-before-terminate`。这将确保只有在关闭过程完成后才终止旧实例。请注意，Amazon EC2 可能会在 `termination-delay` 之前中断旧实例，并发出两分钟警告。
强烈建议不要将 `lowest-price`（EC2 实例集）或 `lowestPrice`（竞价型实例集）分配策略与 `launch-before-terminate` 结合使用，避免让替换竞价型实例面临较高的中断风险。
`launch`
针对现有竞价型实例发出再平衡通知时，Amazon EC2 将启动替换竞价型实例。Amazon EC2 不会终止接收再平衡通知的实例。您可以终止旧实例，也可以使其保持运行状态。在实例运行期间，您需要为它们付费。
## 注意事项
如果针对“容量再平衡”功能配置 EC2 实例集或竞价型实例集，请考虑以下事项：
**在请求中提供尽可能多的 Spot 容量池**
将实例集配置为使用多种实例类型和多个可用区。这提供了在各种 Spot 容量池中启动竞价型实例的灵活性。有关更多信息，请参阅 [灵活地选择实例类型和可用区](spot-best-practices.md#be-instance-type-flexible)。
**避免替换竞价型实例中断的风险升高**
为避免中断风险增加，我们建议使用 `capacity-optimized` 或 `capacity-optimized-prioritized` 分配策略。这些策略确保替换竞价型实例在最佳的竞价型容量池中启动，因此在不久的将来不太可能被中断。有关更多信息，请参阅 [使用价格和容量优化分配策略](spot-best-practices.md#use-capacity-optimized-allocation-strategy)。
如果使用 `lowest-price` 分配策略，替换竞价型实例可能会面临较高的中断风险。这是因为，即使替换竞价型实例可能在启动后不久中断，Amazon EC2 始终会在当时具有可用容量的价格最低池中启动实例。
**只有可用性相同或更好时，Amazon EC2 才会启动新实例**
容量再平衡的目标之一是提高竞价型实例的可用性。如果现有竞价型实例收到再平衡建议，Amazon EC2 只有在新实例提供与现有实例相同或更好的可用性时才会启动新实例。如果新实例的中断风险比现有实例更高，那么 Amazon EC2 将不会启动新实例。但是，Amazon EC2 将继续评测 Spot 容量池，并在可用性改善时启动新实例。
如果 Amazon EC2 没有主动启动新实例，则您的现有实例可能会中断。发生这种情况时，无论新实例的中断风险是否较高，Amazon EC2 都会尝试启动新实例。
**容量再平衡不会提高您的竞价型实例中断率**
当您启用容量再平衡时，它不会提高您的[竞价型实例中断率](spot-interruptions.md)（在 Amazon EC2 需要收回容量时回收的竞价型实例的数量）。然而，如果容量再平衡检测到实例存在中断风险，Amazon EC2 将立即尝试启动新实例。结果是，与存在风险的实例中断后等待 Amazon EC2 启动新实例相比，可能会替换更多实例。
虽然在启用了容量再平衡的情况下您可以更换更多实例，但在中断您的实例之前，您会有更多时间采取行动，从而因为处于主动而非被动地位而受益。使用 [Spot Instance interruption notice](spot-instance-termination-notices.md)（竞价型实例中断通知），您通常最多只有两分钟的时间来正常关闭您的实例。借助容量再平衡提前启动新实例，您可以使现有流程更有可能在存在风险的实例上完成，您可以启动实例关闭程序，并防止在存在风险的实例上安排新工作。您还可以开始准备新启动的实例，以接管应用程序。借助容量再平衡的主动替换，您可以因绝佳的连续性而受益。
作为演示使用容量再平衡的风险和优点的理论示例，请考虑以下场景：
+ 下午 2:00 – 收到针对实例 A 的再平衡建议，Amazon EC2 立即开始尝试启动替换实例 B，让您有时间启动关闭程序。\$1
+ 下午 2:30 - 收到针对实例 B 的再平衡建议，该实例将被替换为实例 C，让您有时间启动关闭程序。\$1
+ 下午 2:32 - 如果未启用容量再平衡，并且如果在下午 2:32 收到针对实例 A 的竞价型实例中断通知，则您最多只有两分钟时间采取行动，但实例 A 将一直运行到此时。
\$1 如果指定了 `launch-before-terminate`，Amazon EC2 将在替换实例上线后终止存在风险的实例。
**Amazon EC2 可以启动新替换竞价型实例，直到已执行容量达到目标容量的两倍**
针对“容量再平衡”功能配置实例集时，实例集会尝试为接收再平衡建议的每个竞价型实例启动新的替换竞价型实例。在竞价型实例收到再平衡建议后，它不再统计为已执行容量的一部分。根据替换策略，Amazon EC2 将在预配置的终止延迟后终止实例，或使其保持运行状态。这使您有机会对实例执行[再平衡操作](rebalance-recommendations.md#rebalancing-actions)。
如果您的队列达到目标容量的两倍，即使替换实例本身收到再平衡建议，它也会停止启动新的替换实例。
例如，您创建的实例集目标容量为 100 个竞价型实例。所有竞价型实例都会收到再平衡建议，这将导致 Amazon EC2 启动 100 个替换竞价型实例。这使已执行的竞价型实例的数量增加到 200 个，是目标容量的两倍。一些替换实例会收到再平衡建议，但由于实例集不能超过其目标容量的两倍，因此不会再启动更多替换实例。
请注意，在实例运行期间，您需要为所有实例付费。
**建议将实例集配置为终止接收再平衡建议的竞价型实例**
如果针对“容量再平衡”功能配置实例集，建议仅在可以预测实例关闭过程完成所需的时长时，才选择 `launch-before-terminate` 和适当的终止延迟。这将确保只有在关闭过程完成后才终止旧实例。
如果您选择自行终止建议再平衡的实例，我们建议您监控机群中的竞价型实例接收的再平衡建议信号。通过监控信号，您可以在 Amazon EC2 中断受影响的实例之前快速对其执行[再平衡操作](rebalance-recommendations.md#rebalancing-actions)，然后您可以手动终止它们。如果您不终止实例，则需要在实例运行期间继续为其付费。Amazon EC2 不会自动终止接收再平衡建议的实例。
您可以使用 Amazon EventBridge 或实例元数据设置通知。有关更多信息，请参阅 [监控再平衡建议信号](rebalance-recommendations.md#monitor-rebalance-recommendations)。
**在计算横向缩减或横向扩展期间的已执行容量时，实例集会排除收到再平衡建议的实例**
如果针对“容量再平衡”功能配置了实例集，并且将目标容量更改为横向缩减或横向扩展，则实例集不会将标记为再平衡的实例计算为已执行容量的一部分，如下所示：
+ 横向缩减 – 如果您降低所需的目标容量，Amazon EC2 将终止未标记为再平衡的实例，直到达到所需容量。标记为再平衡的实例不计入已执行容量。
例如，您创建的竞价型实例集目标容量为 100 个竞价型实例。10 个实例会收到再平衡建议，因此 Amazon EC2 会启动 10 个新的替换实例，从而获得 110 个实例的执行容量。然后，您将目标容量减少到 50 个（横向缩减），但已执行的容量实际上为 60 个实例，因为 Amazon EC2 不会终止标记为再平衡的 10 个实例。您需要手动终止这些实例，也可以让它们保持运行状态。
+ 横向扩展 – 如果您增加所需的目标容量，Amazon EC2 将启动新实例，直到达到所需容量。标记为再平衡的实例不计入已执行容量。
例如，您创建的实例集目标容量为 100 个竞价型实例。10 个实例会收到再平衡建议，因此实例集启动 10 个新的替换实例，从而获得 110 个实例的执行容量。然后，您将目标容量增加到 200（扩展），但已执行的容量实际上为 210 个实例，因为标记为再平衡的 10 个实例不被队列计入目标容量的一部分。您需要手动终止这些实例，也可以让它们保持运行状态。
# 使用容量预留来预留 EC2 实例集中的按需型容量
通过使用按需容量预留，您可以在特定可用区中为按需实例预留计算容量达任意持续时间。您可以将 EC2 队列配置为在启动按需实例时首先使用容量预留。
按需容量预留仅适用于请求类型设置为 `instant` 的 EC2 实例集。
容量预留配置为 `open` 或者 `targeted`。EC2 队列可以将按需实例启动到 `open` 或者 `targeted` 容量预留，如下所示：
+ 如果容量预留为 `open`，具有匹配属性的按需实例会自动在预留容量预留容量中运行。
+ 如果容量预留处于 `targeted` 状态，只有专门定位到其中的按需实例才能在预留容量中运行。这对于使用特定的能力预留或控制何时使用特定的能力预留非常有用。
如果您使用 `targeted` EC2 队列中的容量预留，必须有足够的容量预留才能满足目标按需容量，否则启动失败。为了避免启动失败，请将 `targeted` 能力预留资源组，然后将资源组定位为目标。资源组不需要足够的容量预留；如果在满足目标按需容量之前，其容量预留不足，资源组将剩余的目标容量启动为常规按需容量。
**将容量预留与 EC2 队列结合使用**
1. 将队列配置为类型 `instant`。您不能将容量预留用于其他类型的队列。
1. 将容量预留的使用策略配置为 `use-capacity-reservations-first`。
1. 在启动模板中，**容量预留**中，选择**打开**或者**按组列分类的目标**。如果您选择**按组列分类的目标**中，指定能力预留资源组 ID。
当队列尝试满足按需容量时，如果发现多个实例池具有未使用的匹配容量预留，则会根据按需分配策略确定启动按需实例的池（`lowest-price` 或者 `prioritized`)。
**相关资源**
+ 有关如何将实例集配置为使用容量预留来实现按需容量的 CLI 示例，请参阅[EC2 实例集 CLI 配置示例](ec2-fleet-examples.md)，特别是示例 5 到 7。
+ 有关指导您完成创建容量预留、在实例集中使用容量预留以及查看剩余容量预留数量的教程，请参阅[教程：使用目标容量预留配置 EC2 实例集以启动按需型实例](ec2-fleet-launch-on-demand-instances-using-targeted-capacity-reservations-walkthrough.md)
+ 有关配置容量预留的信息，请参阅 [使用 EC2 按需容量预留来预留计算容量](ec2-capacity-reservations.md) 和[按需容量预留常见问题](https://aws.amazon.com/ec2/faqs/#On-Demand_Capacity_Reservation)。
# 使用 EC2 实例集
要开始使用 EC2 实例集，请创建一个请求，其中包含总目标容量、按需型容量、竞价型容量，以及指定实例集中实例配置的启动模板。您可以选择指定其他参数，也可以让实例集使用默认值。您还可以在创建实例集时标记实例集请求及其实例和卷。
实例集在有可用容量时启动按需型实例，在最高价超过 Spot 价格并且有可用容量时启动竞价型实例。
实例集启动后，即可描述实例集请求、实例集中的实例以及任何实例集事件。您也可以根据需要分配额外的标签。
如需更改任何实例集参数（例如总目标容量），则可以修改该实例集，前提是该实例集已配置为保持容量。提交一次性请求后，您无法修改其容量。
实例集请求在过期或您删除它之前一直有效。删除实例集请求时，您可以终止实例或让其保持运行状态。如果选择让实例保持运行，按需型实例会持续运行至您将其终止，竞价型实例会持续运行至遇到中断或您将其终止。
**Topics**
+ [
# EC2 队列请求状态
](EC2-fleet-states.md)
+ [
# EC2 队列先决条件
](ec2-fleet-prerequisites.md)
+ [
# 创建 EC2 实例集
](create-ec2-fleet.md)
+ [
# 标记新的或现有的 EC2 实例集请求及其启动的实例和卷
](tag-ec2-fleet.md)
+ [
# 描述 EC2 实例集、其实例及其事件
](describe-ec2-fleet.md)
+ [
# 修改 EC2 队列
](modify-ec2-fleet.md)
+ [
# 删除 EC2 实例集请求和实例集中的实例
](delete-fleet.md)
# EC2 队列请求状态
EC2 实例集请求可以处于多种状态之一，每种状态表示请求生命周期及其实例管理的不同阶段。
EC2 队列请求可以处于以下某种状态：
`submitted`
EC2 队列 正在接受评估，并且 Amazon EC2 正准备启动目标数量的实例。如果请求超出实例集限制，则会被立即删除。
`active`
EC2 队列 请求已验证，并且 Amazon EC2 正在尝试使正在运行的实例保持目标数量。请求会保持这一状态，直到其被修改或删除。
`modifying`
正在修改 EC2 队列 请求。请求会保持这一状态，直到修改全部完成或请求被删除。只能修改 `maintain` 队列类型。此状态不适用于其他请求类型。
`deleted_running`
已删除 EC2 实例集请求，且不启动其他竞价型实例。其现有实例将继续运行，直至中断或被手动终止。请求会保持此状态，直到所有实例都已中断或终止。删除 EC2 队列 请求后，只有类型 `maintain` 或 `request` 的 EC2 队列 才能有正在运行的实例。不支持包含正在运行实例的已删除 `instant` 队列。此状态不适用于 `instant` 队列。
`deleted_terminating`
EC2 队列 请求已删除，正在终止其实例。请求会保持此状态，直到所有实例都已终止。
`deleted`
EC2 队列 请求已删除，没有正在运行的实例。请求将在其实例终止两天后被删除。
# EC2 队列先决条件
**Topics**
+ [
## 启动模板
](#ec2-fleet-prerequisites-launch-template)
+ [
## EC2 队列的服务相关角色
](#ec2-fleet-service-linked-role)
+ [
## 授予对用于加密的 AMI 和 EBS 快照的客户托管密钥的访问权限
](#ec2-fleet-service-linked-roles-access-to-cmks)
+ [
## EC2 实例集用户的权限
](#ec2-fleet-iam-users)
## 启动模板
启动模板指定要启动的实例的相关配置信息，例如实例类型和可用区。有关启动模板的更多信息，请参阅[在 Amazon EC2 启动模板中存储实例启动参数](ec2-launch-templates.md)。
## EC2 队列的服务相关角色
`AWSServiceRoleForEC2Fleet` 角色授予 EC2 实例集权限以代表您请求、启动、终止和标记实例。Amazon EC2 使用此服务相关角色来完成以下操作：
+ `ec2:RunInstances` – 启动实例。
+ `ec2:RequestSpotInstances` – 请求 Spot 实例。
+ `ec2:TerminateInstances` – 终止实例。
+ `ec2:DescribeImages`：描述实例的亚马逊机器映像（AMI）。
+ `ec2:DescribeInstanceStatus`：描述实例的状态。
+ `ec2:DescribeSubnets`：描述实例的子网。
+ `ec2:CreateTags` – 将标签添加到 EC2 队列、实例和卷中。
确保此角色存在，然后才使用 AWS CLI 或 API 来创建 EC2 实例集。
**注意**
`instant` EC2 队列不需要此角色。
要创建该角色，请如下使用 IAM 控制台。
**为 EC2 队列创建 AWSServiceRoleForEC2Fleet 角色**
1. 通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择 **Roles**（角色）。
1. 选择**创建角色**。
1. 在**选择受信任的实体**页面上，请执行以下操作：
1. 在**可信实体类型**中选择 **AWS 服务**。
1. 在**使用案例**下，对于**服务或使用案例**，选择 **EC2 - 实例集**。
**提示**
请务必选择 **EC2 - 实例集**。如果您选择 **EC2**，则 **EC2 - 实例集**使用案例不会出现在**使用案例**列表中。**EC2 - 实例集**使用案例将自动创建具有所需 IAM 权限的策略，并建议将 **AWSServiceRoleForEC2Fleet** 作为角色名称。
1. 选择**下一步**。
1. 在**添加权限**页面上，选择**下一步**。
1. 在**命名、检查并创建**页面上，选择**创建角色**。
如果您不再需要使用 EC2 队列，我们建议您删除 **AWSServiceRoleForEC2Fleet** 角色。当此角色从您的账户中删除后，如果您创建其他队列，可再次创建此角色。
有关更多信息，请参阅《IAM 用户指南》**中的[服务相关角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create-service-linked-role.html)。
## 授予对用于加密的 AMI 和 EBS 快照的客户托管密钥的访问权限
如果在 EC2 实例集中指定[加密的 AMI](AMIEncryption.md) 或加密的 Amazon EBS 快照，并且您使用 AWS KMS 密钥进行加密，则必须授予 **AWSServiceRoleForEC2Fleet** 角色使用客户托管式密钥的权限，以便 Amazon EC2 可以代表您启动实例。为此，您必须在客户托管密钥中添加授权，如以下过程中所示。
在提供权限时，授权是密钥策略的替代方法。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[使用授权](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)和[在 AWS KMS 中使用密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)。
**为 AWSServiceRoleForEC2Fleet 角色授予使用客户托管密钥的权限**
+ 使用 [create-grant](https://docs.aws.amazon.com/cli/latest/reference/kms/create-grant.html) 命令在客户托管密钥中添加授权，并指定授予权限的主体（**AWSServiceRoleForEC2Fleet** 服务相关角色），以执行授权允许的操作。客户托管密钥由 `key-id` 参数和客户托管密钥的 ARN 指定。委托人是由 `grantee-principal` 参数和 **AWSServiceRoleForEC2Fleet** 服务相关角色的 ARN 指定的。
```
aws kms create-grant \
--region us-east-1 \
--key-id arn:aws:kms:us-east-1:444455556666:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--grantee-principal arn:aws:iam::111122223333:role/AWSServiceRoleForEC2Fleet \
--operations "Decrypt" "Encrypt" "GenerateDataKey" "GenerateDataKeyWithoutPlaintext" "CreateGrant" "DescribeKey" "ReEncryptFrom" "ReEncryptTo"
```
## EC2 实例集用户的权限
如果用户打算创建或管理 EC2 实例集，请确保为其授予所需权限。
**为 EC2 实例集创建策略**
1. 打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择**策略**。
1. 选择 **Create policy**。
1. 在**创建策略**页面上，选择 **JSON** 选项卡，将文本替换为以下内容，并选择**查看策略**。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:ListRoles",
"iam:PassRole",
"iam:ListInstanceProfiles"
],
"Resource":"arn:aws:iam::123456789012:role/DevTeam*"
}
]
}
```
------
`ec2:*` 为用户授予调用所有 Amazon EC2 API 操作的权限。要将用户限制到特定 Amazon EC2 API 操作，请改为指定这些操作。
用户必须具有相应权限，可以调用 `iam:ListRoles` 操作以枚举现有 IAM 角色、调用 `iam:PassRole` 操作以指定 EC2 实例集角色以及调用 `iam:ListInstanceProfiles` 操作以枚举现有实例配置文件。
（可选）要允许用户使用 IAM 控制台创建角色或实例配置文件，还必须在策略中添加以下操作：
+ `iam:AddRoleToInstanceProfile`
+ `iam:AttachRolePolicy`
+ `iam:CreateInstanceProfile`
+ `iam:CreateRole`
+ `iam:GetRole`
+ `iam:ListPolicies`
1. 在**查看策略**页面上，输入策略名称和描述，然后选择**创建策略**。
1. 要提供访问权限，请为您的用户、组或角色添加权限：
+ AWS IAM Identity Center 中的用户和群组：
创建权限集合。按照《AWS IAM Identity Center 用户指南》**中[创建权限集](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html)的说明进行操作。
+ 通过身份提供者在 IAM 中托管的用户：
创建适用于身份联合验证的角色。按照《IAM 用户指南》**中[针对第三方身份提供者创建角色（联合身份验证）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html)的说明进行操作。
+ IAM 用户：
+ 创建您的用户可以担任的角色。按照《IAM 用户指南》**中[为 IAM 用户创建角色](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html)的说明进行操作。
+ （不推荐使用）将策略直接附加到用户或将用户添加到用户组。按照《IAM 用户指南》**中[向用户添加权限（控制台）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)中的说明进行操作。
# 创建 EC2 实例集
要创建 EC2 实例集，请在 JSON 文件中定义实例集配置，然后使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令引用该文件。在 JSON 文件中，您必须指定实例集的总目标容量、竞价型实例和按需型实例的单独目标容量，以及用于定义实例集中实例配置（例如 AMI、实例类型、子网、可用区、一个或多个安全组）的启动模板。您可以选择指定其他配置，例如用于覆盖启动模板配置的参数、从 EC2 容量池中选择竞价型实例和按需型实例的分配策略，以及愿意为实例集支付的最高金额。有关更多信息，请参阅 [EC2 实例集或竞价型实例集配置选项](ec2-fleet-configuration-strategies.md)。
EC2 实例集在有可用容量时启动按需型实例，在最高价超过竞价型实例价格并且有可用容量时启动竞价型实例。
如果实例集包含竞价型实例且类型为 `maintain`，Amazon EC2 会尝试在竞价型实例中断时维持实例集的目标容量。
## EC2 队列限制
以下限制适用于 EC2 队列。
+ EC2 实例集仅可通过 [Amazon EC2 API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet.html)、[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html)、[AWS SDK](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet.html#API_CreateFleet_SeeAlso) 和 [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html) 创建。
+ EC2 队列请求不能跨 AWS 区域。您需要为每个区域创建单独的 EC2 队列。
+ EC2 队列请求不能跨同一可用区内的不同子网。
## 创建 EC2 实例集
要使用 EC2 实例集启动实例的实例集，只需在实例集请求中指定以下参数，实例集会使用其他参数的默认值：
+ `LaunchTemplateId` 或 `LaunchTemplateName` – 指定要使用的启动模板（其中包含要启动的实例的参数，例如实例类型和可用区）
+ `TotalTargetCapacity` – 指定机群的总目标容量
+ `DefaultTargetCapacityType` – 指定默认购买选项是按需型还是竞价型
要覆盖启动模板中指定的参数，可指定一个或多个覆盖。每个覆盖可以有不同的实例类型、可用区、子网和最高价，并且可以包含不同的权重容量。除了指定实例类型外，还可以指定实例必须具有的属性，Amazon EC2 将使用这些属性标识所有实例类型。有关更多信息，请参阅[指定 EC2 实例集或竞价型实例集的实例类型选择属性](ec2-fleet-attribute-based-instance-type-selection.md)。
对于 `instant` 类型的 EC2 实例集，可以指定 Systems Manager 参数而非 AMI ID。您可以在覆盖或启动模板中指定 Systems Manager 参数。有关更多信息，请参阅 [使用 Systems Manager 参数而非 AMI ID](create-launch-template.md#use-an-ssm-parameter-instead-of-an-ami-id)。
在 JSON 文件中指定实例集参数。有关可以指定的所有可能参数的信息，请参阅[查看所有的 EC2 实例集配置选项](#ec2-fleet-cli-skeleton)。
有关实例集配置示例，请参阅 [EC2 实例集 CLI 配置示例](ec2-fleet-examples.md)。
目前没有控制台支持创建 EC2 Fleet。
**创建 EC2 实例集**
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令创建实例集，并指定包含实例集配置参数的 JSON 文件。
```
aws ec2 create-fleet --cli-input-json file://file_name.json
```
以下是 `request` 或 `maintain` 类型的队列的示例输出。
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE"
}
```
以下是启动了目标容量的 `instant` 类型队列的示例输出。
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE",
"Errors": [],
"Instances": [
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c5.large",
"AvailabilityZone": "us-east-1a"
}
},
"Lifecycle": "on-demand",
"InstanceIds": [
"i-1234567890abcdef0",
"i-9876543210abcdef9"
],
"InstanceType": "c5.large",
"Platform": null
},
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c4.large",
"AvailabilityZone": "us-east-1a"
}
},
"Lifecycle": "on-demand",
"InstanceIds": [
"i-5678901234abcdef0",
"i-5432109876abcdef9"
]
]
}
```
以下是启动了部分目标容量并且出现“无法启动实例”错误的 `instant` 类型队列的示例输出。
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE",
"Errors": [
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c4.xlarge",
"AvailabilityZone": "us-east-1a",
}
},
"Lifecycle": "on-demand",
"ErrorCode": "InsufficientInstanceCapacity",
"ErrorMessage": ""
},
],
"Instances": [
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c5.large",
"AvailabilityZone": "us-east-1a"
}
},
"Lifecycle": "on-demand",
"InstanceIds": [
"i-1234567890abcdef0",
"i-9876543210abcdef9"
]
]
}
```
以下是未启动任何实例的 `instant` 类型队列的示例输出。
```
{
"FleetId": "fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE",
"Errors": [
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c4.xlarge",
"AvailabilityZone": "us-east-1a",
}
},
"Lifecycle": "on-demand",
"ErrorCode": "InsufficientCapacity",
"ErrorMessage": ""
},
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-01234a567b8910abcEXAMPLE",
"Version": "1"
},
"Overrides": {
"InstanceType": "c5.large",
"AvailabilityZone": "us-east-1a",
}
},
"Lifecycle": "on-demand",
"ErrorCode": "InsufficientCapacity",
"ErrorMessage": ""
},
],
"Instances": []
}
```
## 创建 EC2 实例集来替换运行状况不佳的竞价型实例
EC2 队列每 2 分钟检查一次队列中实例的运行状况。实例的运行状况为 `healthy` 或 `unhealthy`。
EC2 队列 将使用 Amazon EC2 提供的状态检查来确定实例的运行状况。如果在连续三次运行状况检查中，实例状态检查或系统状态检查的状态有任一项为 `unhealthy`，则确定该实例的运行状况为 `impaired`。有关更多信息，请参阅[Amazon EC2 实例的状态检查](monitoring-system-instance-status-check.md)。
您可以配置您的队列以替换运行状况不佳的竞价型实例。将 `ReplaceUnhealthyInstances` 设置为 `true` 以后，若竞价型实例报告为 `unhealthy` 则将其替换。在替换运行状况不佳的竞价型实例时，队列可能在几分钟内降至其目标容量之下。
**要求**
+ 仅对保持目标容量的 EC2 队列（类型 `maintain` 的队列）支持运行状况检查替换，不支持类型为 `request` 或 `instant` 的队列。
+ 仅对竞价型实例支持运行状况检查替换。对于 按需型实例 不支持此功能。
+ 您可以将 EC2 队列配置为仅在您创建它时替换运行状况不佳的实例。
+ 用户仅在其有权调用 `ec2:DescribeInstanceStatus` 操作时才能使用运行状况检查替换。
**配置 EC2 实例集 以替换运行状况不佳的竞价型实例**
1. 使用[创建 EC2 实例集](#create-ec2-fleet-procedure)中用于创建 EC2 实例集的信息。
1. 要将实例集配置为替换运行状况不佳的竞价型实例，请在 JSON 文件中将 `ReplaceUnhealthyInstances` 指定 `true`。
## 查看所有的 EC2 实例集配置选项
要查看 EC2 机群配置参数的完整列表，可以生成 JSON 文件。有关每个参数的描述，请参阅 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html)。
**通过所有可能的 EC2 实例集参数生成 JSON 文件**
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) (AWS CLI) 命令和 `--generate-cli-skeleton` 参数生成 EC2 机群 JSON 文件，并将输出定向到某个文件以将其保存。
```
aws ec2 create-fleet \
--generate-cli-skeleton input > ec2createfleet.json
```
下面是示例输出。
```
{
"DryRun": true,
"ClientToken": "",
"SpotOptions": {
"AllocationStrategy": "price-capacity-optimized",
"MaintenanceStrategies": {
"CapacityRebalance": {
"ReplacementStrategy": "launch"
}
},
"InstanceInterruptionBehavior": "hibernate",
"InstancePoolsToUseCount": 0,
"SingleInstanceType": true,
"SingleAvailabilityZone": true,
"MinTargetCapacity": 0,
"MaxTotalPrice": ""
},
"OnDemandOptions": {
"AllocationStrategy": "prioritized",
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
},
"SingleInstanceType": true,
"SingleAvailabilityZone": true,
"MinTargetCapacity": 0,
"MaxTotalPrice": ""
},
"ExcessCapacityTerminationPolicy": "termination",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "",
"LaunchTemplateName": "",
"Version": ""
},
"Overrides": [
{
"InstanceType": "r5.metal",
"MaxPrice": "",
"SubnetId": "",
"AvailabilityZone": "",
"WeightedCapacity": 0.0,
"Priority": 0.0,
"Placement": {
"AvailabilityZone": "",
"Affinity": "",
"GroupName": "",
"PartitionNumber": 0,
"HostId": "",
"Tenancy": "dedicated",
"SpreadDomain": "",
"HostResourceGroupArn": ""
},
"InstanceRequirements": {
"VCpuCount": {
"Min": 0,
"Max": 0
},
"MemoryMiB": {
"Min": 0,
"Max": 0
},
"CpuManufacturers": [
"amd"
],
"MemoryGiBPerVCpu": {
"Min": 0.0,
"Max": 0.0
},
"ExcludedInstanceTypes": [
""
],
"InstanceGenerations": [
"previous"
],
"SpotMaxPricePercentageOverLowestPrice": 0,
"OnDemandMaxPricePercentageOverLowestPrice": 0,
"BareMetal": "included",
"BurstablePerformance": "required",
"RequireHibernateSupport": true,
"NetworkInterfaceCount": {
"Min": 0,
"Max": 0
},
"LocalStorage": "excluded",
"LocalStorageTypes": [
"ssd"
],
"TotalLocalStorageGB": {
"Min": 0.0,
"Max": 0.0
},
"BaselineEbsBandwidthMbps": {
"Min": 0,
"Max": 0
},
"AcceleratorTypes": [
"inference"
],
"AcceleratorCount": {
"Min": 0,
"Max": 0
},
"AcceleratorManufacturers": [
"amd"
],
"AcceleratorNames": [
"a100"
],
"AcceleratorTotalMemoryMiB": {
"Min": 0,
"Max": 0
}
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 0,
"OnDemandTargetCapacity": 0,
"SpotTargetCapacity": 0,
"DefaultTargetCapacityType": "on-demand",
"TargetCapacityUnitType": "memory-mib"
},
"TerminateInstancesWithExpiration": true,
"Type": "instant",
"ValidFrom": "1970-01-01T00:00:00",
"ValidUntil": "1970-01-01T00:00:00",
"ReplaceUnhealthyInstances": true,
"TagSpecifications": [
{
"ResourceType": "fleet",
"Tags": [
{
"Key": "",
"Value": ""
}
]
}
],
"Context": ""
}
```
# 标记新的或现有的 EC2 实例集请求及其启动的实例和卷
要对 EC2 实例集请求及其启动的实例和卷进行分类与管理，可以使用自定义元数据标记它们。您可以在创建 EC2 实例集请求之时或之后为其分配标签。同理，可以在实例集启动实例和卷之时或之后为实例和卷分配标签。
在标记队列请求时，不会自动标记队列启动的实例和卷。您需要明确标记队列启动的实例和卷。您可以选择仅将标签分配给实例集请求，仅分配给实例集启动的实例，仅分配给附加到实例集启动的实例的卷，或者分配给所有这三种内容。
**注意**
对于 `instant` 队列类型，您可以标记附加到按需实例和Spot 实例的卷。对于 `request` 或 `maintain` 队列类型，您只能标记附加到按需实例的卷。
有关标签的工作原理的更多信息，请参阅[标记 Amazon EC2 资源](Using_Tags.md)。
**先决条件**
授予用户标记资源的权限。有关更多信息，请参阅 [示例：标记资源](ExamplePolicies_EC2.md#iam-example-taggingresources)。
**授予用户标记资源的权限**
创建包含以下内容的 IAM policy：
+ `ec2:CreateTags` 操作。这将授予用户创建标签的权限。
+ `ec2:CreateFleet` 操作。这将授予用户创建 EC2 实例集请求的权限。
+ 对于 `Resource`，我们建议您指定 `"*"`。这允许用户标记所有资源类型。
要提供访问权限，请为您的用户、组或角色添加权限：
+ AWS IAM Identity Center 中的用户和群组：
创建权限集合。按照《AWS IAM Identity Center 用户指南》**中[创建权限集](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html)的说明进行操作。
+ 通过身份提供者在 IAM 中托管的用户：
创建适用于身份联合验证的角色。按照《IAM 用户指南》**中[针对第三方身份提供者创建角色（联合身份验证）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html)的说明进行操作。
+ IAM 用户：
+ 创建您的用户可以担任的角色。按照《IAM 用户指南》**中[为 IAM 用户创建角色](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html)的说明进行操作。
+ （不推荐使用）将策略直接附加到用户或将用户添加到用户组。按照《IAM 用户指南》**中[向用户添加权限（控制台）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)中的说明进行操作。
**标记新的 EC2 队列 请求**
要在创建时标记 EC2 队列请求，请在用于创建该队列的 [JSON 文件](create-ec2-fleet.md#ec2-fleet-cli-skeleton)中指定键值对。`ResourceType` 的值必须为 `fleet`。如果指定其他值，队列请求失败。
**标记 EC2 队列启动的实例和卷**
要在队列启动实例和卷时标记它们，请在 EC2 队列请求中引用的[启动模板](create-launch-template.md)中指定标签。
**注意**
您无法标记附加到 `request` 或 `maintain` 队列类型启动的 Spot 实例的卷。
**标记现有的 EC2 实例集请求、实例和卷**
使用 [create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html) 命令标记现有的资源。
```
aws ec2 create-tags \
--resources fleet-12a34b55-67cd-8ef9-ba9b-9208dEXAMPLE i-1234567890abcdef0 vol-1234567890EXAMPLE \
--tags Key=purpose,Value=test
```
# 描述 EC2 实例集、其实例及其事件
您可以描述 EC2 机群配置、EC2 机群中的实例，以及 EC2 机群的历史事件。
**Topics**
+ [
## 描述 EC2 机群
](#describe-all-ec2-fleets)
+ [
## 描述 EC2 实例集中的所有实例
](#describe-instances-in-ec2-fleet)
+ [
## 描述 EC2 实例集的事件历史记录
](#describe-ec2-fleet-event-history)
## 描述 EC2 机群
------
#### [ AWS CLI ]
**描述 EC2 实例集**
使用 [describe-fleets](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-fleets.html) 命令。
```
aws ec2 describe-fleets \
--fleet-ids fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
下面是示例输出。
```
{
"Fleets": [
{
"ActivityStatus": "fulfilled",
"CreateTime": "2022-02-09T03:35:52+00:00",
"FleetId": "fleet-364457cd-3a7a-4ed9-83d0-7b63e51bb1b7",
"FleetState": "active",
"ExcessCapacityTerminationPolicy": "termination",
"FulfilledCapacity": 2.0,
"FulfilledOnDemandCapacity": 0.0,
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "$Latest"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"OnDemandTargetCapacity": 0,
"SpotTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
},
"TerminateInstancesWithExpiration": false,
"Type": "maintain",
"ReplaceUnhealthyInstances": false,
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"InstanceInterruptionBehavior": "terminate"
},
"OnDemandOptions": {
"AllocationStrategy": "lowestPrice"
}
}
]
}
```
------
#### [ PowerShell ]
**描述 EC2 实例集**
使用 [Get-EC2FleetList](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2FleetList.html) cmdlet。
```
Get-EC2FleetList `
-FleetId fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
------
## 描述 EC2 实例集中的所有实例
正在运行的实例的返回列表将定期刷新，或可能过时。
------
#### [ AWS CLI ]
**描述指定 EC2 实例集中的实例**
使用 [describe-fleet-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-fleet-instances.html) 命令。
```
aws ec2 describe-fleet-instances \
--fleet-id fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
下面是示例输出。
```
{
"ActiveInstances": [
{
"InstanceId": "i-09cd595998cb3765e",
"InstanceHealth": "healthy",
"InstanceType": "m4.large",
"SpotInstanceRequestId": "sir-86k84j6p"
},
{
"InstanceId": "i-09cf95167ca219f17",
"InstanceHealth": "healthy",
"InstanceType": "m4.large",
"SpotInstanceRequestId": "sir-dvxi7fsm"
}
],
"FleetId": "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
```
------
#### [ PowerShell ]
**描述指定 EC2 实例集中的实例**
使用 [Get-EC2FleetInstanceList](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2FleetInstanceList.html) cmdlet。
```
Get-EC2FleetInstanceList `
-FleetId fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
------
## 描述 EC2 实例集的事件历史记录
有关事件历史记录中事件的更多信息，请参阅[EC2 队列 事件类型](monitor-ec2-fleet-using-eventbridge.md#ec2-fleet-event-types)。
------
#### [ AWS CLI ]
**描述指定 EC2 实例集的事件**
使用 [describe-fleet-history](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-fleet-history.html) 命令。
```
aws ec2 describe-fleet-history \
--fleet-id fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--start-time 2020-06-01T00:00:00Z
```
下面是示例输出。
```
{
"HistoryRecords": [
{
"EventInformation": {
"EventSubType": "submitted"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:05.000Z"
},
{
"EventInformation": {
"EventSubType": "active"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:15.000Z"
},
{
"EventInformation": {
"EventDescription": "t2.small, ami-07c8bc5c1ce9598c3, ...",
"EventSubType": "progress"
},
"EventType": "fleetRequestChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
},
{
"EventInformation": {
"EventDescription": "{\"instanceType\":\"t2.small\", ...}",
"EventSubType": "launched",
"InstanceId": "i-083a1c446e66085d2"
},
"EventType": "instanceChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
},
{
"EventInformation": {
"EventDescription": "{\"instanceType\":\"t2.small\", ...}",
"EventSubType": "launched",
"InstanceId": "i-090db02406cc3c2d6"
},
"EventType": "instanceChange",
"Timestamp": "2020-09-01T18:26:17.000Z"
}
],
"FleetId": "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"LastEvaluatedTime": "1970-01-01T00:00:00.000Z",
"StartTime": "2020-06-01T00:00:00.000Z"
}
```
------
#### [ PowerShell ]
**描述指定 EC2 实例集的事件**
使用 [Get-EC2FleetHistory](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2FleetHistory.html) cmdlet。
```
Get-EC2FleetHistory `
-FleetId fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE `
-UtcStartTime 2020-06-01T00:00:00Z
```
------
# 修改 EC2 队列
您可以修改 EC2 实例集的总目标容量、竞价型容量和按需型容量。您还可以修改，如果新的总目标容量减少到实例集当前大小以下，是否应终止正在运行的实例。
## 注意事项
修改 EC2 实例集时请考虑以下几点：
+ **实例集类型** – 您只能修改 `maintain` 类型的 EC2 实例集，不能修改 `request` 或 `instant` 类型的 EC2 实例集。
+ **实例集参数** – 您可以修改 EC2 实例集的以下参数：
+ `target-capacity-specification` – 增加或减少以下目标容量：
+ `TotalTargetCapacity`
+ `OnDemandTargetCapacity`
+ `SpotTargetCapacity`
+ `excess-capacity-termination-policy` – 当 EC2 队列的总目标容量降到队列的当前大小以下时是否应终止正在运行的实例。有效值为：
+ `no-termination`
+ `termination`
+ **增加总目标容量时的实例集行为** – 在增加总目标容量时，EC2 实例集会根据为 `DefaultTargetCapacityType` 指定的实例购买选项（按需型实例或竞价型实例）和指定的[分配策略](ec2-fleet-allocation-strategy.md)，启动额外的实例。
+ **减少竞价型目标容量时的实例集行为** – 在减少竞价型目标容量时，EC2 实例集会删除超过新目标容量的任何打开的请求。您可以请求实例集终止竞价型实例，直到实例集的大小达到新目标容量。当 EC2 实例集因目标容量下降而终止某个竞价型实例时，该实例将收到一条竞价型实例中断通知。
根据分配策略选择要终止的实例：
+ `capacity-optimized`：终止可用容量最少的池中的实例。
+ `price-capacity-optimized`：使用价格和可用容量的组合：终止可用容量最少且价格最高的池中的实例。
+ `diversified`：终止所有池中的实例。
+ `lowest-price`：终止价格最高的池中的实例。
您也可以请求 EC2 实例集保持实例集的当前大小，而不替换任何已中断的竞价型实例或者手动终止的实例。
+ **实例集状态** – 您可以修改处于 `submitted` 或 `active` 状态的 EC2 实例集。当您修改队列时，它会进入 `modifying` 状态。
## 修改 EC2 实例集的命令
------
#### [ AWS CLI ]
**修改 EC2 实例集的总目标容量**
使用 [modify-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-fleet.html) 命令。
```
aws ec2 modify-fleet \
--fleet-id fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--target-capacity-specification TotalTargetCapacity=20
```
如果要减少目标容量，但希望保持实例集的当前大小，可按如下方式修改上一个示例。
```
aws ec2 modify-fleet \
--fleet-id fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--target-capacity-specification TotalTargetCapacity=10 \
--excess-capacity-termination-policy no-termination
```
------
#### [ PowerShell ]
**修改 EC2 实例集的总目标容量**
使用 [Edit-EC2Fleet](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2Fleet.html) cmdlet。
```
Edit-EC2Fleet `
-FleetId "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TargetCapacitySpecification_TotalTargetCapacity 20
```
如果要减少目标容量，但希望保持实例集的当前大小，可按如下方式修改上一个示例。
```
Edit-EC2Fleet `
-FleetId "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TargetCapacitySpecification_TotalTargetCapacity 20 `
-ExcessCapacityTerminationPolicy "NoTermination"
```
------
# 删除 EC2 实例集请求和实例集中的实例
如果不再需要某个 EC2 实例集请求，可以将其删除。删除实例集请求后，将取消与实例集关联的所有竞价型实例请求，避免启动任何新的竞价型实例。
删除 EC2 实例集请求后，您还必须指定是否要终止其所有实例。包括按需型实例和竞价型实例。对于 `instant` 实例集，EC2 实例集必须在删除实例集时终止实例。不支持包含正在运行实例的已删除 `instant` 队列。
**警告**
**终止实例是永久且不可逆转的。**
终止一个实例后，您将无法再连接到该实例，而且也无法对其进行恢复操作。被配置为在终止后删除的所有连接的 Amazon EBS 卷也将被永久删除并且无法恢复。实例存储卷中存储的所有数据将永久丢失。有关更多信息，请参阅 [实例终止的工作原理](how-ec2-instance-termination-works.md)。
在终止实例之前，请务必确保已将需要在终止后保留的所有数据备份到持久存储中。
如果您指定在实例集请求删除后必须终止实例，则实例集请求会进入 `deleted_terminating` 状态。否则，队列会进入 `deleted_running` 状态，并且实例会继续运行，直到遇到中断或您手动将其终止。
**限制**
+ 在单次操作中，最多可以删除 25 个 `instant` 类型的实例集。
+ 在单次操作中，最多可以删除 100 个 `maintain` 或 `request` 类型的实例集。
+ 在单次操作中，最多可以删除 125 个实例集，前提是不超过上述指定的各类实例集的限额。
+ 如果要删除的实例集超过指定数量，将不会删除任何实例集。
+ 不支持包含正在运行实例的已删除 `instant` 队列。当您删除 `instant` 实例集时，Amazon EC2 会自动终止其所有实例。对于具有超过 1000 个实例的 `instant` 实例集，删除请求可能会失败。如果您的实例集有超过 1000 个实例，请先手动终止大多数实例，留下 1000 个或更少的实例。然后删除实例集，剩余的实例将自动终止。
------
#### [ AWS CLI ]
**删除 EC2 实例集请求并终止其实例**
使用带 `--terminate-instances` 选项的 [delete-fleets](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-fleets.html) 命令。
```
aws ec2 delete-fleets \
--fleet-ids fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--terminate-instances
```
下面是示例输出。
```
{
"UnsuccessfulFleetDeletions": [],
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_terminating",
"PreviousFleetState": "active",
"FleetId": "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
}
]
}
```
**删除 EC2 实例集请求但不终止其实例**
通过改用 `--no-terminate-instances` 选项修改上一个示例。请注意，`instant` 实例集不支持 `--no-terminate-instances`。
```
aws ec2 delete-fleets \
--fleet-ids fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--no-terminate-instances
```
下面是示例输出。
```
{
"UnsuccessfulFleetDeletions": [],
"SuccessfulFleetDeletions": [
{
"CurrentFleetState": "deleted_running",
"PreviousFleetState": "active",
"FleetId": "fleet-4b8aaae8-dfb5-436d-a4c6-3dafa4c6b7dcEXAMPLE"
}
]
}
```
------
#### [ PowerShell ]
**删除 EC2 实例集请求并终止其实例**
使用带 `-TerminateInstance` 参数的 [Remove-EC2Fleet](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2Fleet.html) cmdlet。
```
Remove-EC2Fleet `
-FleetId "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TerminateInstance $true
```
**删除 EC2 实例集请求但不终止其实例**
通过更改 `-TerminateInstance` 参数的值修改上一个示例。
```
Remove-EC2Fleet `
-FleetId "fleet-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TerminateInstance $false
```
------
## 队列无法删除时进行故障排除
如果 EC2 实例集请求无法删除，则输出中的 `UnsuccessfulFleetDeletions` 将返回 EC2 实例集请求的 ID、错误代码和错误消息。
错误代码为：
+ `ExceededInstantFleetNumForDeletion`
+ `fleetIdDoesNotExist`
+ `fleetIdMalformed`
+ `fleetNotInDeletableState`
+ `NoTerminateInstancesNotSupported`
+ `UnauthorizedOperation`
+ `unexpectedError`
**`ExceededInstantFleetNumForDeletion` 问题排查**
如果您尝试在单个请求中删除超过 25 个 `instant` 队列，则会返回 `ExceededInstantFleetNumForDeletion` 错误。下面是此错误的示例输出。
```
{
"UnsuccessfulFleetDeletions": [
{
"FleetId": " fleet-5d130460-0c26-bfd9-2c32-0100a098f625",
"Error": {
"Message": "Can’t delete more than 25 instant fleets in a single request.",
"Code": "ExceededInstantFleetNumForDeletion"
}
},
{
"FleetId": "fleet-9a941b23-0286-5bf4-2430-03a029a07e31",
"Error": {
"Message": "Can’t delete more than 25 instant fleets in a single request.",
"Code": "ExceededInstantFleetNumForDeletion"
}
}
.
.
.
],
"SuccessfulFleetDeletions": []
}
```
**`NoTerminateInstancesNotSupported` 问题排查**
如果您指定在删除 `instant` 队列时不得终止该队列中的实例，则会返回 `NoTerminateInstancesNotSupported` 错误。`--no-terminate-instances` 队列不支持 `instant`。下面是此错误的示例输出。
```
{
"UnsuccessfulFleetDeletions": [
{
"FleetId": "fleet-5d130460-0c26-bfd9-2c32-0100a098f625",
"Error": {
"Message": "NoTerminateInstances option is not supported for instant fleet",
"Code": "NoTerminateInstancesNotSupported"
}
}
],
"SuccessfulFleetDeletions": []
}
```
**`UnauthorizedOperation` 问题排查**
如果您没有终止实例的权限，则在删除必须终止其实例的队列时会收到 `UnauthorizedOperation` 错误。下面是错误响应。
```
UnauthorizedOperationYou are not authorized to perform this
operation. Encoded authorization failure message: VvuncIxj7Z_CPGNYXWqnuFV-YjByeAU66Q9752NtQ-I3-qnDLWs6JLFd
KnSMMiq5s6cGqjjPtEDpsnGHzzyHasFHOaRYJpaDVravoW25azn6KNkUQQlFwhJyujt2dtNCdduJfrqcFYAjlEiRMkfDHt7N63SKlweKUl
BHturzDK6A560Y2nDSUiMmAB1y9UNtqaZJ9SNe5sNxKMqZaqKtjRbk02RZu5V2vn9VMk6fm2aMVHbY9JhLvGypLcMUjtJ76H9ytg2zRlje
VPiU5v2s-UgZ7h0p2yth6ysUdhlONg6dBYu8_y_HtEI54invCj4CoK0qawqzMNe6rcmCQHvtCxtXsbkgyaEbcwmrm2m01-EMhekLFZeJLr
DtYOpYcEl4_nWFX1wtQDCnNNCmxnJZAoJvb3VMDYpDTsxjQv1PxODZuqWHs23YXWVywzgnLtHeRf2o4lUhGBw17mXsS07k7XAfdPMP_brO
PT9vrHtQiILor5VVTsjSPWg7edj__1rsnXhwPSu8gI48ZLRGrPQqFq0RmKO_QIE8N8s6NWzCK4yoX-9gDcheurOGpkprPIC9YPGMLK9tug
89b1215c-7814-40ae-a8db-41761f43f2b0
```
为了解决错误，您必须将 `ec2:TerminateInstances` 操作添加到 IAM policy，如下例中所示。
# 使用竞价型实例集
要开始使用竞价型实例集，请创建一个请求，其中包含竞价型实例总目标容量、一个可选的按需部分，然后手动指定 AMI 和密钥对，或者指定包含实例集中实例配置的启动模板。您可以选择指定其他参数，也可以让实例集使用默认值。您还可以在创建实例集时标记实例集请求及其实例和卷。
实例集在有可用容量时启动按需型实例，在最高价超过 Spot 价格并且有可用容量时启动竞价型实例。
实例集启动后，即可描述实例集请求、实例集中的实例以及任何实例集事件。您也可以根据需要分配额外的标签。
如需更改任何实例集参数（例如总目标容量），则可以修改该实例集，前提是该实例集已配置为保持容量。提交一次性请求后，您无法修改其容量。
实例集请求在过期或您删除（删除）它之前一直有效。取消实例集请求时，您可以终止实例或让其保持运行状态。如果选择让实例保持运行，按需型实例会持续运行至您将其终止，竞价型实例会持续运行至遇到中断或您将其终止。
**Topics**
+ [
# Spot 队列请求状态
](spot-fleet-states.md)
+ [
# Spot 队列权限
](spot-fleet-prerequisites.md)
+ [
# 创建 Spot 队列
](create-spot-fleet.md)
+ [
# 标记新的或现有的竞价型实例集请求及其启动的实例和卷
](tag-spot-fleet.md)
+ [
# 描述竞价型实例集请求、其实例及事件历史记录
](manage-spot-fleet.md)
+ [
# 修改 Spot 队列请求
](modify-spot-fleet.md)
+ [
# 取消（删除）竞价型实例集请求
](cancel-spot-fleet.md)
+ [
# 了解竞价型实例集的自动扩展
](spot-fleet-automatic-scaling.md)
# Spot 队列请求状态
竞价型实例集请求可以处于多种状态之一，每种状态表示请求生命周期的不同阶段及其实例管理。
Spot 队列请求可以处于以下某种状态：
`submitted`
正在评估 Spot 队列请求，并且 Amazon EC2 正准备启动目标数量的实例。如果请求超出竞价型实例集限额，则会被立即取消。
`active`
已验证竞价型实例集，并且 Amazon EC2 正在尝试维护目标数量的正在运行的竞价型实例。请求会保持此状态，直到修改或取消它。
`modifying`
Spot 队列请求正在修改中。请求将保持该状态，直到完全处理修改或取消该请求。只能修改 `maintain` 队列类型。此状态不适用于一次性 `request` 实例集类型。
`cancelled_running`
已取消（删除）竞价型实例集且不启动其他竞价型实例。其现有实例将继续运行，直至中断或被手动终止。请求会保持此状态，直到所有实例都已中断或终止。
`cancelled_terminating`
已取消（删除）竞价型实例集，正在终止其实例。请求会保持此状态，直到所有实例都已终止。
`cancelled`
已取消（删除）竞价型实例集，没有正在运行的实例。请求将在其实例终止两天后被删除。
# Spot 队列权限
如果用户打算创建或管理竞价型实例集，您需要为其授予所需权限。
如果您使用 Amazon EC2 控制台创建竞价型实例集，将创建两个名为 `AWSServiceRoleForEC2SpotFleet` 和 `AWSServiceRoleForEC2Spot` 的服务相关角色和一个名为 `aws-ec2-spot-fleet-tagging-role` 的角色，这些角色为竞价型实例集授予代表您请求、启动、终止和标记资源的权限。如果您使用 AWS CLI 或 API，您必须确保这些角色存在。
按照以下说明授予所需的权限并创建角色。
**Topics**
+ [
## 向用户授予竞价型实例集权限
](#spot-fleet-iam-users)
+ [
## Spot 队列的服务相关角色
](#service-linked-roles-spot-fleet-requests)
+ [
## 竞价型实例的服务相关角色
](#service-linked-roles-spot-instances)
+ [
## 用于标记 Spot 队列的 IAM 角色
](#spot-fleet-service-linked-role)
## 向用户授予竞价型实例集权限
如果用户打算创建或管理竞价型实例集，请确保为其授予所需的权限。
**为竞价型实例集创建策略**
1. 通过 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。
1. 在导航窗格中，选择 **Policies**、**Create policy**。
1. 在 **Create policy (创建策略)** 页面上，选择 **JSON**，然后将文本替换为以下内容。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:RunInstances",
"ec2:CreateTags",
"ec2:RequestSpotFleet",
"ec2:ModifySpotFleetRequest",
"ec2:CancelSpotFleetRequests",
"ec2:DescribeSpotFleetRequests",
"ec2:DescribeSpotFleetInstances",
"ec2:DescribeSpotFleetRequestHistory"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::*:role/aws-ec2-spot-fleet-tagging-role"
},
{
"Effect": "Allow",
"Action": [
"iam:CreateServiceLinkedRole",
"iam:ListRoles",
"iam:ListInstanceProfiles"
],
"Resource": "*"
}
]
}
```
------
上述示例策略为用户授予多数竞价型实例集使用案例所需的权限。要将用户限制为特定的 API 操作，请仅指定这些 API 操作。
**所需的 EC2 和 IAM API**
必须在策略中包含以下 API：
+ `ec2:RunInstances` – 需要其启动竞价型实例集中的实例
+ `ec2:CreateTags` – 需要其标记竞价型实例集请求、实例或卷
+ `iam:PassRole` – 需要其指定竞价型实例集角色
+ `iam:CreateServiceLinkedRole` – 需要其创建服务相关角色
+ `iam:ListRoles` – 需要其枚举现有的 IAM 角色
+ `iam:ListInstanceProfiles` – 需要其枚举现有的实例配置文件
**重要**
如果您在启动规范或启动模板中为 IAM 实例配置文件指定角色，则必须授予用户将该角色传递给服务的权限。为此，在 IAM policy 中，包括 `"arn:aws:iam::*:role/IamInstanceProfile-role"` 作为 `iam:PassRole` 操作的资源。有关更多信息，请参阅 *IAM 用户指南*中的[向用户授予将角色传递给 AWS 服务的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
**竞价型实例集 API**
根据需要，将以下 Spot 队列 API 操作添加到策略中：
+ `ec2:RequestSpotFleet`
+ `ec2:ModifySpotFleetRequest`
+ `ec2:CancelSpotFleetRequests`
+ `ec2:DescribeSpotFleetRequests`
+ `ec2:DescribeSpotFleetInstances`
+ `ec2:DescribeSpotFleetRequestHistory`
**可选的 IAM API**
（可选）要允许用户使用 IAM 控制台创建角色或实例配置文件，您必须在策略中添加以下操作：
+ `iam:AddRoleToInstanceProfile`
+ `iam:AttachRolePolicy`
+ `iam:CreateInstanceProfile`
+ `iam:CreateRole`
+ `iam:GetRole`
+ `iam:ListPolicies`
1. 选择**查看策略**。
1. 在**查看策略**页面上，输入策略名称和描述，然后选择**创建策略**。
1. 要提供访问权限，请为您的用户、组或角色添加权限：
+ AWS IAM Identity Center 中的用户和群组：
创建权限集合。按照《AWS IAM Identity Center 用户指南》**中[创建权限集](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html)的说明进行操作。
+ 通过身份提供者在 IAM 中托管的用户：
创建适用于身份联合验证的角色。按照《IAM 用户指南》**中[针对第三方身份提供者创建角色（联合身份验证）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html)的说明进行操作。
+ IAM 用户：
+ 创建您的用户可以担任的角色。按照《IAM 用户指南》**中[为 IAM 用户创建角色](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html)的说明进行操作。
+ （不推荐使用）将策略直接附加到用户或将用户添加到用户组。按照《IAM 用户指南》**中[向用户添加权限（控制台）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)中的说明进行操作。
## Spot 队列的服务相关角色
Amazon EC2 使用服务相关角色获取代表您调用其他AWS服务所需的权限。服务相关角色是一种独特类型的 IAM 角色，它与AWS服务直接相关。服务相关角色提供了一种将权限委托给 AWS 服务的安全方式，因为只有相关服务才能担任服务相关角色。有关更多信息，请参阅《IAM 用户指南》**中的[服务相关角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create-service-linked-role.html)。
Amazon EC2 使用名为 **AWSServiceRoleForEC2SpotFleet** 的服务相关角色代表您启动和管理实例。
**重要**
如果在竞价型实例集中指定[加密的 AMI](AMIEncryption.md) 或加密的 Amazon EBS 快照，则必须为 **AWSServiceRoleForEC2SpotFleet** 角色授予使用该 CMK 的权限，以便 Amazon EC2 可以代表您启动实例。有关更多信息，请参阅[授予对用于加密的 AMI 和 EBS 快照的 CMK 的访问权限](#spot-fleet-service-linked-roles-access-to-cmks)。
### AWSServiceRoleForEC2SpotFleet 授予的权限
**AWSServiceRoleForEC2SpotFleet** 角色授予竞价型实例集权限以代表您请求、启动、终止和标记实例。Amazon EC2 使用此服务相关角色来完成以下操作：
+ `ec2:RequestSpotInstances` - 请求 Spot 实例
+ `ec2:RunInstances` - 启动实例
+ `ec2:TerminateInstances` - 终止实例
+ `ec2:DescribeImages` – 描述实例的亚马逊机器映像（AMI）
+ `ec2:DescribeInstanceStatus` - 监控实例的状态。
+ `ec2:DescribeSubnets` - 描述实例的子网
+ `ec2:CreateTags` – 在竞价型实例集请求、实例和卷中添加标签
+ `elasticloadbalancing:RegisterInstancesWithLoadBalancer` - 将指定的实例添加到指定的负载均衡器
+ `elasticloadbalancing:RegisterTargets` - 向指定目标组注册指定目标
### 创建服务相关角色
在大多数情况下，无需手动创建服务相关角色。Amazon EC2 在您首次使用控制台创建 Spot 队列时创建 **AWSServiceRoleForEC2SpotFleet** 服务相关角色。
如果在 2017 年 10 月之前具有活动 Spot 队列请求（此时 Amazon EC2 开始支持该服务相关角色），则 Amazon EC2 在您的AWS账户中创建 **AWSServiceRoleForEC2SpotFleet** 角色。有关更多信息，请参阅 *IAM 用户指南*中的[我的AWS账户中出现新角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared)。
如果您使用 AWS CLI 或 API 来创建竞价型实例集，则必须确保此角色存在。
**使用控制台为竞价型实例集创建 AWSServiceRoleForEC2SpotFleet 角色**
1. 通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择 **Roles**（角色）。
1. 选择**创建角色**。
1. 在**选择受信任的实体**页面上，请执行以下操作：
1. 在**可信实体类型**中选择 **AWS 服务**。
1. 在**使用案例**下，对于**服务或使用案例**，选择 **EC2**。
1. 对于**使用案例**，选择 **EC2 - 竞价型实例集**。
**注意**
**EC2 - 竞价型实例集**使用案例将自动创建具有所需 IAM 权限的策略，并建议将 **AWSEC2SpotFleetServiceRolePolicy** 作为角色名称。
1. 选择**下一步**。
1. 在**添加权限**页面上，选择**下一步**。
1. 在**命名、检查并创建**页面上，选择**创建角色**。
**使用 AWS CLI 为竞价型实例集创建 AWSServiceRoleForEC2SpotFleet 角色**
如下所示使用 [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) 命令。
```
aws iam create-service-linked-role --aws-service-name spotfleet.amazonaws.com
```
如果您不再需要使用 Spot 队列，我们建议您删除 **AWSServiceRoleForEC2SpotFleet** 角色。从您的账户中删除该角色后，如果您使用控制台请求 Spot 队列，Amazon EC2 将再次创建该角色。有关更多信息，请参阅《IAM 用户指南》**中的[删除服务相关角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#id_roles_manage_delete_slr)。
### 授予对用于加密的 AMI 和 EBS 快照的 CMK 的访问权限
如果在竞价型实例集请求中指定[加密的 AMI](AMIEncryption.md) 或加密的 Amazon EBS 快照，并且您使用客户托管的密钥进行加密，则必须为 **AWSServiceRoleForEC2SpotFleet** 角色授予使用该 CMK 的权限，以便 Amazon EC2 可以代表您启动实例。为此，您必须在 CMK 中添加授权，如以下过程中所示。
在提供权限时，授权是密钥策略的替代方法。有关更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[使用授权](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)和[在 AWS KMS 中使用密钥策略](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)。
**为 AWSServiceRoleForEC2SpotFleet 角色授予使用 CMK 的权限**
+ 使用 [create-grant](https://docs.aws.amazon.com/cli/latest/reference/kms/create-grant.html) 命令在 CMK 中添加授权，并指定授予权限的委托人（**AWSServiceRoleForEC2SpotFleet** 服务相关角色）以执行授权允许的操作。CMK 是由 `key-id` 参数和 CMK 的 ARN 指定的。委托人是由 `grantee-principal` 参数和 **AWSServiceRoleForEC2SpotFleet** 服务相关角色的 ARN 指定的。
```
aws kms create-grant \
--region us-east-1 \
--key-id arn:aws:kms:us-east-1:444455556666:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--grantee-principal arn:aws:iam::111122223333:role/aws-service-role/spotfleet.amazonaws.com/AWSServiceRoleForEC2SpotFleet \
--operations "Decrypt" "Encrypt" "GenerateDataKey" "GenerateDataKeyWithoutPlaintext" "CreateGrant" "DescribeKey" "ReEncryptFrom" "ReEncryptTo"
```
## 竞价型实例的服务相关角色
Amazon EC2 使用名为 **AWSServiceRoleForEC2Spot** 的服务相关角色代表您启动和管理 Spot 实例。有关更多信息，请参阅[竞价型实例请求的服务相关角色](service-linked-roles-spot-instance-requests.md)。
## 用于标记 Spot 队列的 IAM 角色
`aws-ec2-spot-fleet-tagging-role` IAM 角色授予竞价型实例集标记竞价型实例集请求、实例和卷的权限。有关更多信息，请参阅 [标记新的或现有的竞价型实例集请求及其启动的实例和卷](tag-spot-fleet.md)。
**重要**
如果您选择在实例集中标记实例并选择保持目标容量（竞价型实例集请求属于类型 `maintain`），用户与 `IamFleetRole` 的权限差异可能会导致实例集中实例的标记行为不一致。如果 `IamFleetRole` 不包含 `CreateTags` 权限，则可能不会标记由队列启动的某些实例。虽然我们正在努力修复这种不一致性，但为了确保队列启动的所有实例都被标记，我们建议您为 `aws-ec2-spot-fleet-tagging-role` 使用 `IamFleetRole` 角色。或者，要使用现有角色，请将 `AmazonEC2SpotFleetTaggingRole` AWS 托管策略附加到现有角色。否则，您需要手动将 `CreateTags` 权限添加到现有策略。
**创建用于标记 Spot 队列的 IAM 角色**
1. 通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择 **Roles**（角色）。
1. 选择**创建角色**。
1. 在 **Select trusted entity**（选择可信实体）页面中，在 **Trusted entity type**（可信实体类型）下选择 ** service**（AWS 服务）。
1. 在**使用案例**下，从**其他 AWS 服务的使用案例**中选择 **EC2**，然后选择 **EC2 – 竞价型实例集标记**。
1. 选择**下一步**。
1. 在**添加权限**页面上，选择**下一步**。
1. 在 **Name, review, and create**（命名、检查和创建）页面上，对于 **Role name**（角色名称），输入角色的名称（例如 **aws-ec2-spot-fleet-tagging-role**）。
1. 检查此页面上的信息，然后选择 **Create role**（创建角色）。
### 防止跨服务混淆座席
[混淆代理问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)是一个安全问题，即没有执行操作权限的实体可能会迫使更具权限的实体执行该操作。我们建议在 `aws-ec2-spot-fleet-tagging-role` 信任策略中使用 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键，以限制竞价型实例集为其他服务提供的资源访问权限。
**将 aws:SourceArn 和 aws:SourceAccount 条件键添加到 `aws-ec2-spot-fleet-tagging-role` 信任策略**
1. 通过以下网址打开 IAM 控制台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择**角色**。
1. 找到您之前创建的 `aws-ec2-spot-fleet-tagging-role` 并选择链接（而不是复选框）。
1. 在 **Summary**（摘要）下，选择 **Trust relationships**（信任关系）选项卡，然后选择 **Edit trust policy**（编辑信任策略）。
1. 在 JSON 语句中，添加一个包含您的 `aws:SourceAccount` 和 `aws:SourceArn` 全局条件上下文键的 `Condition` 元素，以防止[混淆代理人问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)，如下所示：
```
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:ec2:us-east-1:111122223333:spot-fleet-request/sfr-*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
```
**注意**
如果 `aws:SourceArn` 值包含账户 ID，并且您同时使用了这两个全局条件上下文键，则 `aws:SourceAccount` 值和 `aws:SourceArn` 值中的账户在同一策略语句中使用时，必须使用相同的账户 ID。
最终的信任策略将如下所示：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "ConfusedDeputyPreventionExamplePolicy",
"Effect": "Allow",
"Principal": {
"Service": "spotfleet.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:ec2:us-east-1:111122223333:spot-fleet-request/sfr-*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
}
}
}
```
------
1. 选择**更新策略**。
下表提供了 `aws:SourceArn` 的潜在值，以根据不同的明确程度限制 `aws-ec2-spot-fleet-tagging-role` 的范围。
****
| API 操作 | 调用的服务 | 范围 | `aws:SourceArn` |
| --- | --- | --- | --- |
| RequestSpotFleet | AWS STS (AssumeRole) | 将 aws-ec2-spot-fleet-tagging-role 上的 AssumeRole 功能限定为指定账户中的竞价型实例集请求。 | arn:aws:ec2:\$1:123456789012:spot-fleet-request/sfr-\$1 |
| RequestSpotFleet | AWS STS (AssumeRole) | 将 aws-ec2-spot-fleet-tagging-role 上的 AssumeRole 功能限定为指定账户和指定区域中的竞价型实例集请求。请注意，此角色将不能在其他区域使用。 | arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-\$1 |
| RequestSpotFleet | AWS STS (AssumeRole) | 将 aws-ec2-spot-fleet-tagging-role 上的 AssumeRole 功能限定为仅影响实例集 sfr-11111111-1111-1111-1111-111111111111 的操作。请注意，此角色可能无法用于其他竞价型实例集。此外，此角色不能用于通过请求竞价型实例集来启动任何新的竞价型实例集。 | arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-11111111-1111-1111-1111-111111111111 |
# 创建 Spot 队列
使用 AWS 管理控制台时，只需选择 AMI 和所需的目标总容量，即可快速创建竞价型实例集请求。Amazon EC2 将配置一个最符合您需求并遵循竞价型实例最佳实践的实例集。您也可以修改任何默认设置。
要在实例集中包含按需型实例，则必须在请求中指定启动模板以及所需的按需容量。
实例集在有可用容量时启动按需型实例，在最高价超过 Spot 价格并且有可用容量时启动竞价型实例。
如果实例集包含竞价型实例且类型为 `maintain`，Amazon EC2 会尝试在竞价型实例中断时维持实例集的目标容量。
**所需的权限**
有关更多信息，请参阅 [Spot 队列权限](spot-fleet-prerequisites.md)。
**Topics**
+ [
## 快速创建竞价型实例集请求
](#create-spot-fleet-quick)
+ [
## 使用已定义的参数创建竞价型实例集请求
](#create-spot-fleet-advanced)
+ [
## 创建竞价型实例集来替换运行状况不佳的竞价型实例
](#spot-fleet-health-checks)
## 快速创建竞价型实例集请求
使用 Amazon EC2 控制台，按照以下步骤快速创建竞价型实例集请求。
**使用推荐设置创建竞价型实例集请求**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 如果您是首次接触 Spot，则会看到一个欢迎页面；请选择 **Get started**。否则，请选择**创建竞价型实例集请求**。
1. 在 **Launch parameters**（启动参数）下，选择 **Manually configure launch parameters**（手动配置启动参数）。
1. 对于 **AMI**，选择一个 AMI。
1. 在 **Target capacity**（目标容量）下，对于 **Total target capacity**（总目标容量），请指定要请求的单位数。对于单位类型，您可以选择**实例**、**vCPU** 或 **内存（GiB）**。
1. 对于**您的实例集请求概览**，查看您的实例集配置，然后选择**启动**。
## 使用已定义的参数创建竞价型实例集请求
您可以使用自己定义的参数创建竞价型实例集。
------
#### [ Console ]
**使用已定义的参数创建竞价型实例集请求**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 如果您是首次接触 Spot，则会看到一个欢迎页面；请选择 **Get started**。否则，请选择**创建竞价型实例集请求**。
1. 对于**启动参数**，可以手动配置启动参数，也可以使用启动模板，如下所示：
1. [手动配置] 要在 Amazon EC2 控制台中定义启动参数，请选择**手动配置启动参数**，再执行以下操作：
1. 对于 **AMI**，选择 AWS 提供的基本 AMI，或者选择 **Search for AMI**（搜索 AMI）以使用来自我们用户社群、AWS Marketplace 或您自己的 AMI。
**注意**
如果启动参数中指定的 AMI 已注销或禁用，则无法从该 AMI 启动任何新实例。对于设置为维持目标容量的实例集，目标容量将无法维持。
1. （可选）对于 **Key pair name (密钥对名称)**，选择现有密钥对或新建一个密钥对。
[现有密钥对] 选择所需的密钥对。
[新密钥对] 选择**创建新密钥对**前往**密钥对**页面。完成之后，返回 **Spot Requests**（竞价型请求）页面并刷新列表。
1. （可选）展开 **Additional launch parameters**（其它启动参数），然后执行以下操作：
1. （可选）要启用 Amazon EBS 优化，对于 **EBS-optimized**（EBS 优化），请选择 **Launch EBS-optimized instances**（启动 EBS 优化实例）。
1. （可选）要为实例添加临时性块级存储，请对 **Instance store (实例存储)** 选择 **Attach at launch (启动时附加)**。
1. （可选）要添加存储，请选择 **Add new volume**（添加新卷），然后根据实例类型指定其它实例存储卷或 Amazon EBS 卷。
1. (可选) 默认情况下，已为您的实例启用基本监控。要启用详细监控，对于 **Monitoring**（监控），请选择 **Enable CloudWatch detailed monitoring**（启用 CloudWatch 详细监控）。
1. （可选）要运行专用 Spot 实例，请为 **Tenancy (租期)** 选择 **Dedicated - run a dedicated instance (专用 – 运行专用实例)**。
1. （可选）对于 **Security groups (安全组)**，选择一个或多个安全组，或者新建一个。
[现有安全组] 选择一个或多个所需的安全组。
[新安全组] 选择 **Create new security group**（新建安全组）以前往 **Security Groups**（安全组）页面。完成之后，返回 **Spot Requests**（Spot 请求）并刷新列表。
1. （可选）要能够通过 Internet 访问实例，请对 **Auto-assign IPv4 Public IP (自动分配 IPv4 公有 IP)** 选择 **Enable (启用)**。
1. （可选）要使用 IAM 角色启动 Spot 实例，请对 **IAM 实例配置文件**选择角色。
1. (可选) 要运行启动脚本，请将其复制到 **User data**。
1. （可选）要添加标签，请选择 **Create tag**（创建标签），输入标签的键和值，然后选择 **Create**（创建）。对每个标签重复此操作。
对于每个标签，要使用相同标签标记实例和竞价型实例集请求，请确保同时选择了 **Instance**（实例）和 **Fleet**（机群）。要仅标记由队列启动的实例，清除 **Fleet**（队列）。要仅标记竞价型实例集请求，请清除 **Instance**（实例）。
1. [启动模板] 要使用在启动模板中创建的配置，请选择**使用启动模板**，再为**启动模板**选择一个启动模板。
**注意**
如果希望在竞价型实例集中包含按需容量，则必须指定启动模板。
1. 对于 **Additional request details (其他请求详细信息)**，执行以下操作：
1. 查看其他请求详细信息。要进行更改，请清除 **Apply defaults (应用默认设置)**。
1. （可选）对于 **IAM fleet role (IAM 队列角色)**，您可以使用默认角色或选择其他角色。要在更改角色后使用默认角色，请选择 **Use default role (使用默认角色)**。
1. (可选) 要创建仅在特定时间段内有效的请求，请编辑**请求有效起始时间**和**请求有效截止时间**。
1. （可选）默认情况下，Amazon EC2 在竞价型实例集会在请求过期时终止竞价型实例。要保持这些实例在请求过期后继续运行，请清除 **Terminate the instances when the request expires (请求到期时终止实例)**。
1. （可选）要向负载均衡器注册 Spot 实例，请选择 **Receive traffic from one or more load balancers (从一个或多个负载均衡器接收流量)**，然后选择一个或多个经典负载均衡器或目标组。
1. 对于 **Target capacity**（目标容量），执行以下操作：
1. 对于 **Total target capacity**（总目标容量），请指定要请求的单位数。对于单位类型，您可以选择 **Instances**（实例）、**vCPU** 或 **Memory (MiB)**（内存 (MiB)）。要将目标容量指定为 0 以便以后可增加容量，请选择**维持目标容量**。
1. （可选）对于 **Include On-Demand base capacity**（包括按需基本容量），请指定要请求的按需单位数。该数字必须小于 **Total target capacity (总目标容量)**。Amazon EC2 会计算差值，并将差值分配给要请求的 Spot 单位。
**重要**
要指定可选的按需容量，您必须先选择一个启动模板。
1. （可选）默认情况下，在竞价型实例中断时，Amazon EC2 将终止这些实例。要保持目标容量，请选择**保持目标容量**。然后，您可以指定 Amazon EC2 在竞价型实例中断时终止、停止或休眠这些实例。为此，请从**中断行为**中选择相应的选项。
**注意**
如果启动参数中指定的 AMI 已注销或禁用，则无法从该 AMI 启动任何新实例。在这种情况下，对于设置为维持目标容量的实例集，目标容量将无法维持。
1. （可选）要允许竞价型实例集在系统针对实例集中的现有竞价型实例发出实例再平衡通知时启动替换竞价型实例，请选择 **Capacity rebalance**（容量再平衡），然后选择实例替换策略。如果选择**终止前启动**，请指定 Amazon EC2 终止旧实例之前的延迟时间（以秒为单位）。有关更多信息，请参阅 [在 EC2 实例集和竞价型实例集中使用“容量再平衡”功能来替换存在风险的竞价型实例](ec2-fleet-capacity-rebalance.md)。
1. （可选）要控制每小时为队列中所有的 Spot 实例支付的金额，请选择 **Set maximum cost for Spot Instances**（设置 Spot 实例的最大成本），然后输入您每小时愿意支付的最大总额。当达到最大总额后，即使未达到目标容量，竞价型实例集也会停止启动竞价型实例。有关更多信息，请参阅 [为 EC2 实例集或竞价型实例集设置支出限额](ec2-fleet-control-spending.md)。
1. 对于 **Network**（网络），执行以下操作：
1. 对于 **Network (网络)**，选择现有 VPC 或新建一个。
[现有 VPC] 选择所需的 VPC。
[新 VPC] 选择 **Create new VPC (新建 VPC)** 以前往 Amazon VPC 控制台。完成之后，请返回此屏幕并刷新列表。
1. （可选）对于**可用区**，让 Amazon EC2 为竞价型实例选择可用区，或者指定一个或多个可用区。
如果您在一个可用区中有多个子网，则请从 **Subnet (子网)** 中选择合适的子网。要添加子网，请选择 **Create new subnet (新建子网)** 以前往 Amazon VPC 控制台。完成之后，请返回此屏幕并刷新列表。
1. 对于 **Instance type requirements**（实例类型要求），可以指定实例属性，然后让 Amazon EC2 使用这些属性识别最佳实例类型，也可以指定实例列表。有关更多信息，请参阅 [指定 EC2 实例集或竞价型实例集的实例类型选择属性](ec2-fleet-attribute-based-instance-type-selection.md)。
1. 如果选择 **Specify instance attributes that match your compute requirements**（指定符合计算要求的实例属性），请按如下方式指定实例属性：
1. 对于 **vCPU**，请输入所需的最小和最大 vCPU 数。要指定没有限制，请选择**没有最小值**和/或**没有最大值**。
1. 对于 **Memory (GiB)**（内存 (GiB)），输入所需的最小和最大内存量。要指定没有限制，请选择**没有最小值**和/或**没有最大值**。
1. （可选）对于**其他实例属性**，您可以选择指定一个或多个属性来更详细地表达计算要求。每个额外属性都会进一步增加对您的请求的限制。您可以省略其它属性；如果省略，则使用默认值。有关每个属性及其默认值的描述，请参阅 [get-spot-placement-scores](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-spot-placement-scores.html)。
1. （可选）要查看具有指定属性的实例类型，请展开 **Preview matching instance types**（预览匹配的实例类型）。要排除在请求中使用的实例类型，请选择实例，然后选择 **Exclude selected instance types**（排除选定的实例类型）。
1. 如果选择 **Manually select instance types**（手动选择实例类型），竞价型实例集将提供实例类型默认列表。要选择更多实例类型，请选择 **Add instance types**（添加实例类型），选择要在请求中使用的实例类型，然后选择 **Select**（选择）。要删除实例类型，请选择实例类型，然后选择 **Delete**（删除）。
1. 对于**分配策略**，请选择符合需求的竞价型分配策略和按需型分配策略。有关更多信息，请参阅 [使用分配策略确定 EC2 实例集或竞价型实例集如何满足竞价型和按需型容量](ec2-fleet-allocation-strategy.md)。
1. 对于 **Your fleet request at a glance**（您的机群请求概览），查看您的机群配置，并在必要时进行任何调整。
1. （可选）要下载一个启动配置副本以用于 AWS CLI，请选择 **JSON config (JSON 配置)**。
1. 准备好启动竞价型实例集后，请选择**启动**。
竞价型实例集请求类型为 `fleet`。执行请求后，系统会添加请求类型 `instance`，此时其状态为 `active` 和 `fulfilled`。
------
#### [ AWS CLI ]
**创建竞价型实例集请求**
使用 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) 命令。
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://config.json
```
有关示例配置文件，请参阅[竞价型实例集 CLI 配置示例](spot-fleet-examples.md)。
------
#### [ PowerShell ]
**创建竞价型实例集请求**
使用 [Request-EC2SpotFleet](https://docs.aws.amazon.com/powershell/latest/reference/items/Request-EC2SpotFleet.html) cmdlet。以下示例在容量优化实例集中启动竞价型实例。
```
Request-EC2SpotFleet `
-SpotFleetRequestConfig_TargetCapacity 50 `
-SpotFleetRequestConfig_AllocationStrategy "CapacityOptimized" `
-SpotFleetRequestConfig_IamFleetRole "arn:aws:iam::123456789012:role/my-spot-fleet-role" `
-SpotFleetRequestConfig_LaunchTemplateConfig @($launchConfig)
```
按如下方式定义启动配置，设置启动模板并覆盖所需的属性。有关示例配置，请参阅 [竞价型实例集 CLI 配置示例](spot-fleet-examples.md)。
```
$lcSpec = Amazon.EC2.Model.FleetLaunchTemplateSpecification
# To do - Set FleetLaunchTemplateSpecification properties
$lcOverrides = New-Object Amazon.EC2.Model.LaunchTemplateOverrides
# To do - Set LaunchTemplateOverrides properties
$launchConfig = New-Object Amazon.EC2.Model.LaunchTemplateConfig
$launchConfig.LaunchTemplateSpecification $lcSpec
$launchConfig.Overrides @($lcOverrides)
```
------
## 创建竞价型实例集来替换运行状况不佳的竞价型实例
竞价型实例集每 2 分钟检查一次队列中竞价型实例的运行状况。实例的运行状况为 `healthy` 或 `unhealthy`。
Spot 队列将使用 Amazon EC2 提供的状态检查来确定实例的运行状况。如果在连续三次运行状况检查中，实例状态检查或系统状态检查的状态有任一项为 `unhealthy`，则可确定该实例的运行状况为 `impaired`。有关更多信息，请参阅 [Amazon EC2 实例的状态检查](monitoring-system-instance-status-check.md)。
您可以配置您的队列以替换运行状况不佳的竞价型实例。启用运行状况检查替换后，如果竞价型实例被报告为 `unhealthy`，则会被替换。在替换运行状况不佳的竞价型实例时，队列的容量可能在几分钟内降至其目标容量之下。
**要求**
+ 只有在保持目标容量（类型 `maintain` 的队列）的情况下 Spot 队列 才支持运行状况检查替换，而不支持一次性 Spot 队列（类型 `request` 的队列）。
+ 仅对竞价型实例支持运行状况检查替换。对于 按需型实例 不支持此功能。
+ 您可以将 Spot 队列配置为仅在您创建它时替换运行状况不佳的实例。
+ 用户仅在其有权调用 `ec2:DescribeInstanceStatus` 操作时才能使用运行状况检查替换。
------
#### [ Console ]
**配置竞价型实例集来替换运行不正常的竞价型实例**
1. 按[使用已定义的参数创建竞价型实例集请求](#create-spot-fleet-advanced)中创建竞价型实例集的步骤操作。
1. 要将实例集配置为替换运行状况不佳的竞价型实例，请展开**其他启动参数**，然后在**运行状况检查**下选择**替换运行状况不佳的实例**。要启用此选项，您必须先选择 **Maintain target capacity (保持目标容量)**。
------
#### [ AWS CLI ]
**配置竞价型实例集来替换运行不正常的竞价型实例**
使用 `ReplaceUnhealthyInstances` 属性为 `SpotFleetRequestConfig` 的 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) 命令。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "lowestPrice",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"TargetCapacity": 10,
"ReplaceUnhealthyInstances": true
}
}
```
------
#### [ PowerShell ]
**配置竞价型实例集请求来替换运行不正常的竞价型实例**
使用带 `-SpotFleetRequestConfig_ReplaceUnhealthyInstance` 参数的 [Request-EC2SpotFleet](https://docs.aws.amazon.com/powershell/latest/reference/items/Request-EC2SpotFleet.html) cmdlet。
```
-SpotFleetRequestConfig_ReplaceUnhealthyInstance $true
```
------
# 标记新的或现有的竞价型实例集请求及其启动的实例和卷
要对竞价型实例集请求及其启动的实例和卷进行分类与管理，可以使用自定义元数据标记它们。您可以在创建 Spot 队列请求时或之后为其分配标签。同理，可以在实例集启动实例和卷之时或之后为实例和卷分配标签。
在标记队列请求时，不会自动标记队列启动的实例和卷。您需要明确标记队列启动的实例和卷。您可以选择仅将标签分配给实例集请求，仅分配给实例集启动的实例，仅分配给附加到实例集启动的实例的卷，或者分配给所有这三种内容。
**注意**
您只能标记附加到按需型实例的卷。您无法标记附加到竞价型实例的卷。
您可以使用 Amazon EC2 控制台或命令行工具分配标签。
有关标签的工作原理的更多信息，请参阅[标记 Amazon EC2 资源](Using_Tags.md)。
**Topics**
+ [
## 先决条件
](#tag-spot-fleet-prereqs)
+ [
## 标记新的 Spot 队列及其启动的实例和卷
](#tag-new-spot-fleet-and-resources)
+ [
## 标记现有的 Spot 队列
](#tag-existing-spot-fleet)
+ [
## 查看 Spot 队列请求标签
](#view-spot-fleet-tags)
## 先决条件
授予用户标记资源的权限。有关更多信息，请参阅 [示例：标记资源](ExamplePolicies_EC2.md#iam-example-taggingresources)。
**授予用户标记资源的权限**
创建包含以下内容的 IAM policy：
+ `ec2:CreateTags` 操作。这将授予用户创建标签的权限。
+ `ec2:RequestSpotFleet` 操作。这将授予用户创建竞价型实例集请求的权限。
+ 对于 `Resource`，您必须指定 `"*"`。这允许用户标记所有资源类型。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TagSpotFleetRequest",
"Effect": "Allow",
"Action": [
"ec2:CreateTags",
"ec2:RequestSpotFleet"
],
"Resource": "*"
}
]
}
```
------
**重要**
对于 `spot-fleet-request` 资源，我们目前不支持资源级权限。如果您指定 `spot-fleet-request` 以作为资源，在您尝试标记队列时，将会发生未经授权异常。以下示例说明如何*不* 设置策略。
```
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags",
"ec2:RequestSpotFleet"
],
"Resource": "arn:aws:ec2:us-east-1:111122223333:spot-fleet-request/*"
}
```
要提供访问权限，请为您的用户、组或角色添加权限：
+ AWS IAM Identity Center 中的用户和群组：
创建权限集合。按照《AWS IAM Identity Center 用户指南》**中[创建权限集](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html)的说明进行操作。
+ 通过身份提供者在 IAM 中托管的用户：
创建适用于身份联合验证的角色。按照《IAM 用户指南》**中[针对第三方身份提供者创建角色（联合身份验证）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html)的说明进行操作。
+ IAM 用户：
+ 创建您的用户可以担任的角色。按照《IAM 用户指南》**中[为 IAM 用户创建角色](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html)的说明进行操作。
+ （不推荐使用）将策略直接附加到用户或将用户添加到用户组。按照《IAM 用户指南》**中[向用户添加权限（控制台）](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console)中的说明进行操作。
## 标记新的 Spot 队列及其启动的实例和卷
**使用控制台标记新的竞价型实例集请求及其启动的实例和卷**
1. 按照[使用已定义的参数创建竞价型实例集请求](create-spot-fleet.md#create-spot-fleet-advanced)过程操作。
1. 添加标签的方式取决于您是手动配置实例集还是使用启动模板。
+ 如果手动配置了实例集，请执行以下操作：
要添加标签，请展开**其他启动参数**，选择**创建标签**，然后输入标签的键和值。对每个标签重复此操作。
对于每个标签，您可以使用相同标签标记 Spot 队列请求和实例。要对两者进行标记，请确保同时选择**实例**和**实例集**。要仅标记竞价型实例集请求，请清除 **Instance**（实例）。要仅标记由队列启动的实例，清除 **Fleet**（队列）。
**注意**
手动配置实例集时，无法选择标记卷。仅附加到按需型实例的卷支持卷标签。手动配置实例集时，您无法指定按需型实例。
+ 如果使用启动模板，请执行以下操作：
要向实例集请求添加标签，请在**标签**下，选择**创建标签**，然后输入该标签的键和值。对每个标签重复此操作。
要标记实例集中的资源，您必须在[启动模板](create-launch-template.md)中指定标签。
**标记新的竞价型实例集请求及其使用 AWS CLI 启动的实例和卷**
要在创建 Spot 队列请求时标记该请求，并在队列启动实例和卷时标记它们，请按以下方式配置 Spot 队列请求配置：
**Spot 队列请求标签：**
+ 在 `SpotFleetRequestConfig` 中指定竞价型实例集请求的标签。
+ 对于 `ResourceType`，请指定 `spot-fleet-request`。如果指定其他值，队列请求将失败。
+ 对于 `Tags`，请指定键值对。您可以指定多个键值对。
**实例标签：**
+ 为 `LaunchSpecifications` 中的实例指定标签。
+ 对于 `ResourceType`，请指定 `instance`。如果指定其他值，队列请求将失败。
+ 对于 `Tags`，请指定键值对。您可以指定多个键值对。
或者，您可以在 Spot 队列请求中引用的[启动模板](create-launch-template.md)中为实例指定标签。
**卷标签：**
+ 在 Spot 队列请求中引用的[启动模板](create-launch-template.md)中为卷指定标签。不支持 `LaunchSpecifications` 中的卷标记。
在以下示例中，使用两个标签来标记 Spot 队列请求：键=环境，值=生产；键=成本中心，值=123。由队列启动的实例使用一个标签（与 Spot 队列请求的其中一个标签相同）进行标记：键=成本中心，值=123。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::111122223333:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-0123456789EXAMPLE",
"InstanceType": "c4.large",
"TagSpecifications": [
{
"ResourceType": "instance",
"Tags": [
{
"Key": "Cost-Center",
"Value": "123"
}
]
}
]
}
],
"SpotPrice": "5",
"TargetCapacity": 2,
"TerminateInstancesWithExpiration": true,
"Type": "maintain",
"ReplaceUnhealthyInstances": true,
"InstanceInterruptionBehavior": "terminate",
"InstancePoolsToUseCount": 1,
"TagSpecifications": [
{
"ResourceType": "spot-fleet-request",
"Tags": [
{
"Key": "Environment",
"Value":"Production"
},
{
"Key": "Cost-Center",
"Value":"123"
}
]
}
]
}
}
```
**使用 AWS CLI 标记由竞价型实例集启动的实例**
要在队列启动实例时标记实例，您可以在 Spot 队列请求中引用的[启动模板](create-launch-template.md)中指定标记，也可以在 Spot 队列请求配置中指定标记，如下所示：
+ 为 `LaunchSpecifications` 中的实例指定标签。
+ 对于 `ResourceType`，请指定 `instance`。如果指定其他值，队列请求将失败。
+ 对于 `Tags`，请指定键值对。您可以指定多个键值对。
在以下示例中，由队列启动的实例使用一个标签进行标记：键=成本中心，值=123。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::111122223333:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-0123456789EXAMPLE",
"InstanceType": "c4.large",
"TagSpecifications": [
{
"ResourceType": "instance",
"Tags": [
{
"Key": "Cost-Center",
"Value": "123"
}
]
}
]
}
],
"SpotPrice": "5",
"TargetCapacity": 2,
"TerminateInstancesWithExpiration": true,
"Type": "maintain",
"ReplaceUnhealthyInstances": true,
"InstanceInterruptionBehavior": "terminate",
"InstancePoolsToUseCount": 1
}
}
```
**使用 AWS CLI 标记挂载至由竞价型实例集启动的按需型实例的卷**
要在队列创建卷时标记这些卷，您必须在 Spot 队列请求中引用的[启动模板](create-launch-template.md)中指定标签。
**注意**
仅附加到按需型实例的卷支持卷标签。您无法标记附加到竞价型实例的卷。
不支持 `LaunchSpecifications` 中的卷标记。
## 标记现有的 Spot 队列
**使用控制台标记现有 Spot 队列请求**
创建竞价型实例集请求后，您可以使用控制台向实例集请求添加标签。
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择 **Tags (标签)** 选项卡，然后选择 **Create Tag (创建标签)**。
**使用 AWS CLI 标记现有竞价型实例集请求**
可以使用 [create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html) 命令标记现有的资源。在以下示例中，使用以下标签标记现有 Spot 队列请求：键=目的，值=测试。
```
aws ec2 create-tags \
--resources sfr-11112222-3333-4444-5555-66666EXAMPLE \
--tags Key=purpose,Value=test
```
## 查看 Spot 队列请求标签
**使用控制台查看 Spot 队列请求标签**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择您的 Spot 队列请求并选择 **Tags (标签)** 选项卡。
**描述 Spot 队列请求标记**
使用 [describe-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-tags.html) 命令可查看指定资源的标签。在以下示例中，您将描述指定 Spot 队列请求的标签。
```
aws ec2 describe-tags \
--filters "Name=resource-id,Values=sfr-11112222-3333-4444-5555-66666EXAMPLE"
```
```
{
"Tags": [
{
"Key": "Environment",
"ResourceId": "sfr-11112222-3333-4444-5555-66666EXAMPLE",
"ResourceType": "spot-fleet-request",
"Value": "Production"
},
{
"Key": "Another key",
"ResourceId": "sfr-11112222-3333-4444-5555-66666EXAMPLE",
"ResourceType": "spot-fleet-request",
"Value": "Another value"
}
]
}
```
您还可以通过描述 Spot 队列请求来查看 Spot 队列请求的标签。
使用 [describe-spot-fleet-requests](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-spot-fleet-requests.html) 命令可查看指定的 Spot 队列请求的配置，其中包括为队列请求指定的任何标签。
```
aws ec2 describe-spot-fleet-requests \
--spot-fleet-request-ids sfr-11112222-3333-4444-5555-66666EXAMPLE
```
```
{
"SpotFleetRequestConfigs": [
{
"ActivityStatus": "fulfilled",
"CreateTime": "2020-02-13T02:49:19.709Z",
"SpotFleetRequestConfig": {
"AllocationStrategy": "capacityOptimized",
"OnDemandAllocationStrategy": "lowestPrice",
"ExcessCapacityTerminationPolicy": "Default",
"FulfilledCapacity": 2.0,
"OnDemandFulfilledCapacity": 0.0,
"IamFleetRole": "arn:aws:iam::111122223333:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-0123456789EXAMPLE",
"InstanceType": "c4.large"
}
],
"TargetCapacity": 2,
"OnDemandTargetCapacity": 0,
"Type": "maintain",
"ReplaceUnhealthyInstances": false,
"InstanceInterruptionBehavior": "terminate"
},
"SpotFleetRequestId": "sfr-11112222-3333-4444-5555-66666EXAMPLE",
"SpotFleetRequestState": "active",
"Tags": [
{
"Key": "Environment",
"Value": "Production"
},
{
"Key": "Another key",
"Value": "Another value"
}
]
}
]
}
```
# 描述竞价型实例集请求、其实例及事件历史记录
您可以描述竞价型实例集配置、竞价型实例集中的实例以及竞价型实例集的事件历史记录。
------
#### [ Console ]
**描述竞价型实例集**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。ID 以 **sfr-** 开头。要查看配置详细信息，请选择 **Description (描述)**。
1. 要列出 Spot 队列的 Spot 实例，请选择 **Instances (实例)**。
1. 要查看 Spot 队列的历史记录，请选择 **History (历史记录)**。
------
#### [ AWS CLI ]
**描述竞价型实例集请求**
使用 [describe-spot-fleet-requests](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-spot-fleet-requests.html) 命令。
```
aws ec2 describe-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
**描述用于指定竞价型实例集请求的运行实例**
使用 [describe-spot-fleet-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-spot-fleet-instances.html) 命令。
```
aws ec2 describe-spot-fleet-instances \
--spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE
```
**描述用于指定竞价型实例集请求的事件历史记录**
使用 [describe-spot-fleet-request-history](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-spot-fleet-request-history.html) 命令。
```
aws ec2 describe-spot-fleet-request-history \
--spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--start-time 2024-05-18T00:00:00Z
```
------
#### [ PowerShell ]
**描述竞价型实例集请求**
使用 [Get-EC2SpotFleetRequest](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2SpotFleetRequest.html) cmdlet。
```
Get-EC2SpotFleetRequest
```
**描述用于指定竞价型实例集请求的运行实例**
使用 [Get-EC2SpotFleetInstance](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2SpotFleetInstance.html) cmdlet。
```
Get-EC2SpotFleetInstance `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE"
```
**描述用于指定竞价型实例集请求的事件历史记录**
使用 [Get-EC2SpotFleetRequestHistory](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2SpotFleetRequestHistory.html) cmdlet。
```
Get-EC2SpotFleetRequestHistory `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-UtcStartTime 2024-05-18T00:00:00Z
```
------
# 修改 Spot 队列请求
您可以修改活动的 Spot 队列请求以完成以下任务：
+ 增加总目标容量和按需部分
+ 减少总目标容量和按需部分
在增加总目标容量时，竞价型实例集会根据其竞价型实例集请求的[分配策略](ec2-fleet-allocation-strategy.md)启动额外的竞价型实例。当您提高按需部分时，竞价型实例集会启动其他按需型实例。
在减少总目标容量时，竞价型实例集会取消超过新目标容量的任何打开的请求。您可以请求竞价型实例集终止竞价型实例，直到队列的大小达到新目标容量。如果分配策略为 `diversified`，则竞价型实例集将在池间终止实例。或者，您可以请求竞价型实例集保持队列当前的队列大小，而不替换已中断的任何竞价型实例或者您手动终止的任何竞价型实例。
**注意事项**
+ 您无法修改一次性 Spot 队列请求。您只能在创建 Spot 队列请求时选择了 **Maintain target capacity (保持目标容量)** 的情况下修改 Spot 队列请求。
+ 当竞价型实例集因目标容量下降而终止某个实例时，该实例将收到一条竞价型实例中断通知。
------
#### [ Console ]
**修改竞价型实例集请求**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 依次选择 **Actions (操作)** 和 **Modify target capacity (修改目标容量)**。
1. 在 **Modify target capacity** 中，执行以下操作：
1. 输入新的目标容量和按需部分。
1. （可选）如果您要减少目标容量，但是要使队列保持其当前大小，请清除 **Terminate instances (终止实例)**。
1. 选择**提交**。
------
#### [ AWS CLI ]
**修改竞价型实例集请求**
使用 [modify-spot-fleet-request](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-spot-fleet-request.html) 命令可更新指定 Spot 队列请求的目标容量。
```
aws ec2 modify-spot-fleet-request \
--spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--target-capacity 20
```
可以按如下所示修改前面的命令，以减少指定竞价型实例集的目标容量而不因此终止任何竞价型实例。
```
aws ec2 modify-spot-fleet-request \
--spot-fleet-request-id sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--target-capacity 10 \
--excess-capacity-termination-policy NoTermination
```
------
#### [ PowerShell ]
**修改竞价型实例集请求**
使用 [Edit-EC2SpotFleetRequest](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2SpotFleetRequest.html) cmdlet 更新指定竞价型实例集请求的目标容量。
```
Edit-EC2SpotFleetRequest `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TargetCapacity 20
```
可以按如下所示修改前面的命令，以减少指定竞价型实例集的目标容量而不因此终止任何竞价型实例。
```
Edit-EC2SpotFleetRequest `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TargetCapacity 20 `
-ExcessCapacityTerminationPolicy "NoTermination"
```
------
# 取消（删除）竞价型实例集请求
如果您不再需要竞价型实例集，则可以取消竞价型实例集请求，这将删除该请求。取消实例集请求后，与实例集关联的所有竞价型实例请求也将取消，从而不会启动任何新的竞价型实例。
取消竞价型实例集请求后，您还必须指定是否要终止其所有实例。包括按需型实例和竞价型实例。
**警告**
**终止实例是永久且不可逆转的。**
终止一个实例后，您将无法再连接到该实例，而且也无法对其进行恢复操作。被配置为在终止后删除的所有连接的 Amazon EBS 卷也将被永久删除并且无法恢复。实例存储卷中存储的所有数据将永久丢失。有关更多信息，请参阅 [实例终止的工作原理](how-ec2-instance-termination-works.md)。
在终止实例之前，请务必确保已将需要在终止后保留的所有数据备份到持久存储中。
如果您指定必须在取消实例集请求后终止实例，实例集请求会进入 `cancelled_terminating` 状态。否则，队列会进入 `cancelled_running` 状态，并且实例会继续运行，直到遇到中断或您手动将其终止。
**限制**
+ 在单个请求中，最多可以取消 100 个实例集。如果超过指定数量，将不会取消任何实例集。
------
#### [ Console ]
**取消（删除）竞价型实例集请求**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 依次选择**操作**和**取消请求**。
1. 在**取消竞价型实例请求**对话框中，执行以下操作：
1. 要在取消竞价型实例集请求的同时终止关联的实例，请将**终止实例**复选框保持为选中状态。要取消竞价型实例集请求而不终止关联的实例，请清除**终止实例**复选框。
1. 选择**确认**。
------
#### [ AWS CLI ]
**取消（删除）竞价型实例集请求并终止其实例**
使用带 `--terminate-instances` 选项的 [cancel-spot-fleet-requests](https://docs.aws.amazon.com/cli/latest/reference/ec2/cancel-spot-fleet-requests.html) 命令。
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--terminate-instances
```
下面是示例输出。
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_terminating",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
**取消（删除）竞价型实例集请求而不终止其实例**
通过改用 `--no-terminate-instances` 选项修改上一个示例。
```
aws ec2 cancel-spot-fleet-requests \
--spot-fleet-request-ids sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE \
--no-terminate-instances
```
下面是示例输出。
```
{
"SuccessfulFleetRequests": [
{
"SpotFleetRequestId": "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE",
"CurrentSpotFleetRequestState": "cancelled_running",
"PreviousSpotFleetRequestState": "active"
}
],
"UnsuccessfulFleetRequests": []
}
```
------
#### [ PowerShell ]
**取消（删除）竞价型实例集请求并终止其实例**
使用带 `-TerminateInstance` 参数的 [Stop-EC2SpotFleetRequest](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2SpotFleetRequest.html) cmdlet。
```
Stop-EC2SpotFleetRequest `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TerminateInstance $true
```
**取消（删除）竞价型实例集请求而不终止其实例**
通过更改 `-TerminateInstance` 参数的值修改上一个示例。
```
Stop-EC2SpotFleetRequest `
-SpotFleetRequestId "sfr-73fbd2ce-aa30-494c-8788-1cee4EXAMPLE" `
-TerminateInstance $false
```
------
# 了解竞价型实例集的自动扩展
*自动扩展*使您的竞价型实例集能够根据需求增加或减少其目标容量。凭借自动扩展，竞价型实例集可以响应一个或多个扩展策略，在指定范围内启动实例（横向扩展）或终止实例（横向缩减）。
通过结合使用 Amazon EC2、Amazon CloudWatch 和 Application Auto Scaling API 可实现 Spot 队列的自动扩展。通过 Amazon EC2 可创建 Spot 队列请求，通过 CloudWatch 可创建警报，通过 Application Auto Scaling 可创建扩展策略。
**自动扩缩的类型**
Spot 队列支持以下类型的自动扩展：
+ [目标跟踪扩展](spot-fleet-target-tracking.md)：针对特定指标的值，增加或减少实例集的当前容量。这与恒温器保持家里温度的方式类似：您选择所需的温度，恒温器将完成所有其他工作。
+ [步进扩展](spot-fleet-step-scaling.md) – 根据一组扩展调整，增加或减小队列的当前容量，这些调整称为步进调整，将根据警报严重程度发生变化。
+ [计划扩展](spot-fleet-scheduled-scaling.md) – 根据日期和时间增加或减少队列的当前容量。
## 注意事项
对竞价型实例集使用自动扩展时，请注意以下事项：
+ **实例权重**：如果使用[实例权重](ec2-fleet-instance-weighting.md)，请记住，竞价型实例集可以根据需要超出目标容量。执行容量可以是浮点数，但目标容量必须是整数，因此 Spot 队列向上舍入到下一个整数。在您查看触发警报时扩展策略的结果时，必须考虑这些行为。例如，假设目标容量为 30，执行容量为 30.1，扩展策略减 1。当触发报警时，自动扩展过程将 30.1 减 1 得到 29.1，然后将其向上取整为 30，因此不执行扩展操作。再如，假设您选择的实例权重为 2、4 和 8，目标容量为 10，但没有权重 2 实例可用，因此为执行容量为 12 的 Spot 队列预置权重为 4 和 8 的实例。如果扩展策略将目标容量减少 20% 并触发警报，则自动扩展过程将 12 减 12\$10.2 得到 9.6，然后将其向上取整为 10，因此不执行扩展操作。
+ **冷却时间**：您为竞价型实例集创建的扩展策略支持冷却时间。这是扩展活动完成后上一个与触发相关的扩展活动可影响将来扩展事件的秒数。对于扩大策略，虽然冷却时间有效，但启动冷却的上一个扩大事件所添加的容量将计算为下一次扩大所需容量的一部分。旨在持续 (但不过度) 扩大。对于缩小策略，冷却时间用于阻止后续缩小请求，直至到期。旨在谨慎地缩小以保护您的应用程序的可用性。但是，如果在缩小后，另一个警报在冷却时间内触发了扩大策略，自动扩展将立即扩大您的可扩展目标。
+ **使用详细监控**：建议将随实例指标扩展的频率设置为 1 分钟，这可确保更快地响应使用率变化。如果将随指标扩展的频率设置为 5 分钟，可能会导致响应时间变慢，并且可能导致系统依据陈旧的指标数据进行扩展。要每隔 1 分钟向 CloudWatch 发送一次实例的指标数据，您必须专门启用详细监控。有关更多信息，请参阅[管理 EC2 实例的详细监控](manage-detailed-monitoring.md)和[使用已定义的参数创建竞价型实例集请求](create-spot-fleet.md#create-spot-fleet-advanced)。
+ **AWS CLI**：如果要使用 AWS CLI 来配置竞价型实例集的扩展，则应使用 [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) 命令。
# Spot 队列自动扩展所需的 IAM 权限
通过结合使用 Amazon EC2、Amazon CloudWatch 和 Application Auto Scaling API 可实现 Spot 队列的自动扩展。通过 Amazon EC2 可创建 Spot 队列请求，通过 CloudWatch 可创建警报，通过 Application Auto Scaling 可创建扩展策略。除[使用竞价型实例集所需的 IAM 权限](spot-fleet-prerequisites.md#spot-fleet-iam-users)和 Amazon EC2 外，访问实例集扩展设置的用户必须具有使用支持自动扩缩的服务的适当权限。
要对竞价型实例集使用自动扩展，用户必须具有使用以下示例策略中所示操作的权限。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*",
"ec2:DescribeSpotFleetRequests",
"ec2:ModifySpotFleetRequest",
"cloudwatch:DeleteAlarms",
"cloudwatch:DescribeAlarmHistory",
"cloudwatch:DescribeAlarms",
"cloudwatch:DescribeAlarmsForMetric",
"cloudwatch:GetMetricStatistics",
"cloudwatch:ListMetrics",
"cloudwatch:PutMetricAlarm",
"cloudwatch:DisableAlarmActions",
"cloudwatch:EnableAlarmActions",
"iam:CreateServiceLinkedRole",
"sns:CreateTopic",
"sns:Subscribe",
"sns:Get*",
"sns:List*"
],
"Resource": "*"
}
]
}
```
------
您还可以创建自己的 IAM 策略，从而使 Application Auto Scaling API 调用获得更精细的权限。有关更多信息，请参阅《Application Auto Scaling User Guide》**中的 [Identity and Access Management for Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/auth-and-access-control.html)。
Application Auto Scaling 服务还需要描述 Spot 队列和 CloudWatch 警报的权限，以及代表您修改 Spot 队列目标容量的权限。如果您为竞价型实例集启用自动扩展功能，它将创建一个名为 `AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest` 的服务相关角色。此服务相关角色授予 Application Auto Scaling 权限，以描述策略警报、监控队列的当前容量以及修改队列的容量。Application Auto Scaling 的原托管竞价型实例集角色为 `aws-ec2-spot-fleet-autoscale-role`，但今后已不再需要。此服务相关角色是 Application Auto Scaling 的默认角色。有关更多信息，请参阅《Application Auto Scaling 用户指南》**中的 [Application Auto Scaling 的服务相关角色](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)。
# 目标跟踪扩展：通过确定特定指标的目标值来扩展竞价型实例集
凭借目标跟踪扩展，您可以通过选择指标并设置目标值来创建目标跟踪扩展策略。然后，竞价型实例集将创建和管理触发扩展策略的 CloudWatch 警报，并根据所选指标和目标值计算扩展调整。扩展策略通过根据需要添加或删除实例来调整容量，将指标保持在指定的目标值或接近指定的目标值。目标跟踪策略将指标保持在目标值附近，而且还可以根据由于负载模式波动而造成的指标波动进行调节，并最大限度地减少快速容量波动。
您可以为竞价型实例集创建多个目标跟踪扩展策略，但前提是每个策略分别使用不同的指标。实例集根据指定最大实例集容量的策略进行扩展。这样便可涵盖多种场景，以确保您的应用程序工作负载拥有足够的容量。
为了确保应用程序可用性，队列针对指标尽快按比例向外扩展，但会逐渐向内扩展。
当竞价型实例集因目标容量下降而终止竞价型实例时，该实例将收到一条竞价型实例中断通知。
**注意**
请勿编辑或删除 Spot 队列为目标跟踪扩展策略管理的 CloudWatch 警报。在删除目标跟踪扩展策略时，Spot 队列将自动删除警报。
**先决条件**
+ 竞价型实例集请求必须使用 `maintain` 作为请求类型。`request` 类型的请求不支持自动扩缩。
+ 配置 [Spot 队列自动扩展所需的 IAM 权限](spot-fleet-auto-scaling-IAM.md)。
+ 查看[注意事项](spot-fleet-automatic-scaling.md#considerations-for-spot-fleet-automatic-scaling)。
**配置目标跟踪策略**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**自动扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**自动扩缩**部分。
1. 如果未配置自动扩展，请选择 **Configure**。
1. 使用 **Scale capacity between** 设置队列的最小和最大容量。队列的自动扩展操作不会超出最小或最大容量范围。
1. 对于 **Policy name**（策略名称），输入此策略的名称。
1. 选择一个**目标指标**。
1. 为该指标键入一个**目标值**。
1. 对于**冷却时间**，指定新值（以秒为单位）或保留默认值。
1. （可选）要忽略根据当前配置创建横向缩减策略，请选择**禁用缩减**。您可以使用不同的配置创建一个向内扩展策略。
1. 选择 **Save**。
**使用 AWS CLI 配置目标跟踪策略**
1. 使用 [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html) 命令将 Spot 队列请求注册为可扩展目标。
1. 使用 [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) 命令创建扩展策略。
# 步进扩展：使用步进扩展策略扩展竞价型实例集
在使用步进扩展策略时，您可以指定 CloudWatch 警报以触发扩展过程。例如，如果您希望在 CPU 利用率达到特定水平时扩展，可以使用 Amazon EC2 提供的 `CPUUtilization` 指标创建警报。
在创建步进扩展策略时，您必须指定以下扩展调整类型之一：
+ **Add (增加)** – 按指定的容量单位数量或当前容量的指定百分比来增加队列的目标容量。
+ **Remove (移走)** – 按指定的容量单位数量或当前容量的指定百分比来缩减队列的目标容量。
+ **Set to (设定为)** – 将队列的目标容量设为指定的容量单位数量。
当触发警报时，自动扩展过程使用执行容量和扩展策略计算新的目标容量，然后相应地更新目标容量。例如，假设目标容量和执行容量为 10，扩展策略加 1。触发警报时，自动扩展过程为 10 增加 1 得到 11，因此 Spot 队列将启动 1 个实例。
当竞价型实例集因目标容量下降而终止竞价型实例时，该实例将收到一条竞价型实例中断通知。
**先决条件**
+ 竞价型实例集请求必须使用 `maintain` 作为请求类型。`request` 类型的请求不支持自动扩缩。
+ 配置 [Spot 队列自动扩展所需的 IAM 权限](spot-fleet-auto-scaling-IAM.md)。
+ 考虑哪些 CloudWatch 指标对您的应用程序比较重要。您可以根据 AWS 提供的指标或您自己的自定义指标来创建 CloudWatch 告警。
+ 如果您打算在扩展策略中使用 AWS 指标，请为其启用 CloudWatch 指标集合（如果提供这些指标的服务默认未启用它的话）。
+ 查看[注意事项](spot-fleet-automatic-scaling.md#considerations-for-spot-fleet-automatic-scaling)。
**创建 CloudWatch 警报**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，展开**警报**，然后选择**所有警报**。
1. 选择 **Create Alarm (创建警报)**。
1. 在 **Specify metric and conditions (指定指标和条件)** 页面上，选择 **Select metric (选择指标)**。
1. 依次选择 **EC2 竞价型实例**、**实例集请求指标**，选择一个指标（例如，**TargetCapacity**），然后选择**选择指标**。
这将显示 **Specify metric and conditions (指定指标和条件)** 页面，其中显示一个图表以及有关所选指标的其他信息。
1. 对于**周期**，选择警报的评估周期，例如 **1 分钟**。评估警报时，每个周期都聚合到一个数据点。
**注意**
周期越短，创建的警报越敏感。
1. 在 **Conditions (条件)** 下，通过定义阈值条件来定义警报。例如，您可以定义一个阈值，在指标值大于或等于 80% 时触发警报。
1. 在 **Additional configuration (附加配置)** 下，对于 **Datapoints to alarm (触发警报的数据点数)**，请指定必须有多少个数据点（评估期）处于 ALARM 状态才会触发警报，例如，1 个或 2 个（共 3 个）评估期。这将创建一个警报，如果多个连续周期超出阈值，该警报将进入 ALARM（警报）状态。有关更多信息，请参阅 *Amazon CloudWatch 用户指南* 中的[评估警报](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarm-evaluation)。
1. 对于 **Missing data treatment (缺失数据处理)**，选择某个选项（或保留 **Treat missing data as missing (将缺失的数据视为缺失)** 的默认值）。有关更多信息，请参阅 *Amazon CloudWatch 用户指南*中的[配置 CloudWatch 警报处理缺少数据的方式](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarms-and-missing-data)。
1. 选择**下一步**。
1. （可选）要接收扩展事件的通知，在 **Notification (通知)** 中，您可以选择或创建要用于接收通知的 Amazon SNS 主题。当然，您也可以立即删除通知，之后按需添加通知。
1. 选择**下一步**。
1. 在**添加名称和描述**下，输入警报的名称和描述，然后选择**下一步**。
1. 选择**创建警报**。
**为竞价型实例集配置分步扩展策略**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**自动扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**自动扩缩**部分。
1. 如果未配置自动扩展，请选择 **Configure**。
1. 使用 **Scale capacity between** 设置队列的最小和最大容量。扩展策略不会将实例集扩展至超出最小或最大容量范围。
1. 在**扩展策略**下，对于**策略类型**，选择**步进扩展策略**。
1. 最初，**扩展策略**包含名为 **ScaleUp** 和 **ScaleDown** 的分步扩展策略。您可以完善这些策略，或选择 **Remove policy** 来删除它们。您也可以选择 **Add policy (添加策略)**。
1. 要定义策略，请执行以下操作：
1. 对于 **Policy name**（策略名称），输入此策略的名称。
1. 对于**策略触发器**，可以选择现有的警报，也可以选择**创建警报**打开 Amazon CloudWatch 控制台并创建警报。
1. 对于**修改容量**，定义扩展量以及分步调整的下限和上限。您可以添加或删除特定数量的实例或现有实例集大小的百分比，也可将实例集设置为准确的大小。
例如，要创建将实例集容量增加 30% 的步进扩展策略，请选择**添加**，在下一个字段中输入 **30**，然后选择**百分比**。默认情况下，添加策略的下限为警报阈值，上限为正（\$1）无穷。默认情况下，移除策略的上限为警报阈值，下限为负 (-) 无穷。
1. （可选）要添加其他步骤，请选择**添加步骤**。
1. 对于**冷却时间**，指定新值（以秒为单位）或保留默认值。
1. 选择**保存**。
**使用 AWS CLI 为竞价型实例集配置分步扩展策略**
1. 使用 [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html) 命令将 Spot 队列请求注册为可扩展目标。
1. 使用 [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) 命令创建扩展策略。
1. 使用 [put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html) 命令创建触发扩展策略的警报。
# 计划扩展：按计划扩展竞价型实例集
按计划扩展实例集使您可以按照可预测的需求变化来扩展应用程序。通过创建*计划操作*，您可以指示竞价型实例集在特定时间执行扩展活动。要创建计划的操作，您必须指定现有的竞价型实例集、必须发生扩展活动的时间以及所需的最小容量和最大容量。可以将计划操作配置为一次性或按定期计划进行扩展。如果需要更改，可以编辑或删除计划的操作。
**先决条件**
+ 只能为现有竞价型实例集创建计划操作。您不能在创建竞价型实例集时创建计划操作。
+ 竞价型实例集请求必须使用 `maintain` 作为请求类型。`request` 类型的请求不支持自动扩缩。
+ 配置 [Spot 队列自动扩展所需的 IAM 权限](spot-fleet-auto-scaling-IAM.md)。
+ 查看[注意事项](spot-fleet-automatic-scaling.md#considerations-for-spot-fleet-automatic-scaling)。
**创建一次性计划操作**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**计划扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**计划扩缩**部分。
1. 选择**创建计划操作**。
1. 对于 **Name (名称)**，请指定计划操作的名称。
1. 对于 **Minimum capacity (最小容量)** 和/或 **Maximum capacity (最大容量)**，输入所需的值。
1. 对于 **Recurrence (重复次数)**，选择 **Once (一次)**。
1. （可选）对于 **Start time (开始时间)** 和/或 **End time (结束时间)**，选择所需的日期和时间。
1. 选择**创建**。
**创建重复计划操作**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**计划扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**计划扩缩**部分。
1. 对于 **Name (名称)**，请指定计划操作的名称。
1. 对于 **Minimum capacity (最小容量)** 和/或 **Maximum capacity (最大容量)**，输入所需的值。
1. 对于 **Recurrence**（重复次数），选择预定义计划之一（例如 **Every day**（每天）），或者选择 **Custom**（自定义）并输入 cron 表达式。有关计划扩展所支持的 cron 表达式的更多信息，请参阅《Amazon EventBridge User Guide》**中的 [Cron expressions](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions)。
1. （可选）对于 **Start time (开始时间)** 和/或 **End time (结束时间)**，选择所需的日期和时间。
1. 选择**提交**。
**编辑计划操作**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**计划扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**计划扩缩**部分。
1. 选择所需的计划操作，然后依次选择 **Actions (操作)** 和 **Edit (编辑)**。
1. 进行所需的更改，然后选择 **Submit (提交)**。
**删除计划操作**
1. 通过以下网址打开 Amazon EC2 控制台：[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。
1. 在导航窗格中，请选择 **Spot Requests**。
1. 选择 Spot 队列请求。
1. 选择屏幕底部附近的**计划扩缩**选项卡。如果您选择了竞价型实例集的链接，则没有选项卡；而是向下滚动到**计划扩缩**部分。
1. 选择所需的计划操作，然后依次选择 **Actions (操作)** 和 **Delete (删除)**。
1. 当系统提示进行确认时，选择 **Delete (删除)**。
**使用 AWS CLI 管理计划扩展**
使用以下命令：
+ [put-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scheduled-action.html)
+ [describe-scheduled-actions](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scheduled-actions.html)
+ [delete-scheduled-action](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scheduled-action.html)
# 监控 EC2 实例集或竞价型实例集
有效监控您的 EC2 实例集或竞价型实例集对于保持最佳性能和确保可靠性至关重要。有各种工具可以帮助您实现这一目标，包括本主题中介绍的 Amazon CloudWatch 和 Amazon EventBridge。
使用 CloudWatch，您可以收集和跟踪指标，设置警报，并自动应对实例集的状态变化。
借助 EventBridge，您可以通过编程方式监控和响应实例集发出的事件。通过在 EventBridge 中定义规则，您可以自动响应特定的实例集事件，例如实例终止或实例集状态更改，从而提高运营效率。
**Topics**
+ [
# 使用 CloudWatch 监控 EC2 实例集或竞价型实例集
](ec2-fleet-cloudwatch-metrics.md)
+ [
# 使用 Amazon EventBridge 监控并以编程方式响应您的 EC2 实例集或竞价型实例集发出的事件
](monitor-ec2-fleet-using-eventbridge.md)
# 使用 CloudWatch 监控 EC2 实例集或竞价型实例集
您可以使用本节所述的 Amazon CloudWatch 指标监控 EC2 实例集或竞价型实例集。
**重要**
为确保准确性，我们建议您在使用这些指标时启用详细监控。有关更多信息，请参阅 [管理 EC2 实例的详细监控](manage-detailed-monitoring.md)。
有关使用 CloudWatch 的更多信息，请参阅[使用 CloudWatch 监控您的实例](using-cloudwatch.md)。
## EC2 实例集和竞价型实例集指标
`AWS/EC2Spot` 命名空间包含以下实例集指标，以及实例集中竞价型实例的 CloudWatch 指标。有关更多信息，请参阅 [实例指标](viewing_metrics_with_cloudwatch.md#ec2-cloudwatch-metrics)。
| 指标 | 说明 |
| --- | --- |
| AvailableInstancePoolsCount | 实例集请求中指定的竞价型容量池。 单位：计数 |
| BidsSubmittedForCapacity | Amazon EC2 已提交实例集请求的容量。 单位：计数 |
| EligibleInstancePoolCount | 在 Amazon EC2 可以完成请求的实例集请求中指定的竞价型容量池。在您愿意为竞价型实例支付的最高价格低于 Spot 价格或 Spot 价格高于按需型实例价格的池中，Amazon EC2 不会完成请求。 单位：计数 |
| FulfilledCapacity | Amazon EC2 已执行的容量。 单位：计数 |
| MaxPercentCapacityAllocation | 实例集请求中指定的所有实例集池间的 `PercentCapacityAllocation` 最大值。 单位：百分比 |
| PendingCapacity | `TargetCapacity` 与 `FulfilledCapacity` 之间的区别。 单位：计数 |
| PercentCapacityAllocation | 针对所指定维度的 Spot 容量池分配的容量。要获取所有 Spot 容量池中记录的最大值，请使用 `MaxPercentCapacityAllocation`。 单位：百分比 |
| TargetCapacity | 实例集请求的目标容量。 单位：计数 |
| TerminatingCapacity | 因预置容量大于目标容量而终止的容量。 单位：计数 |
如果指标的度量单位是 `Count`，则最有用的统计信息是 `Average`。
## EC2 实例集和竞价型实例集维度
要筛选实例集的数据，请使用以下维度。
| Dimensions | 描述 |
| --- | --- |
| AvailabilityZone | 按照可用区筛选数据。 |
| FleetRequestId | 按照实例集请求筛选数据。 |
| InstanceType | 按实例类型筛选数据。 |
## 查看 EC2 实例集或竞价型实例集的 CloudWatch 指标
您可以使用 Amazon CloudWatch 控制台查看实例集的 CloudWatch 指标。这些指标显示为监控图表。如果实例集处于活动状态，则这些图表会显示数据点。
指标首先按命名空间进行分组，然后按各命名空间内的各种维度组合进行分组。例如，您可以按实例集请求 ID、实例类型或可用区查看所有实例集指标或实例集指标组。
**查看实例集指标**
1. 通过 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 打开 CloudWatch 控制台。
1. 在导航窗格中，展开**指标**，然后选择**所有指标**。
1. 选择 **EC2 Spot** 命名空间。
**注意**
如果未显示 **EC2 Spot** 命名空间，这种情况有两个原因。您从未在该区域中使用过 EC2 实例集或竞价型实例集 – 只有正在使用的 AWS 服务才会将指标发送到 Amazon CloudWatch。或者，如果您在该区域中使用了 EC2 实例集或竞价型实例集，但过去两周没有使用，则不会显示命名空间。
1. 要按维度筛选指标，请选择下列选项之一：
+ **实例集请求指标** – 按实例集请求分组
+ **按可用区** – 按实例集请求和可用区分组
+ **按实例类型** – 按实例集请求和实例类型分组
+ **按可用区/实例类型** – 按实例集请求、可用区和实例类型分组
1. 要查看某指标的数据，请选中该指标旁边的复选框。
# 使用 Amazon EventBridge 监控并以编程方式响应您的 EC2 实例集或竞价型实例集发出的事件
当 EC2 实例集或竞价型实例集的状态发生变化时，其将发出通知。该通知作为发送到 Amazon EventBridge（以前称为 Amazon CloudWatch Events）的事件提供。尽最大努力发出事件。
您可以使用 Amazon EventBridge 创建触发编程操作以响应事件的规则。例如，您可以创建两个 EventBridge 规则：一个在实例集状态变化时触发，另一个在实例集中的实例终止时触发。在本例中，您可以配置第一条规则，这样如果实例集状态发生变化，该规则将调用 SNS 主题，向您发送电子邮件通知。您可以配置第二条规则，这样如果实例集中的实例被终止，该规则将调用 Lambda 函数以启动新实例。
**注意**
只有类型 `maintain` 和 `request` 的队列才能触发事件。类型 `instant` 的队列不会触发事件，因为它们提交同步一次性请求，并且队列的状态立即可在响应中获知。要使用 Amazon EventBridge 监控实例集事件，请求类型必须为 `maintain` 或 `request`。
有关如何描述实例集事件历史记录的说明，请参阅[描述 EC2 实例集的事件历史记录](describe-ec2-fleet.md#describe-ec2-fleet-event-history)。
**Topics**
+ [
## 创建 Amazon EventBridge 规则以监控 EC2 实例集或竞价型实例集事件
](#fleet_create-eventbridge-rules)
+ [
## EC2 队列 事件类型
](#ec2-fleet-event-types)
+ [
## Spot 队列事件类型
](#spot-fleet-event-types)
## 创建 Amazon EventBridge 规则以监控 EC2 实例集或竞价型实例集事件
当 EC2 实例集或竞价型实例集发出状态变更通知时，该通知将作为事件以 JSON 文件的形式发送到 Amazon EventBridge。如果 EventBridge 检测到与规则中定义的模式匹配的事件模式，则 EventBridge 调用规则中指定的一个或多个目标。
您可以编写 EventBridge 规则，从而根据匹配的事件模式自动执行操作。
事件中的下列字段构成规则中定义的事件模式：
`"source": "aws.ec2fleet"`
识别来自 EC2 队列 的事件。
`"detail-type": "EC2 Fleet State Change"`
识别事件类型。
`"detail": { "sub-type": "submitted" }`
识别事件子类型。
有关 EC2 实例集和竞价型实例集事件和示例事件数据的列表，请参阅 [EC2 队列 事件类型](#ec2-fleet-event-types)和[Spot 队列事件类型](#spot-fleet-event-types)。
**Topics**
+ [
### 创建 EventBridge 规则以发送通知
](#eventbridge-send-notification)
+ [
### 创建 EventBridge 规则以触发 Lambda 函数
](#eventbridge-trigger-lambda)
### 创建 EventBridge 规则以发送通知
下面的示例可创建 EventBridge 规则，以便在 Amazon EC2 每次发出 EC2 队列状态变化通知时发送电子邮件、短信或移动推送通知。本示例中的信号作为 `EC2 Fleet State Change` 事件发出，这将触发规则定义的操作。
**先决条件**
创建 EventBridge 规则之前，您必须为电子邮件、短信或移动推送通知创建 Amazon SNS 主题。
**创建 EventBridge 规则以在 EC2 队列 状态变化时发送通知**
1. 打开位于 [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/) 的 Amazon EventBridge 控制台。
1. 选择 **Create rule**（创建规则）。
1. 对于**定义规则详细信息**，请执行以下操作：
1. 输入规则的 **Name (名称)** 和“Description (描述)”（可选）。
规则不能与同一区域中的另一个规则和同一事件总线上的名称相同。
1. 对于 **Event bus**（事件总线），选择 **default**（默认）。当您账户中的某个 AWS 服务生成一个事件时，它始终会发送到您账户的默认事件总线。
1. 对于 **Rule type**（规则类型），选择 **Rule with an event pattern**（具有事件模式的规则）。
1. 选择**下一步**。
1. 对于 **Build event pattern**（构建事件模式），执行以下操作：
1. 对于 **Event source**（事件源），选择 **AWS 事件或 EventBridge 合作伙伴事件**。
1. 对于 **Event pattern**（事件模式），在此示例中，您将指定以下事件模式以匹配 `EC2 Fleet Instance Change` 事件。
```
{
"source": ["aws.ec2fleet"],
"detail-type": ["EC2 Fleet Instance Change"]
}
```
要添加事件模式，您可以通过选择 **Event pattern form**（事件模式表）使用模板，或者通过选择 **Custom pattern (JSON editor)**（自定义模式（JSON 编辑器））指定您自己的模式，如下所示：
1. 要使用模板创建事件模式，请执行以下操作：
1. 选择 **Event pattern form**（事件模式表）。
1. 对于 **Event source**（事件源），选择 **AWS services**（服务）。
1. 对于 **AWS 服务**，选择 **EC2 实例集**。
1. 对于 **Event type**（事件类型），选择 **EC2 Fleet Instance Change**（EC2 实例集实例更改）。
1. 要自定义模板，请选择 **Edit pattern**（编辑模式），然后进行更改以匹配示例事件模式。
1. （可选）要指定自定义事件模式，请执行以下操作：
1. 选择 **Custom pattern (JSON editor)**（自定义模式（JSON 编辑器））。
1. 在 **Event pattern**（事件模式）框中，为此示例添加事件模式。
1. 选择**下一步**。
1. 对于 **Select target(s)**（选择目标），请执行以下操作：
1. 对于 **Target types**（目标类型），选择 **AWS service**（服务）。
1. 对于 **Select a target**（选择目标），选择 **SNS topic**（SNS 主题）以在事件发生时发送电子邮件、短信或移动推送通知。
1. 对于 **Topic**（主题），选择现有主题。您首先需要使用 Amazon SNS 控制台创建 Amazon SNS 主题。有关更多信息，请参阅*Amazon Simple Notification Service 开发人员指南*中的[使用 Amazon SNS 进行应用程序对人 (A2P) 消息传送](https://docs.aws.amazon.com//sns/latest/dg/sns-user-notifications.html)。
1. （可选）在 **Additional settings**（其他设置）下，您可以选择配置其他设置。有关更多信息，请参阅《Amazon EventBridge User Guide》**中的 [Creating Amazon EventBridge rules that react to events](https://docs.aws.amazon.com//eventbridge/latest/userguide/eb-create-rule.html)（步骤 16）。
1. 选择**下一步**。
1. （可选）对于 **Tags**（标签），您可以选择向规则分配一个或多个标签，然后选择 **Next**（下一步）。
1. 对于 **Review and create**（查看与创建），执行以下操作：
1. 查看规则的详细信息并根据需要对其进行修改。
1. 选择 **Create rule**（创建规则）。
有关更多信息，请参阅 *Amazon EventBridge 用户指南*中的 [Amazon EventBridge 规则](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rules.html)和 [Amazon EventBridge 事件模式](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html)。
### 创建 EventBridge 规则以触发 Lambda 函数
下面的示例可创建 EventBridge 规则，以便在 Amazon EC2 每次在实例启动时发出 EC2 队列实例变更通知时触发 Lambda 函数。本示例中的信号作为 `EC2 Fleet Instance Change` 事件子类型 `launched` 发出，这将触发规则定义的操作。
在创建 EventBridge 规则之前，您必须创建 Lambda 函数。
**创建要在 EventBridge 规则中使用的 Lambda 函数**
1. 通过 [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 打开 AWS Lambda 控制台。
1. 选择**创建函数**。
1. 输入函数的名称，配置代码，然后选择 **Create function**（创建函数）。
有关更多信息，请参阅《AWS Lambda 开发人员指南》**中的[创建第一个 Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)。
**创建 EventBridge 规则以在 EC2 队列 中的实例改变状态时触发 Lambda 函数**
1. 打开位于 [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/) 的 Amazon EventBridge 控制台。
1. 选择 **Create rule**（创建规则）。
1. 对于**定义规则详细信息**，请执行以下操作：
1. 输入规则的 **Name (名称)** 和“Description (描述)”（可选）。
规则不能与同一区域中的另一个规则和同一事件总线上的名称相同。
1. 对于 **Event bus**（事件总线），选择 **default**（默认）。当您账户中的某个 AWS 服务生成一个事件时，它始终会发送到您账户的默认事件总线。
1. 对于 **Rule type**（规则类型），选择 **Rule with an event pattern**（具有事件模式的规则）。
1. 选择**下一步**。
1. 对于 **Build event pattern**（构建事件模式），执行以下操作：
1. 对于 **Event source**（事件源），选择 **AWS 事件或 EventBridge 合作伙伴事件**。
1. 对于 **Event pattern**（事件模式），在此示例中，您将指定以下事件模式以匹配 `EC2 Fleet Instance Change` 事件和 `launched` 子类型。
```
{
"source": ["aws.ec2fleet"],
"detail-type": ["EC2 Fleet Instance Change"],
"detail": {
"sub-type": ["launched"]
}
```
要添加事件模式，您可以通过选择 **Event pattern form**（事件模式表）使用模板，或者通过选择 **Custom pattern (JSON editor)**（自定义模式（JSON 编辑器））指定您自己的模式，如下所示：
1. 要使用模板创建事件模式，请执行以下操作：
1. 选择 **Event pattern form**（事件模式表）。
1. 对于 **Event source**（事件源），选择 **AWS services**（服务）。
1. 对于 **AWS 服务**，选择 **EC2 实例集**。
1. 对于 **Event type**（事件类型），选择 **EC2 Fleet Instance Change**（EC2 实例集实例更改）。
1. 选择 **Edit pattern**（编辑模式），然后添加 `"detail": {"sub-type": ["launched"]` 以匹配示例事件模式。对于正确的 JSON 格式，在前面的方括号（`,`）之后插入一个逗号（`]`）。
1. （可选）要指定自定义事件模式，请执行以下操作：
1. 选择 **Custom pattern (JSON editor)**（自定义模式（JSON 编辑器））。
1. 在 **Event pattern**（事件模式）框中，为此示例添加事件模式。
1. 选择**下一步**。
1. 对于 **Select target(s)**（选择目标），请执行以下操作：
1. 对于 **Target types**（目标类型），选择 **AWS service**（服务）。
1. 对于 **Select a target**（选择目标），选择 **SNS topic**（SNS 主题）以在事件发生时发送电子邮件、短信或移动推送通知。
1. 对于 **Topic**（主题），选择 **Lambda function**（Lambda 函数），对于 **Function**（函数），选择您创建的用于在事件发生时响应的函数。
1. （可选）在 **Additional settings**（其他设置）下，您可以选择配置其他设置。有关更多信息，请参阅《Amazon EventBridge User Guide》**中的 [Creating Amazon EventBridge rules that react to events](https://docs.aws.amazon.com//eventbridge/latest/userguide/eb-create-rule.html)（步骤 16）。
1. 选择**下一步**。
1. （可选）对于 **Tags**（标签），您可以选择向规则分配一个或多个标签，然后选择 **Next**（下一步）。
1. 对于 **Review and create**（查看与创建），执行以下操作：
1. 查看规则的详细信息并根据需要对其进行修改。
1. 选择 **Create rule**（创建规则）。
有关如何创建 Lambda 函数和运行 Lambda 函数的 EventBridge 规则的教程，请参阅 *AWS Lambda 开发人员指南*中的[教程：使用 EventBridge 记录 Amazon EC2 实例的状态](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-log-ec2-instance-state.html)。
## EC2 队列 事件类型
EC2 队列 事件类型有五种。对于每种事件类型，都有几个子类型。
**Topics**
+ [
### EC2 队列状态变化
](#ec2-fleet-state-change)
+ [
### EC2 实例集竞价型实例请求更改
](#ec2-fleet-spot-instance-request-change)
+ [
### EC2 队列实例更改
](#ec2-fleet-instance-change)
+ [
### EC2 队列信息
](#ec2-fleet-info)
+ [
### EC2 队列错误
](#ec2-fleet-config-not-valid)
### EC2 队列状态变化
当 EC2 队列 状态变化时，EC2 队列 会将 `EC2 Fleet State Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "715ed6b3-b8fc-27fe-fad6-528c7b8bf8a2",
"detail-type": "EC2 Fleet State Change",
"source": "aws.ec2fleet",
"account": "123456789012",
"time": "2020-11-09T09:00:20Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:fleet/fleet-598fb973-87b7-422d-be4d-6b0809bfff0a"
],
"detail": {
"sub-type": "active"
}
}
```
`sub-type` 可使用的值为：
`active`
EC2 队列 请求已验证，并且 Amazon EC2 正在尝试使正在运行的实例保持目标数量。
`deleted`
EC2 队列 请求已删除，没有正在运行的实例。EC2 队列 将在其实例终止两天后被删除。
`deleted_running`
EC2 队列 请求已删除，且不启动其他实例。现有实例将继续运行，直至被中断或终止。请求会保持此状态，直到所有实例都已中断或终止。
`deleted_terminating`
EC2 队列 请求已删除，正在终止其实例。请求会保持此状态，直到所有实例都已终止。
`expired`
EC2 队列 请求已过期。如果请求使用 `TerminateInstancesWithExpiration` 集创建，则随后的 `terminated` 事件指示实例已终止。
`modify_in_progress`
正在修改 EC2 队列 请求。请求将保持该状态，直到完全处理修改。
`modify_succeeded`
EC2 队列 请求已修改。
`submitted`
EC2 队列 正在接受评估，并且 Amazon EC2 正准备启动目标数量的实例。
`progress`
该 EC2 队列 请求正在执行过程中。
### EC2 实例集竞价型实例请求更改
当队列中的 Spot 实例请求状态变化时，EC2 队列 会将 `EC2 Fleet Spot Instance Request Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "19331f74-bf4b-a3dd-0f1b-ddb1422032b9",
"detail-type": "EC2 Fleet Spot Instance Request Change",
"source": "aws.ec2fleet",
"account": "123456789012",
"time": "2020-11-09T09:00:05Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:fleet/fleet-83fd4e48-552a-40ef-9532-82a3acca5f10"
],
"detail": {
"spot-instance-request-id": "sir-rmqske6h",
"description": "SpotInstanceRequestId sir-rmqske6h, PreviousState: cancelled_running",
"sub-type": "cancelled"
}
}
```
`sub-type` 可使用的值为：
`active`
竞价型实例请求已执行并有关联的竞价型实例。
`cancelled`
您取消了竞价型实例请求，或竞价型实例请求已过期。
`disabled`
您停止了竞价型实例。
`submitted`
已提交竞价型实例请求。
### EC2 队列实例更改
当队列中的实例状态变化时，EC2 队列 会将 `EC2 Fleet Instance Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "542ce428-c8f1-0608-c015-e8ed6522c5bc",
"detail-type": "EC2 Fleet Instance Change",
"source": "aws.ec2fleet",
"account": "123456789012",
"time": "2020-11-09T09:00:23Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:fleet/fleet-598fb973-87b7-422d-be4d-6b0809bfff0a"
],
"detail": {
"instance-id": "i-0c594155dd5ff1829",
"description": "{\"instanceType\":\"c5.large\",\"image\":\"ami-6057e21a\",\"productDescription\":\"Linux/UNIX\",\"availabilityZone\":\"us-east-1d\"}",
"sub-type": "launched"
}
}
```
`sub-type` 可使用的值为：
`launched`
启动了一个新实例。
`terminated`
实例已终止。
`termination_notified`
当 Amazon EC2 在缩减期间终止竞价型实例时，机群的目标容量被缩减，例如，从目标容量 4 减至目标容量 3 时，会发送实例终止通知。
### EC2 队列信息
在履行过程中出错时，EC2 队列 会将 `EC2 Fleet Information` 事件发送到 Amazon EventBridge。信息事件不会阻止队列尝试实现其目标容量。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "76529817-d605-4571-7224-d36cc1b2c0c4",
"detail-type": "EC2 Fleet Information",
"source": "aws.ec2fleet",
"account": "123456789012",
"time": "2020-11-09T08:17:07Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:fleet/fleet-8becf5fe-bb9e-415d-8f54-3fa5a8628b91"
],
"detail": {
"description": "c4.xlarge, ami-0947d2ba12ee1ff75, Linux/UNIX, us-east-1a, Spot price in either SpotFleetRequestConfigData or SpotFleetLaunchSpecification or LaunchTemplate or LaunchTemplateOverrides is less than Spot market price $0.0619",
"sub-type": "launchSpecUnusable"
}
}
```
`sub-type` 可使用的值为：
`fleetProgressHalted`
每个启动规范中的价格无效，因为它低于 Spot 价格（所有启动规范都已生成 `launchSpecUnusable` 事件）。如果 Spot 价格发生变化，启动规范可能会变为有效。
`launchSpecTemporarilyBlacklisted`
配置无效，多次启动实例的尝试都已失败。有关更多信息，请参阅事件的描述。
`launchSpecUnusable`
启动规范中的价格无效，因为它低于 Spot 价格。
`registerWithLoadBalancersFailed`
尝试向负载均衡器注册实例失败。有关更多信息，请参阅事件的描述。
### EC2 队列错误
在履行过程中出错时，EC2 队列 会将 `EC2 Fleet Error` 事件发送到 Amazon EventBridge。错误事件阻止了队列尝试实现其目标容量。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "69849a22-6d0f-d4ce-602b-b47c1c98240e",
"detail-type": "EC2 Fleet Error",
"source": "aws.ec2fleet",
"account": "123456789012",
"time": "2020-10-07T01:44:24Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:fleet/fleet-9bb19bc6-60d3-4fd2-ae47-d33e68eafa08"
],
"detail": {
"description": "m3.large, ami-00068cd7555f543d5, Linux/UNIX: IPv6 is not supported for the instance type 'm3.large'. ",
"sub-type": "spotFleetRequestConfigurationInvalid"
}
}
```
`sub-type` 可使用的值为：
`iamFleetRoleInvalid`
EC2 机群没有启动或终止实例所需的权限。
`allLaunchSpecsTemporarilyBlacklisted`
所有配置均无效，多次启动实例的尝试已失败。有关更多信息，请参阅事件的描述。
`spotInstanceCountLimitExceeded`
您已达到可启动的竞价型实例的数量限制。
`spotFleetRequestConfigurationInvalid`
该配置无效。有关更多信息，请参阅事件的描述。
## Spot 队列事件类型
Spot 队列事件类型有五种。对于每种事件类型，都有几个子类型。
**Topics**
+ [
### EC2 Spot 队列状态变化
](#spot-fleet-state-change)
+ [
### EC2竞价型实例集竞价型实例请求更改
](#spot-fleet-spot-instance-request-change)
+ [
### EC2 Spot 队列实例更改
](#spot-fleet-instance-change)
+ [
### EC2 Spot 队列信息
](#spot-fleet-info)
+ [
### EC2 Spot 队列错误
](#spot-fleet-config-not-valid)
### EC2 Spot 队列状态变化
当 Spot 队列状态变化时，Spot 队列会将 `EC2 Spot Fleet State Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "d1af1091-6cc3-2e24-203a-3b870e455d5b",
"detail-type": "EC2 Spot Fleet State Change",
"source": "aws.ec2spotfleet",
"account": "123456789012",
"time": "2020-11-09T08:57:06Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-4b6d274d-0cea-4b2c-b3be-9dc627ad1f55"
],
"detail": {
"sub-type": "submitted"
}
}
```
`sub-type` 可使用的值为：
`active`
已验证竞价型实例集请求，并且 Amazon EC2 正在尝试维护目标数量的正在运行的实例。
`cancelled`
竞价型实例集请求已取消，没有正在运行的实例。Spot 队列将在其实例终止两天后被删除。
`cancelled_running`
竞价型实例集请求已取消，且不启动其他实例。现有实例将继续运行，直至被中断或终止。请求会保持此状态，直到所有实例都已中断或终止。
`cancelled_terminating`
竞价型实例集请求已取消，正在终止其实例。请求会保持此状态，直到所有实例都已终止。
`expired`
Spot 队列请求已过期。如果请求使用 `TerminateInstancesWithExpiration` 集创建，则随后的 `terminated` 事件指示实例已终止。
`modify_in_progress`
Spot 队列请求正在修改中。请求将保持该状态，直到完全处理修改。
`modify_succeeded`
Spot 队列请求已修改。
`submitted`
正在评估 Spot 队列请求，并且 Amazon EC2 正准备启动目标数量的实例。
`progress`
Spot 队列请求正在执行过程中。
### EC2竞价型实例集竞价型实例请求更改
当队列中的 Spot 实例请求状态变化时，Spot 队列会将 `EC2 Spot Fleet Spot Instance Request Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "cd141ef0-14af-d670-a71d-fe46e9971bd2",
"detail-type": "EC2 Spot Fleet Spot Instance Request Change",
"source": "aws.ec2spotfleet",
"account": "123456789012",
"time": "2020-11-09T08:53:21Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-a98d2133-941a-47dc-8b03-0f94c6852ad1"
],
"detail": {
"spot-instance-request-id": "sir-a2w9gc5h",
"description": "SpotInstanceRequestId sir-a2w9gc5h, PreviousState: cancelled_running",
"sub-type": "cancelled"
}
}
```
`sub-type` 可使用的值为：
`active`
竞价型实例请求已执行并有关联的竞价型实例。
`cancelled`
您取消了竞价型实例请求，或竞价型实例请求已过期。
`disabled`
您停止了竞价型实例。
`submitted`
已提交竞价型实例请求。
### EC2 Spot 队列实例更改
当队列中的实例状态变化时，Spot 队列会将 `EC2 Spot Fleet Instance Change` 事件发送到 Amazon EventBridge。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "11591686-5bd7-bbaa-eb40-d46529c2710f",
"detail-type": "EC2 Spot Fleet Instance Change",
"source": "aws.ec2spotfleet",
"account": "123456789012",
"time": "2020-11-09T07:25:02Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-c8a764a4-bedc-4b62-af9c-0095e6e3ba61"
],
"detail": {
"instance-id": "i-08b90df1e09c30c9b",
"description": "{\"instanceType\":\"r4.2xlarge\",\"image\":\"ami-032930428bf1abbff\",\"productDescription\":\"Linux/UNIX\",\"availabilityZone\":\"us-east-1a\"}",
"sub-type": "launched"
}
}
```
`sub-type` 可使用的值为：
`launched`
启动了一个新实例。
`terminated`
实例已终止。
`termination_notified`
当 Amazon EC2 在缩减期间终止竞价型实例时，机群的目标容量被缩减，例如，从目标容量 4 减至目标容量 3 时，会发送实例终止通知。
### EC2 Spot 队列信息
在履行过程中出错时，Spot 队列会将 `EC2 Spot Fleet Information` 事件发送到 Amazon EventBridge。信息事件不会阻止队列尝试实现其目标容量。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "73a60f70-3409-a66c-635c-7f66c5f5b669",
"detail-type": "EC2 Spot Fleet Information",
"source": "aws.ec2spotfleet",
"account": "123456789012",
"time": "2020-11-08T20:56:12Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-2531ea06-af18-4647-8757-7d69c94971b1"
],
"detail": {
"description": "r3.8xlarge, ami-032930428bf1abbff, Linux/UNIX, us-east-1a, Spot bid price is less than Spot market price $0.5291",
"sub-type": "launchSpecUnusable"
}
}
```
`sub-type` 可使用的值为：
`fleetProgressHalted`
每个启动规范中的价格无效，因为它低于 Spot 价格（所有启动规范都已生成 `launchSpecUnusable` 事件）。如果 Spot 价格发生变化，启动规范可能会变为有效。
`launchSpecTemporarilyBlacklisted`
配置无效，多次启动实例的尝试都已失败。有关更多信息，请参阅事件的描述。
`launchSpecUnusable`
启动规范中的价格无效，因为它低于 Spot 价格。
`registerWithLoadBalancersFailed`
尝试向负载均衡器注册实例失败。有关更多信息，请参阅事件的描述。
### EC2 Spot 队列错误
在履行过程中出错时，Spot 队列会将 `EC2 Spot Fleet Error` 事件发送到 Amazon EventBridge。错误事件阻止了队列尝试实现其目标容量。
以下是此事件的示例数据。
```
{
"version": "0",
"id": "10adc4e7-675c-643e-125c-5bfa1b1ba5d2",
"detail-type": "EC2 Spot Fleet Error",
"source": "aws.ec2spotfleet",
"account": "123456789012",
"time": "2020-11-09T06:56:07Z",
"region": "us-east-1",
"resources": [
"arn:aws:ec2:us-east-1:123456789012:spot-fleet-request/sfr-38725d30-25f1-4f30-83ce-2907c56dba17"
],
"detail": {
"description": "r4.2xlarge, ami-032930428bf1abbff, Linux/UNIX: The associatePublicIPAddress parameter can only be specified for the network interface with DeviceIndex 0. ",
"sub-type": "spotFleetRequestConfigurationInvalid"
}
}
```
`sub-type` 可使用的值为：
`iamFleetRoleInvalid`
竞价型实例集不具有启动或终止实例所需的权限。
`allLaunchSpecsTemporarilyBlacklisted`
所有配置均无效，多次启动实例的尝试已失败。有关更多信息，请参阅事件的描述。
`spotInstanceCountLimitExceeded`
您已达到可启动的竞价型实例的数量限制。
`spotFleetRequestConfigurationInvalid`
该配置无效。有关更多信息，请参阅事件的描述。
# EC2 实例集的教程
可通过不同的方法配置 EC2 实例集。您选择的配置取决于特定使用案例。
以下教程涵盖了一些可能的使用案例，并提供实现这些使用案例所需的任务。
| 使用案例 | 指向教程的链接 |
| --- | --- |
| **使用实例权重来管理 EC2 实例集的可用性和性能。** 您可以借助实例权重为 EC2 实例集中的每种实例类型分配权重，来表示它们相对于彼此的计算容量和性能。实例集可以根据权重使用指定实例类型的任意组合，前提是可以满足所需的目标容量。 | [教程：将 EC2 实例集配置为使用实例权重](ec2-fleet-instance-weighting-walkthrough.md) |
| **使用按需容量可确保高峰时段的可用性，但可从更低成本的额外竞价容量获益。** 将您的 EC2 实例集配置为使用按需型实例作为主要容量，以确保高峰时段的可用容量。此外，为竞价型实例分配一些容量以享受折扣价，同时请记住，如果 Amazon EC2 需要恢复容量，则竞价型实例可能会中断。 | [教程：将 EC2 实例集配置为使用按需型实例作为主容量](ec2-fleet-on-demand-walkthrough.md) |
| **使用容量预留为按需型实例预留计算容量。** 将 EC2 实例集配置为在启动按需型实例时首先使用 `targeted` 容量预留。如果您有严格的容量要求，并且正在运行需要一定级别的长期或短期容量保证的业务关键型工作负载，我们建议您创建容量预留，以确保在需要时始终可以获得所需时长的 Amazon EC2 容量。 | [教程：使用目标容量预留配置 EC2 实例集以启动按需型实例](ec2-fleet-launch-on-demand-instances-using-targeted-capacity-reservations-walkthrough.md) |
| **使用容量块为您的 ML 工作负载预留广受欢迎的 GPU 实例。** 将 EC2 实例集配置为将实例启动到容量块中。 | [教程：将 EC2 实例集配置为将实例启动到容量块中](ec2-fleet-launch-instances-capacity-blocks-walkthrough.md) |
| **使用可中断容量预留，可以临时重新利用整个 AWS 组织的闲置容量并节省成本。** 配置 EC2 队列，使其在可中断容量预留中启动实例，这些预留代表您 AWS 组织内的空闲容量。容量所有者可随时收回容量。回收后，EC2 会在 2 分钟通知后终止实例。 | [教程：将 EC2 实例集配置为将实例启动到可中断容量预留中](ec2-fleet-launch-instances-interruptible-cr-walkthrough.md) |
# 教程：将 EC2 实例集配置为使用实例权重
该教程使用名为 Example Corp 的虚构公司说明使用实例权重请求 EC2 队列的过程。
## 目标
Example Corp 是一家医药公司，该公司想要使用 Amazon EC2 的计算功能来筛查可能用于对抗癌症的化学成分。
## 规划
Example Corp 首先查看[Spot 最佳实践](https://aws.amazon.com/ec2/spot/getting-started/#bestpractices)。然后，Example Corp 确定了他们的 EC2 队列的要求。
**实例类型**
Example Corp 有一个计算和内存密集型应用程序，该应用程序在至少 60 GB 内存和八个虚拟 CPU (vCPU) 的情况下性能最佳。他们希望以尽可能低的价格为该应用程序提供尽可能多的这些资源。Example Corp 认定以下任意 EC2 实例类型都能满足其需求：
| 实例类型 | 内存 (GiB) | vCPU |
| --- | --- | --- |
| r3.2xlarge | 61 | 8 |
| r3.4xlarge | 122 | 16 |
| r3.8xlarge | 244 | 32 |
**以单位数表示的目标容量**
采用实例权重，目标容量可以等于几个实例 (默认) 或一些因素 (如内核 (vCPU)、内存 (GiB) 和存储 (GB)) 的组合。将其应用程序的基本要求 (60 GB RAM 和八个 vCPU) 作为一个单位，Example Corp 确定，此数量的 20 倍应可满足其需求。因此该公司将其 EC2 实例集请求的目标容量设置为 20 个单位。
**实例权重**
确定目标容量后，Example Corp 计算了实例权重。为了计算每个实例类型的实例权重，他们按如下所示确定每个实例类型需要多少单位才能达到目标容量：
+ r3.2xlarge (61.0 GB, 8 vCPUs) = 1 个 20 单位
+ r3.4xlarge (122.0 GB, 16 vCPUs) = 2 个 20 单位
+ r3.8xlarge (244.0 GB, 32 vCPUs) = 4 个 20 单位
因此，Example Corp 在其EC2 队列请求中将实例权重 1、2 和 4 分配给相应的启动配置。
**每单位小时价格**
Example Corp 将每实例小时[按需价格](https://aws.amazon.com/ec2/pricing/)作为其价格的起点。他们也可以使用最近的 Spot 价格或两者的组合。为了计算每单位小时价格，他们将每实例小时起始价格除以权重。例如：
| 实例类型 | 按需价格 | 实例权重 | 每单位小时价格 |
| --- | --- | --- | --- |
| r3.2xLarge | 0.7 美元 | 1 | 0.7 美元 |
| r3.4xLarge | 1.4 美元 | 2 | 0.7 美元 |
| r3.8xLarge | 2.8 美元 | 4 | 0.7 美元 |
Example Corp 可能会使用每单位小时全局价格 0.7 美元，这对于所有三种实例类型来说是非常有竞争力的。他们可能还会使用每单位小时全局价格 0.7 USD，并在 `r3.8xlarge` 启动规范中使用特定的每单位小时价格 0.9 USD。
## 验证权限
在创建 EC2 队列请求之前，Example Corp 验证它是否拥有具备所需权限的 IAM 角色。有关更多信息，请参阅[EC2 队列先决条件](ec2-fleet-prerequisites.md)。
## 创建启动模板
接下来，Example Corp 会创建启动模板。启动模板 ID 将在下一个步骤中使用。有关更多信息，请参阅[创建 Amazon EC2 启动模板](create-launch-template.md)。
## 创建 EC2 队列
Example Corp 为其 EC2 队列创建一个具有以下配置的文件 (`config.json`)。在以下示例中，将资源标识符替换为您自己的资源标识符。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-07b3bc7625cdab851",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r3.2xlarge",
"SubnetId": "subnet-482e4972",
"WeightedCapacity": 1
},
{
"InstanceType": "r3.4xlarge",
"SubnetId": "subnet-482e4972",
"WeightedCapacity": 2
},
{
"InstanceType": "r3.8xlarge",
"MaxPrice": "0.90",
"SubnetId": "subnet-482e4972",
"WeightedCapacity": 4
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
}
}
```
Example Corp 使用以下 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令创建 EC2 队列。
```
aws ec2 create-fleet --cli-input-json file://config.json
```
有关更多信息，请参阅 [创建 EC2 实例集](create-ec2-fleet.md)。
## 执行
分配策略确定竞价型实例所来自的 Spot 容量池。
使用 `lowest-price` 策略（这是默认策略）时，Spot 实例来自在执行时具有最低每单位价格的池。为了提供 20 个单位的容量，EC2 队列有三种做法：启动 20 个 `r3.2xlarge` 实例（20 除以 1）、10 个 `r3.4xlarge` 实例（20 除以 2）或 5 个 `r3.8xlarge` 实例（20 除以 4）。
如果 Example Corp 使用 `diversified` 策略，则 Spot 实例来自所有三个池。EC2 队列会启动 6 个 `r3.2xlarge` 实例（提供 6 个单位）、3 个 `r3.4xlarge` 实例（提供 6 个单位）和 2 个 `r3.8xlarge` 实例（提供 8 个单位），总共 20 个单位。
# 教程：将 EC2 实例集配置为使用按需型实例作为主容量
该教程使用名为 ABC Online 的虚构公司说明请求 EC2 队列并将按需作为主容量和 Spot 容量（如果可用）的过程。
## 目标
ABC Online 是一家餐饮送货公司，旨在跨 EC2 实例类型和购买选项预置 Amazon EC2 容量，以实现其预期的扩展、性能和成本。
## 规划
ABC Online 需要固定容量以应对高峰时段，但也想要以较低价格从额外容量获益。该公司确定其 EC2 实例集的以下要求：
+ 按需型实例容量 – ABC Online 需要使用 15 个按需型实例，以确保它们可以处理高峰期的流量。
+ 竞价型实例容量：为了以较低的价格提高性能，ABC Online 打算预置 5 个竞价型实例。
## 验证权限
在创建 EC2 队列之前，ABC Online 验证它是否拥有具备所需权限的 IAM 角色。有关更多信息，请参阅[EC2 队列先决条件](ec2-fleet-prerequisites.md)。
## 创建启动模板
接下来，ABC Online 会创建启动模板。启动模板 ID 将在下一个步骤中使用。有关更多信息，请参阅[创建 Amazon EC2 启动模板](create-launch-template.md)。
## 创建 EC2 队列
ABC Online 为其 EC2 队列创建一个具有以下配置的文件 (`config.json`)。在以下示例中，将资源标识符替换为您自己的资源标识符。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-07b3bc7625cdab851",
"Version": "2"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"OnDemandTargetCapacity":15,
"DefaultTargetCapacityType": "spot"
}
}
```
ABC Online 使用以下 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令创建 EC2 队列。
```
aws ec2 create-fleet --cli-input-json file://config.json
```
有关更多信息，请参阅 [创建 EC2 实例集](create-ec2-fleet.md)。
## 执行
分配策略确定按需容量始终得到满足，而目标容量的余额将在具有可用容量的情况下作为竞价型实例容量执行。
# 教程：使用目标容量预留配置 EC2 实例集以启动按需型实例
本教程将指导您完成必须执行的所有步骤，以便 EC2 队列将按需实例启动到 `targeted` 容量预留。
您将学习如何将队列配置为使用 `targeted` 启动按需实例时，首先使用按需容量预留。您还将了解如何配置队列，以便当按需目标总容量超过可用未使用容量预留的数量时，队列使用指定的分配策略来选择启动剩余目标容量的实例池。
**EC2 队列配置**
在本教程中，实例集配置如下：
+ 目标容量：10 个按需实例
+ 未使用总数 `targeted` 容量预留：6（少于队列的 10 个按需实例的按需目标容量）
+ 容量预留池数量：2 (`us-east-1a` 和 `us-east-1b`）
+ 每个池的容量预留数量：3
+ 按需分配策略：`lowest-price`（如果未使用的容量预留数少于按需目标容量，队列将根据按需分配策略确定启动剩余的按需容量的池。）
请注意，您也可以使用 `prioritized` 分配策略而不是 `lowest-price` 分配策略。
**要将按需实例启动到 `targeted` 能力预留，您必须执行以下几个步骤：**
+ [
## 步骤 1：创建容量预留
](#ec2-fleet-odcr-step1)
+ [
## 步骤 2：创建容量预留资源组
](#ec2-fleet-odcr-step2)
+ [
## 步骤 3：将容量预留添加到容量预留资源组
](#ec2-fleet-odcr-step3)
+ [
## （可选）步骤 4：查看资源组中的容量预留
](#ec2-fleet-odcr-step4)
+ [
## 步骤 5：创建启动模板，该模板指定容量预留的目标是特定资源组
](#ec2-fleet-odcr-step5)
+ [
## （可选）步骤 6：描述启动模板
](#ec2-fleet-odcr-step6)
+ [
## 步骤 7：创建 EC2 队列
](#ec2-fleet-odcr-step7)
+ [
## （可选）步骤 8：查看剩余未使用的容量预留数
](#ec2-fleet-odcr-step8)
## 步骤 1：创建容量预留
使用[创建容量预留](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-capacity-reservation.html)命令创建容量预留，三个 `us-east-1a`，另外三个 `us-east-1b`。除了可用区之外，容量预留的其他属性是相同的。
**`us-east-1a` 中的 3 个容量预留**
```
aws ec2 create-capacity-reservation \
--availability-zone us-east-1a \
--instance-type c5.xlarge \
--instance-platform Linux/UNIX \
--instance-count 3 \
--instance-match-criteria targeted
```
生成的容量预留 ID 示例
```
cr-1234567890abcdef1
```
**`us-east-1b` 中的 3 个容量预留**
```
aws ec2 create-capacity-reservation \
--availability-zone us-east-1b \
--instance-type c5.xlarge \
--instance-platform Linux/UNIX \
--instance-count 3 \
--instance-match-criteria targeted
```
生成的容量预留 ID 示例
```
cr-54321abcdef567890
```
## 步骤 2：创建容量预留资源组
使用 `resource-groups` 服务和 [create-group](https://docs.aws.amazon.com/cli/latest/reference/resource-groups/create-group.html) 命令可创建容量预留资源组。在此示例中，资源组名为 `my-cr-group`。有关必须创建资源组原因的信息，请参阅 [使用容量预留来预留 EC2 实例集中的按需型容量](ec2-fleet-on-demand-capacity-reservations.md)。
```
aws resource-groups create-group \
--name my-cr-group \
--configuration '{"Type":"AWS::EC2::CapacityReservationPool"}' '{"Type":"AWS::ResourceGroups::Generic", "Parameters": [{"Name": "allowed-resource-types", "Values": ["AWS::EC2::CapacityReservation"]}]}'
```
## 步骤 3：将容量预留添加到容量预留资源组
使用 `resource-groups` 服务和 [group-resources](https://docs.aws.amazon.com/cli/latest/reference/resource-groups/group-resources.html) 命令将您在步骤 1 中创建的容量预留添加到容量预留资源组。请注意，您必须通过其 ARN 引用按需容量预留。
```
aws resource-groups group-resources \
--group my-cr-group \
--resource-arns \
arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-1234567890abcdef1 \
arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-54321abcdef567890
```
输出示例
```
{
"Failed": [],
"Succeeded": [
"arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-1234567890abcdef1",
"arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-54321abcdef567890"
]
}
```
## （可选）步骤 4：查看资源组中的容量预留
使用 `resource-groups` 服务和 [list-group-resources](https://docs.aws.amazon.com/cli/latest/reference/resource-groups/list-group-resources.html) 命令可根据需要描述资源组以查看其容量预留。
```
aws resource-groups list-group-resources --group my-cr-group
```
输出示例
```
{
"ResourceIdentifiers": [
{
"ResourceType": "AWS::EC2::CapacityReservation",
"ResourceArn": "arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-1234567890abcdef1"
},
{
"ResourceType": "AWS::EC2::CapacityReservation",
"ResourceArn": "arn:aws:ec2:us-east-1:123456789012:capacity-reservation/cr-54321abcdef567890"
}
]
}
```
## 步骤 5：创建启动模板，该模板指定容量预留的目标是特定资源组
使用 [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html) 命令可创建启动模板，在此启动模板中指定要使用的容量预留。在此示例中，队列将使用已添加到资源组的 `targeted` 容量预留。因此，启动模板数据指定容量预留以特定资源组为目标。在此示例中，启动模板名为 `my-launch-template`。
```
aws ec2 create-launch-template \
--launch-template-name my-launch-template \
--launch-template-data \
'{"ImageId": "ami-0123456789example",
"CapacityReservationSpecification":
{"CapacityReservationTarget":
{ "CapacityReservationResourceGroupArn": "arn:aws:resource-groups:us-east-1:123456789012:group/my-cr-group" }
}
}'
```
## （可选）步骤 6：描述启动模板
使用 [describe-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-template-versions.html) 命令（可选）描述启动模板以查看其配置。
```
aws ec2 describe-launch-template-versions --launch-template-name my-launch-template
```
输出示例
```
{
"LaunchTemplateVersions": [
{
"LaunchTemplateId": "lt-01234567890example",
"LaunchTemplateName": "my-launch-template",
"VersionNumber": 1,
"CreateTime": "2021-01-19T20:50:19.000Z",
"CreatedBy": "arn:aws:iam::123456789012:user/Admin",
"DefaultVersion": true,
"LaunchTemplateData": {
"ImageId": "ami-0947d2ba12ee1ff75",
"CapacityReservationSpecification": {
"CapacityReservationTarget": {
"CapacityReservationResourceGroupArn": "arn:aws:resource-groups:us-east-1:123456789012:group/my-cr-group"
}
}
}
}
]
}
```
## 步骤 7：创建 EC2 队列
创建一个 EC2 队列，指定将启动的实例配置信息。以下 EC2 队列配置仅显示该示例的相关配置。启动模板 `my-launch-template` 是您在步骤 5 中创建的启动模板。有两个实例池，每个实例池具有相同的实例类型 (`c5.xlarge`)，但具有不同的可用区域（`us-east-1a` 和 `us-east-1b`)。实例池的价格是相同的，因为定价是针对区域定义的，而不是按可用区定义的。总目标容量为 10，而原定设置目标容量类型为 `on-demand`。按需分配策略为 `lowest-price`。容量预留的使用策略是 `use-capacity-reservations-first`。
**注意**
队列类型必须为 `instant`。其他队列类型不支持 `use-capacity-reservations-first`。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "c5.xlarge",
"AvailabilityZone": "us-east-1a"
},
{
"InstanceType": "c5.xlarge",
"AvailabilityZone": "us-east-1b"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 10,
"DefaultTargetCapacityType": "on-demand"
},
"OnDemandOptions": {
"AllocationStrategy": "lowest-price",
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
}
},
"Type": "instant"
}
```
在使用上述配置创建 `instant` 队列后，将启动下面的 10 个实例来满足目标容量：
+ 容量预留首先用于启动 6 个按需实例，如下所示：
+ 3 个按需实例启动到 `us-east-1a` 中的 3 个`c5.xlarge` `targeted`容量预留
+ 3 个按需实例启动到 `us-east-1b` 中的 3 个`c5.xlarge` `targeted`容量预留
+ 为了满足目标容量，根据按需分配策略，将 4 个额外的按需实例启动到常规按需容量中（在本示例中为 `lowest-price`）。但是，由于池的价格相同（因为价格是每个区域而不是每个可用区），因此队列将在其中一个池中启动剩余的 4 个按需实例。
## （可选）步骤 8：查看剩余未使用的容量预留数
在启动队列后，您可以运行 [describe-capacity-reservations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-capacity-reservations.html) 来查看保留的未使用的容量预留的数目。在此示例中，您应看到以下响应，该响应指示所有池中的所有 容量预留 均已使用。
```
{ "CapacityReservationId": "cr-111",
"InstanceType": "c5.xlarge",
"AvailableInstanceCount": 0
}
{ "CapacityReservationId": "cr-222",
"InstanceType": "c5.xlarge",
"AvailableInstanceCount": 0
}
```
# 教程：将 EC2 实例集配置为将实例启动到容量块中
本教程将指导您完成必须执行的步骤，以便 EC2 实例集在容量块中启动实例。
在大多数情况下，EC2 实例集请求的目标容量应小于或等于您所定位的容量块预留的可用容量。无法满足超过容量块预留限制的目标容量请求。如果目标容量请求超过容量块预留的限制，则对于超出容量块预留限制的容量，您将收到 `Insufficient Capacity Exception`。
**注意**
对于容量块，EC2 实例集将不会回退到为剩余的所需目标容量启动按需型实例。
如果 EC2 实例集无法满足可用容量块预留中请求的目标容量，EC2 Fleet 将尽可能多地满足容量，并返回其能够启动的实例。您可以再次调用 EC2 实例集，直到所有实例都已预调配。
配置 EC2 实例集请求后，您必须等到容量块预留的开始日期。如果您请求 EC2 实例集启动到尚未启动的容量块中，您将收到 `Insufficient Capacity Error`。
在容量块预留变为活动状态后，您可以调用 EC2 实例集 API，并根据您选择的参数将实例预调配到您的容量块中。在容量块中运行的实例将继续运行，直到您手动停止或终止这些实例，或者直到 Amazon EC2 在容量块预留结束时终止这些实例。
有关容量块的更多信息，请参阅 [ML 容量块](ec2-capacity-blocks.md)。
**注意事项**
+ 只有类型为 `instant` EC2 实例集请求才支持将实例启动到容量块中。有关更多信息，请参阅 [配置 instant 类型的 EC2 实例集](instant-fleet.md)。
+ 不支持在同一 EC2 实例集请求中有多个容量块。
+ 不支持在使用 `OnDemandTargetCapacity` 或 `SpotTargetCapacity` 的同时将 `capacity-block` 设置为 `DefaultTargetCapacity`。
+ 如果将 `DefaultTargetCapacityType` 设置为 `capacity-block`，则无法提供 `OnDemandOptions::CapacityReservationOptions`。将会出现异常。
**配置 EC2 实例集以将实例启动到容量块中**
1. **创建启动模板。**
在启动模板中，执行以下操作：
+ 对于 `InstanceMarketOptionsRequest`，将 `MarketType` 设置为 `capacity-block`。
+ 要确定容量块预留目标，对于 `CapacityReservationID`，指定容量块预留 ID。
记下启动模板的名称和版本。您在下一步中将使用此信息。
有关创建启动模板的更多信息，请参阅[创建 Amazon EC2 启动模板](create-launch-template.md)。
1. **配置 EC2 实例集。**
为您的 EC2 实例集创建一个具有以下配置的文件，文件名为 `config.json`。在以下示例中，将资源标识符替换为您自己的资源标识符。
有关配置 EC2 实例集的更多信息，请参阅[创建 EC2 实例集](create-ec2-fleet.md)。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "CBR-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "p5.48xlarge",
"AvailabilityZone": "us-east-1a"
},
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 10,
"DefaultTargetCapacityType": "capacity-block"
},
"Type": "instant"
}
```
1. **启动实例集。**
使用以下 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令。
```
aws ec2 create-fleet --cli-input-json file://config.json
```
有关更多信息，请参阅 [创建 EC2 实例集](create-ec2-fleet.md#create-ec2-fleet-procedure)。
# 教程：将 EC2 实例集配置为将实例启动到可中断容量预留中
本教程将指导您完成必须执行的步骤，以便 EC2 实例集在可中断容量预留中启动实例。
可中断容量预留是指 AWS 组织内按需容量预留所有者借给您的备用容量。这些预留适用于可中断的工作负载，因为容量所有者可以随时收回容量，只需发出 2 分钟的中断通知，之后 EC2 就会终止实例。有关容量预留的更多信息，请参阅 [可中断容量预留](interruptible-capacity-reservations.md)。
EC2 实例集请求的目标容量应小于或等于您所定位的可中断容量预留的可用容量。如果目标容量请求超过您的可中断容量预留的可用容量，则 EC2 实例集会启动尽可能多的实例，并在 API 响应中报告已启动的实例。
在可中断容量预留中运行的实例将继续运行，直到您手动停止或终止它们，或直到容量所有者收回容量。当容量所有者收回容量时，Amazon EC2 会在终止实例前 2 分钟发送一条 Amazon EventBridge 通知。
## 注意事项
+ 只有类型为 `instant` EC2 实例集请求才支持将实例启动到可中断容量预留中。
+ 不支持在使用 `OnDemandTargetCapacity` 或 `SpotTargetCapacity` 的同时将 `reserved-capacity` 设置为 `DefaultTargetCapacityType`。
+ 当您指定多个启动模板（每个模板都针对不同的可中断容量预留）时，EC2 实例集会为所有匹配的预留配置实例。
+ 对于可中断容量预留，EC2 实例集将不会回退到为剩余的所需目标容量启动按需型实例或竞价型实例。
## 验证权限
在创建 EC2 实例集之前，验证您是否拥有具备所需权限的 IAM 角色。有关更多信息，请参阅 [EC2 队列先决条件](ec2-fleet-prerequisites.md)。
要将实例启动到可中断容量预留中，您必须执行以下步骤：
## 步骤 1：创建启动模板
使用 [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html) 命令可创建启动模板，指定目标可中断容量预留。在启动模板中，将 `MarketType` 设置为 `interruptible-capacity-reservation`，并指定可中断容量预留的 `CapacityReservationId`。
启动模板配置示例：
```
{
"LaunchTemplateName": "interruptible-cr-launch-template",
"LaunchTemplateData": {
"InstanceType": "m5.large",
"ImageId": "ami-0abcdef1234567890",
"CapacityReservationSpecification": {
"CapacityReservationTarget": {
"CapacityReservationId": "cr-0123456789abcdef0"
}
},
"InstanceMarketOptions": {
"MarketType": "interruptible-capacity-reservation"
}
}
}
```
输出示例
```
{
"LaunchTemplate": {
"LaunchTemplateId": "lt-0123456789example",
"LaunchTemplateName": "interruptible-cr-launch-template",
"CreateTime": "2026-03-12T10:00:00.000Z",
"CreatedBy": "arn:aws:iam::123456789012:user/Admin",
"DefaultVersionNumber": 1,
"LatestVersionNumber": 1
}
}
```
有关更多信息，请参阅 [创建 Amazon EC2 启动模板](create-launch-template.md)。
## 步骤 2：配置 EC2 实例集。
为 EC2 实例集创建一个配置文档，指定启动模板和目标容量。以下配置使用步骤 1 中创建的启动模板 `interruptible-cr-launch-template`。
使用 `reserved-capacity` 作为 `DefaultTargetCapacityType` 时，必须指定 `ReservedCapacityOptions`，并将 `ReservationType` 设置为 `interruptible-capacity-reservation`。
使用以下内容创建名为 `config.json` 的文件：
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "interruptible-cr-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "m5.large",
"AvailabilityZone": "us-east-1a"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 10,
"DefaultTargetCapacityType": "reserved-capacity"
},
"ReservedCapacityOptions": {
"ReservationType": ["interruptible-capacity-reservation"]
},
"Type": "instant"
}
```
关键配置参数：
| 参数 | 说明 |
| --- | --- |
| DefaultTargetCapacityType | 设置为 reserved-capacity 表示应将实例启动到预留容量。 |
| ReservedCapacityOptions | 指定预留容量的类型。对于可中断容量预留，设置 ReservationType 为 ["interruptible-capacity-reservation"]。 |
| Type | 必须设置为 instant。可中断容量预留仅支持实例集。 |
## 步骤 3：启动实例集并查看结果
使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令创建实例集。
```
aws ec2 create-fleet \
--cli-input-json file://config.json
```
使用前面的配置创建 `instant` 实例集后，EC2 实例集会向可中断容量预留启动 10 个实例，以满足目标容量。
**注意**
如果实例集无法满足全部目标容量，则响应将包括已启动的实例以及未实现容量的所有错误。
输出示例
```
{
"FleetId": "fleet-12345678-1234-1234-1234-123456789012",
"Instances": [
{
"LaunchTemplateAndOverrides": {
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0123456789example",
"Version": "1"
},
"Overrides": {
"InstanceType": "m5.large",
"AvailabilityZone": "us-east-1a"
}
},
"Lifecycle": "interruptible-capacity-reservation",
"InstanceIds": [
"i-0123456789example1",
"i-0123456789example2",
"i-0123456789example3",
"i-0123456789example4",
"i-0123456789example5",
"i-0123456789example6",
"i-0123456789example7",
"i-0123456789example8",
"i-0123456789example9",
"i-0123456789example0"
],
"InstanceType": "m5.large",
"Platform": "Linux/UNIX"
}
],
"Errors": []
}
```
有关更多信息，请参阅 [创建 EC2 实例集](create-ec2-fleet.md)。
## 清理
要停止产生费用，请在不再需要时终止实例。请注意，当容量所有者收回容量时，EC2 还会自动终止在可中断容量预留中启动的实例。
## 相关资源
+ [可中断容量预留](interruptible-capacity-reservations.md)
+ [使用 EC2 按需容量预留来预留计算容量](ec2-capacity-reservations.md)
+ [使用 EC2 实例集](manage-ec2-fleet.md)
+ [创建 EC2 实例集](create-ec2-fleet.md)
+ [在 Amazon EC2 启动模板中存储实例启动参数](ec2-launch-templates.md)
# EC2 实例集 CLI 配置示例
要创建实例集，请在 JSON 文件中定义 EC2 实例集配置，然后使用 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html) 命令引用该文件，如下所示：
```
aws ec2 create-fleet --cli-input-json file://file_name.json
```
以下示例说明了各种 EC2 实例集用例的启动配置。有关配置参数的更多信息，请参阅 [create-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-fleet.html)。
**Topics**
+ [
## 示例 1：启动竞价型实例作为默认购买选项
](#ec2-fleet-config1)
+ [
## 示例 2：启动按需型实例作为默认购买选项
](#ec2-fleet-config2)
+ [
## 示例 3：启动按需型实例作为主容量
](#ec2-fleet-config3)
+ [
## 示例 4：使用多个容量保留按需启动实例
](#ec2-fleet-config5)
+ [
## 示例 5：当总目标容量大于未使用的容量预留数量时，使用容量预留启动按需实例
](#ec2-fleet-config6)
+ [
## 示例 6：使用容量预留启动按需实例
](#ec2-fleet-config7)
+ [
## 示例 7：配置容量再平衡以启动替换竞价型实例
](#ec2-fleet-config8)
+ [
## 示例 8：在容量优化的队列中启动竞价型实例
](#ec2-fleet-config9)
+ [
## 示例 9：在具有优先级的容量优化队列中启动竞价型实例
](#ec2-fleet-config10)
+ [
## 示例 10：在价格容量优化的实例集中启动竞价型实例
](#ec2-fleet-config11)
+ [
## 示例 11：配置基于属性的实例类型选择
](#ec2-fleet-config12)
有关 `instant` 类型实例集的更多 CLI 示例，请参阅[配置 instant 类型的 EC2 实例集](instant-fleet.md)。
## 示例 1：启动竞价型实例作为默认购买选项
下面的示例指定了 EC2 队列中所需的最少参数：启动模板、目标容量和默认购买选项。启动模板由其启动模板 ID 和版本号标识。队列的目标容量为 2 个实例，默认购买选项为 `spot`，因此队列启动两个 Spot 实例。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "spot"
}
}
```
## 示例 2：启动按需型实例作为默认购买选项
下面的示例指定了 EC2 队列中所需的最少参数：启动模板、目标容量和默认购买选项。启动模板由其启动模板 ID 和版本号标识。队列的目标容量为 2 个实例，默认购买选项为 `on-demand`，因此队列启动两个 按需实例。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"DefaultTargetCapacityType": "on-demand"
}
}
```
## 示例 3：启动按需型实例作为主容量
下面的示例为队列指定 2 个实例的总目标容量和 1 个按需实例的目标容量。默认购买选项为 `spot`。队列按照指定的方式启动 1 个按需型实例，但需要再启动一个实例以满足总目标容量要求。差值的购买选项是通过 `TotalTargetCapacity` – `OnDemandTargetCapacity` = `DefaultTargetCapacityType` 计算得出，因而实例集会启动 1 个竞价型实例。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
}
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 2,
"OnDemandTargetCapacity": 1,
"DefaultTargetCapacityType": "spot"
}
}
```
## 示例 4：使用多个容量保留按需启动实例
可以通过将 容量预留 的使用策略配置为 `use-capacity-reservations-first` 来将队列配置为在启动 按需实例 时首先使用 按需容量预留。此示例演示了当容量预留数量超过满足目标容量所需的容量预留数量时，队列如何选择要使用的容量预留。
队列配置如下所示：
+ 目标容量：12 个按需实例
+ 未使用的容量预留总数：15（超过了队列的 12 个按需实例的目标容量）
+ 容量预留池数量：3 (`m5.large`、`m4.xlarge` 和 `m4.2xlarge`）
+ 每个池的容量预留数量：5
+ 按需分配策略：`lowest-price`（当多个实例池中存在多个未使用的容量预留时，队列将根据按需分配策略确定启动按需实例的池。）
请注意，您也可以使用 `prioritized` 分配策略而不是 `lowest-price` 分配策略。
**容量预留**
账户在 3 个不同的池中有以下 15 个未使用的 容量预留。每个池中的 容量预留 数由 `AvailableInstanceCount` 指示。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 5,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "m4.xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 5,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-333",
"InstanceType": "m4.2xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount":5,
"InstanceMatchCriteria": "open",
"State": "active"
}
```
**队列配置**
以下队列配置仅显示该示例的相关配置。总目标容量为 12，而默认目标容量类型为 `on-demand`。按需分配策略为 `lowest-price`。容量预留的使用策略是 `use-capacity-reservations-first`。
在此示例中，个按需型实例 价格为：
+ `m5.large` – 每小时 0.096 美元
+ `m4.xlarge` – 每小时 0.20 美元
+ `m4.2xlarge` – 每小时 0.40 美元
**注意**
队列类型必须为类型 `instant`。其他队列类型不支持 `use-capacity-reservations-first`。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-abc1234567example",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "m5.large",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
},
{
"InstanceType": "m4.xlarge",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
},
{
"InstanceType": "m4.2xlarge",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 12,
"DefaultTargetCapacityType": "on-demand"
},
"OnDemandOptions": {
"AllocationStrategy": "lowest-price",
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
}
},
"Type": "instant"
}
```
在使用上述配置创建 `instant` 队列后，将启动下面的 12 个实例来满足目标容量：
+ `us-east-1a` 中的 5 个 `m5.large` 按需实例–`us-east-1a` 中的 `m5.large` 是最低的价格,并且有 5 个可用的未使用 `m5.large` 容量预留
+ us-east-1a 中的 5 个 `m4.xlarge` 按需实例 – `us-east-1a` 中的 `m4.xlarge` 是第二低的价格，并且有 5 个可用的未使用 `m4.xlarge` 容量预留
+ us-east-1a 中的 2 个 `m4.2xlarge` 按需实例 – `us-east-1a` 中的 `m4.2xlarge` 是第三低的价格，并且有 5 个可用的未使用 `m4.2xlarge` 容量预留，只需其中的 2 个即可满足目标容量
在启动队列后，您可以运行 [describe-capacity-reservations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-capacity-reservations.html) 来查看保留的未使用的 容量预留 的数目。在此示例中，您该看到以下响应，该响应指示已使用所有 `m5.large` 和 `m4.xlarge` 容量预留，有 3 个 `m4.2xlarge` 容量预留未使用。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "m4.xlarge",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-333",
"InstanceType": "m4.2xlarge",
"AvailableInstanceCount": 3
}
```
## 示例 5：当总目标容量大于未使用的容量预留数量时，使用容量预留启动按需实例
可以通过将 容量预留 的使用策略配置为 `use-capacity-reservations-first` 来将队列配置为在启动 按需实例 时首先使用 按需容量预留。此示例演示了当总目标容量超过可用未使用容量预留数时，队列如何选择要在其中启动按需实例的实例池。
在此示例中，队列配置如下所示：
+ 目标容量：16 个按需实例
+ 未使用的容量预留总数：15（少于队列的 16 个按需实例的目标容量）
+ 容量预留池数量：3 (`m5.large`、`m4.xlarge` 和 `m4.2xlarge`）
+ 每个池的容量预留数量：5
+ 按需分配策略：`lowest-price`（如果未使用的容量预留数少于按需目标容量，队列将根据按需分配策略确定启动剩余的按需容量的池。）
请注意，您也可以使用 `prioritized` 分配策略而不是 `lowest-price` 分配策略。
**容量预留**
账户在 3 个不同的池中有以下 15 个未使用的 容量预留。每个池中的 容量预留 数由 `AvailableInstanceCount` 指示。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 5,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "m4.xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 5,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-333",
"InstanceType": "m4.2xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount":5,
"InstanceMatchCriteria": "open",
"State": "active"
}
```
**队列配置**
以下队列配置仅显示该示例的相关配置。总目标容量为 16，而默认目标容量类型为 `on-demand`。按需分配策略为 `lowest-price`。容量预留的使用策略是 `use-capacity-reservations-first`。
在此示例中，个按需型实例 价格为：
+ m5.large – 每小时 0.096 美元
+ m4.xlarge – 每小时 0.20 美元
+ m4.2xlarge – 每小时 0.40 美元
**注意**
队列类型必须为 `instant`。其他队列类型不支持 `use-capacity-reservations-first`。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0e8c754449b27161c",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "m5.large",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
},
{
"InstanceType": "m4.xlarge",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
},
{
"InstanceType": "m4.2xlarge",
"AvailabilityZone": "us-east-1a",
"WeightedCapacity": 1
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 16,
"DefaultTargetCapacityType": "on-demand"
},
"OnDemandOptions": {
"AllocationStrategy": "lowest-price"
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
}
},
"Type": "instant",
}
```
在使用上述配置创建 `instant` 队列后，将启动下面的 16 个实例来满足目标容量：
+ `us-east-1a` 中的 6个 `m5.large` 按需实例–`us-east-1a` 中的 `m5.large` 是最低的价格, 并且有 5 个可用的未使用 `m5.large` 容量预留。容量预留首先用于启动 5 个按需实例。使用了剩余 `m4.xlarge` 和 `m4.2xlarge` 容量保留后，为了满足目标容量，将额外的按需实例启动到常规按需容量中（在本示例中为 `lowest-price`）。
+ `us-east-1a` 中的 5个 `m4.xlarge` 按需实例–`us-east-1a` 中的 `m4.xlarge` 是第二低的价格, 并且有 5 个可用的未使用 `m4.xlarge` 容量预留。
+ `us-east-1a` 中的 5个 `m4.2xlarge` 按需实例–`us-east-1a` 中的 `m4.2xlarge` 是第三低的价格, 并且有 5 个可用的未使用 `m4.2xlarge` 容量预留。
在启动队列后，您可以运行 [describe-capacity-reservations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-capacity-reservations.html) 来查看保留的未使用的 容量预留 的数目。在此示例中，您应看到以下响应，该响应指示所有池中的所有 容量预留 均已使用。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "m5.large",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "m4.xlarge",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-333",
"InstanceType": "m4.2xlarge",
"AvailableInstanceCount": 0
}
```
## 示例 6：使用容量预留启动按需实例
通过将容量保留的使用策略设置为 `use-capacity-reservations-first`，您可以将震源组配置为在启动按需实例时首先使用 `targeted` 按需容量保留。此示例演示如何将按需实例启动到 `targeted` 容量预留，其中容量预留的属性相同，但其可用区域除外 (`us-east-1a` 和 `us-east-1b`)。它还演示了当总目标容量超过可用未使用容量预留数时，队列如何选择要在其中启动按需实例的实例池。
在此示例中，队列配置如下所示：
+ 目标容量：10 个按需实例
+ 未使用总数 `targeted` 容量预留：6（少于队列的 10 个按需实例的按需目标容量）
+ 容量预留池数量：2 (`us-east-1a` 和 `us-east-1b`）
+ 每个池的容量预留数量：3
+ 按需分配策略：`lowest-price`（如果未使用的容量预留数少于按需目标容量，队列将根据按需分配策略确定启动剩余的按需容量的池。）
请注意，您也可以使用 `prioritized` 分配策略而不是 `lowest-price` 分配策略。
有关完成此示例所必须执行的过程的演练，请参阅 [教程：使用目标容量预留配置 EC2 实例集以启动按需型实例](ec2-fleet-launch-on-demand-instances-using-targeted-capacity-reservations-walkthrough.md)。
**容量预留**
账户在 2 个不同的池中有以下 6 个未使用的容量预留。在此示例中，池因其可用区而异。每个池中的 容量预留 数由 `AvailableInstanceCount` 指示。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "c5.xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1a",
"AvailableInstanceCount": 3,
"InstanceMatchCriteria": "open",
"State": "active"
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "c5.xlarge",
"InstancePlatform": "Linux/UNIX",
"AvailabilityZone": "us-east-1b",
"AvailableInstanceCount": 3,
"InstanceMatchCriteria": "open",
"State": "active"
}
```
**队列配置**
以下队列配置仅显示该示例的相关配置。总目标容量为 10，而默认目标容量类型为 `on-demand`。按需分配策略为 `lowest-price`。容量预留的使用策略是 `use-capacity-reservations-first`。
在此示例中，`us-east-1` 中 `c5.xlarge` 的按需实例价格为：每小时 0.17 美元
**注意**
队列类型必须为 `instant`。其他队列类型不支持 `use-capacity-reservations-first`。
```
{
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "c5.xlarge",
"AvailabilityZone": "us-east-1a"
},
{
"InstanceType": "c5.xlarge",
"AvailabilityZone": "us-east-1b"
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 10,
"DefaultTargetCapacityType": "on-demand"
},
"OnDemandOptions": {
"AllocationStrategy": "lowest-price",
"CapacityReservationOptions": {
"UsageStrategy": "use-capacity-reservations-first"
}
},
"Type": "instant"
}
```
在使用上述配置创建 `instant` 队列后，将启动下面的 10 个实例来满足目标容量：
+ 容量预留首先用于启动 6 个按需实例，如下所示：
+ 3 个按需实例启动到 `us-east-1a` 中的 3 个`c5.xlarge` `targeted`容量预留
+ 3 个按需实例启动到 `us-east-1b` 中的 3 个`c5.xlarge` `targeted`容量预留
+ 为了满足目标容量，根据按需分配策略，将 4 个额外的按需实例启动到常规按需容量中（在本示例中为 `lowest-price`）。但是，由于池的价格相同（因为价格是每个区域而不是每个可用区），因此队列将在一个池中启动剩余的 4 个按需实例。
在启动队列后，您可以运行 [describe-capacity-reservations](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-capacity-reservations.html) 来查看保留的未使用的 容量预留 的数目。在此示例中，您应看到以下响应，该响应指示所有池中的所有 容量预留 均已使用。
```
{
"CapacityReservationId": "cr-111",
"InstanceType": "c5.xlarge",
"AvailableInstanceCount": 0
}
{
"CapacityReservationId": "cr-222",
"InstanceType": "c5.xlarge",
"AvailableInstanceCount": 0
}
```
## 示例 7：配置容量再平衡以启动替换竞价型实例
下面的示例将 EC2 实例集配置为在 Amazon EC2 为队列中的竞价型实例发出再平衡建议时启动替换竞价型实例。要配置 Spot 实例 的自动替换，对于 `ReplacementStrategy`，请指定 `launch-before-terminate`。要配置从启动新替换竞价型实例到自动删除旧竞价型实例的时间延迟，请对于 `termination-delay`，请指定值（以秒为单位）。有关更多信息，请参阅 [配置选项](ec2-fleet-capacity-rebalance.md#ec2-fleet-capacity-rebalance-config-options)。
**注意**
我们建议仅当您可以预测实例关闭过程完成所需的时长时才使用 `launch-before-terminate`，这样只有在这些过程完成后才会终止旧实例。在实例运行期间，您需要为它们付费。
容量再平衡策略的有效性取决于 EC2 队列 请求中指定的 Spot 容量池的数量。我们建议您使用一组多样化的实例类型和可用区配置队列，对于 `AllocationStrategy`，请指定 `capacity-optimized`。有关为容量再平衡配置 EC2 队列 时应考虑的内容的更多信息，请参阅[在 EC2 实例集和竞价型实例集中使用“容量再平衡”功能来替换存在风险的竞价型实例](ec2-fleet-capacity-rebalance.md)。
```
{
"ExcessCapacityTerminationPolicy": "termination",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "LaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "c3.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
},
{
"InstanceType": "c4.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
},
{
"InstanceType": "c5.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 5,
"DefaultTargetCapacityType": "spot"
},
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
"MaintenanceStrategies": {
"CapacityRebalance": {
"ReplacementStrategy": "launch-before-terminate",
"TerminationDelay": "720"
}
}
}
}
```
## 示例 8：在容量优化的队列中启动竞价型实例
以下示例演示如何使用针对容量进行优化的 Spot 分配策略配置 EC2 队列。要优化容量，您必须将 `AllocationStrategy` 设置为 `capacity-optimized`。
在以下示例中，三个启动规范指定了三个 Spot 容量池。目标容量为 50 个竞价型实例。EC2 实例集尝试在 Spot 容量池中启动 50 个竞价型实例，并为启动的实例数量提供最佳容量。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized",
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2a"
},
},
{
"InstanceType": "m4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
},
{
"InstanceType": "c5.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 50,
"DefaultTargetCapacityType": "spot"
}
}
```
## 示例 9：在具有优先级的容量优化队列中启动竞价型实例
以下示例演示如何通过 Spot 分配策略配置 EC2 队列，该策略针对容量进行优化，同时尽最大努力使用优先级。
使用 `capacity-optimized-prioritized` 分配策略时，您可以使用 `Priority` 参数指定 Spot 容量池的优先级，数字越小优先级越高。如果您平等地支持多个 Spot 容量池，您还可以为它们设置相同的优先级。如果您没有为某个池设置优先级，则该池将在优先级方面被视为最后一个。
要设置 Spot 容量池的优先级，您必须将 `AllocationStrategy` 设置为 `capacity-optimized-prioritized`。EC2 队列首先会针对容量进行优化，但会尽最大努力遵循优先级。（例如，如果遵循优先级不会显著影响 EC2 队列预置最佳容量的能力）。对于必须最大限度地减少中断可能性，同时对某些实例类型的偏好也很重要的工作负载来说，这是一个不错的选择。
在以下示例中，三个启动规范指定了三个 Spot 容量池。对每个池进行优先级排序，数字越小优先级越高。目标容量为 50 个竞价型实例。EC2 实例集尝试以最高优先级在 Spot 容量池中启动 50 个竞价型实例，但首先针对容量进行优化。
```
{
"SpotOptions": {
"AllocationStrategy": "capacity-optimized-prioritized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"Priority": 1,
"Placement": {
"AvailabilityZone": "us-west-2a"
},
},
{
"InstanceType": "m4.2xlarge",
"Priority": 2,
"Placement": {
"AvailabilityZone": "us-west-2b"
},
},
{
"InstanceType": "c5.2xlarge",
"Priority": 3,
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 50,
"DefaultTargetCapacityType": "spot"
}
```
## 示例 10：在价格容量优化的实例集中启动竞价型实例
以下示例演示了如何通过 Spot 分配策略配置 EC2 实例集，该策略针对容量和最低价格进行了优化。若要在考虑价格的同时优化容量，必须将 Spot `AllocationStrategy` 设置为 `price-capacity-optimized`。
在以下示例中，三个启动规范指定了三个 Spot 容量池。目标容量为 50 个竞价型实例。EC2 实例集尝试在 Spot 容量池中启动 50 个竞价型实例，并为启动的实例数量提供最佳容量，同时选择最低价格的池。
```
{
"SpotOptions": {
"AllocationStrategy": "price-capacity-optimized",
"MinTargetCapacity": 2,
"SingleInstanceType": true
},
"OnDemandOptions": {
"AllocationStrategy": "lowest-price"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2a"
},
},
{
"InstanceType": "m4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
},
{
"InstanceType": "c5.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 50,
"OnDemandTargetCapacity":0,
"SpotTargetCapacity":50,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
## 示例 11：配置基于属性的实例类型选择
以下示例演示了如何配置 EC2 实例集，以使用基于属性的实例类型选择来识别实例类型。若要指定所需的实例属性，请在 `InstanceRequirements` 结构中指定属性。
在以下示例中，指定了 2 个实例属性：
+ `VCpuCount` – 至少指定了 2 个 vCPU。由于未指定最大值，因此没有最大限制。
+ `MemoryMiB` – 至少指定了 4 MiB 的内存。由于未指定最大值，因此没有最大限制。
将识别具有 2 个或更多 vCPU 和 4 MiB 或更大内存的任何实例类型。然而，当 [EC2 实例集预置实例集](ec2-fleet-attribute-based-instance-type-selection.md#how-ef-uses-abs)时，价格保护和分配策略可能会排除某些实例类型。
有关您可以指定的所有可能属性的列表和描述，请参阅 *Amazon EC2 API Reference*（《Amazon EC2 API 参考》）中的 [InstanceRequirements](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceRequirements.html)。
```
{
"SpotOptions": {
"AllocationStrategy": "price-capacity-optimized"
},
"LaunchTemplateConfigs": [{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2
},
"MemoryMiB": {
"Min": 4
}
}
}]
}],
"TargetCapacitySpecification": {
"TotalTargetCapacity": 20,
"DefaultTargetCapacityType": "spot"
},
"Type": "instant"
}
```
# 竞价型实例集 CLI 配置示例
要创建实例集，请在 JSON 文件中定义竞价型实例集配置，然后使用 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html) AWS CLI 命令引用该文件，如下所示：
```
aws ec2 request-spot-fleet --spot-fleet-request-config file://file_name.json
```
以下示例说明了各种竞价型实例集用例的启动配置。有关配置参数的更多信息，请参阅 [request-spot-fleet](https://docs.aws.amazon.com/cli/latest/reference/ec2/request-spot-fleet.html)。有关创建竞价型实例集的更多信息，请参阅[创建 Spot 队列](create-spot-fleet.md)。
**注意**
对于竞价型实例集，您无法在启动模板或启动规范中指定网络接口 ID。请务必要忽略启动模板或启动规范中的 `NetworkInterfaceID` 参数。
**Topics**
+ [
## 示例 1：使用区域中价格最低的可用区启动竞价型实例
](#fleet-config1)
+ [
## 示例 2：使用列表中价格最低的可用区启动竞价型实例
](#fleet-config2)
+ [
## 示例 3：使用列表中价格最低的实例类型启动竞价型实例
](#fleet-config3)
+ [
## 示例 4。覆盖请求的价格
](#fleet-config4)
+ [
## 示例 5：使用多样化分配策略启动 Spot 队列
](#fleet-config5)
+ [
## 示例 6：使用实例权重启动 Spot 队列
](#fleet-config6)
+ [
## 示例 7：使用按需容量启动竞价型实例集
](#fleet-config7)
+ [
## 示例 8：配置容量再平衡以启动替换竞价型实例
](#fleet-config8)
+ [
## 示例 9：在容量优化的队列中启动竞价型实例
](#fleet-config9)
+ [
## 示例 10：在具有优先级的容量优化队列中启动竞价型实例
](#fleet-config10)
+ [
## 示例 11：在 priceCapacityOptimized 实例集中启动竞价型实例
](#fleet-config11)
+ [
## 示例 12：配置基于属性的实例类型选择
](#fleet-config12)
## 示例 1：使用区域中价格最低的可用区启动竞价型实例
以下示例指定一个没有可用区或子网的启动规范。Spot 队列会在具有默认子网且价格最低的可用区中启动实例。您支付的价格不得超过按需价格。
```
{
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "m3.medium",
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
]
}
```
## 示例 2：使用列表中价格最低的可用区启动竞价型实例
以下示例指定具有的可用区或子网不同但实例类型和 AMI 相同的两种启动规范。
**可用区**
Spot 队列会在价格最低的指定可用区的默认子网中启动实例。
```
{
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "m3.medium",
"Placement": {
"AvailabilityZone": "us-west-2a, us-west-2b"
},
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
]
}
```
**子网**
您可以指定默认子网或非默认子网，并且非默认子网可来自默认 VPC 或非默认 VPC。Spot 服务会在位于价格最低的可用区的子网中启动实例。
您无法在 Spot 队列请求中指定来自相同可用区的不同子网。
```
{
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "m3.medium",
"SubnetId": "subnet-a61dafcf, subnet-65ea5f08",
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
]
}
```
如果在默认 VPC 中启动实例，则实例在默认情况下会收到一个公有 IPv4 地址。如果在非默认 VPC 中启动实例，则实例在默认情况下不会收到一个公有 IPv4 地址。在启动规范中使用网络接口来将一个公有 IPv4 地址分配给在非默认 VPC 中启动的实例。指定网络接口时，您必须包括使用网络接口的子网 ID 和安全组 ID。
```
...
{
"ImageId": "ami-1a2b3c4d",
"KeyName": "my-key-pair",
"InstanceType": "m3.medium",
"NetworkInterfaces": [
{
"DeviceIndex": 0,
"SubnetId": "subnet-1a2b3c4d",
"Groups": [ "sg-1a2b3c4d" ],
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "arn:aws:iam::123456789012:instance-profile/my-iam-role"
}
}
...
```
## 示例 3：使用列表中价格最低的实例类型启动竞价型实例
以下示例指定实例类型不同、但 AMI 和可用区或子网相同的两种启动配置。Spot 队列使用价格最低的指定实例类型启动实例。
**可用区**
```
{
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "c5.4xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
},
{
"ImageId": "ami-1a2b3c4d",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "r3.8xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
```
**子网**
```
{
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "c5.4xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"SecurityGroups": [
{
"GroupId": "sg-1a2b3c4d"
}
],
"InstanceType": "r3.8xlarge",
"SubnetId": "subnet-1a2b3c4d"
}
]
}
```
## 示例 4。覆盖请求的价格
我们建议您使用默认最高价 (这是按需价格)。如果愿意，您可以为队列请求以及各个启动规范指定最高价。
以下示例为队列请求以及两个启动规范 (共三个) 指定最高价。队列请求的最高价用于未指定最高价的任何启动规范。Spot 队列使用价格最低的实例类型启动实例。
**可用区**
```
{
"SpotPrice": "1.00",
"TargetCapacity": 30,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
"SpotPrice": "0.10"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.4xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
"SpotPrice": "0.20"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.8xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
```
**子网**
```
{
"SpotPrice": "1.00",
"TargetCapacity": 30,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.2xlarge",
"SubnetId": "subnet-1a2b3c4d",
"SpotPrice": "0.10"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.4xlarge",
"SubnetId": "subnet-1a2b3c4d",
"SpotPrice": "0.20"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.8xlarge",
"SubnetId": "subnet-1a2b3c4d"
}
]
}
```
## 示例 5：使用多样化分配策略启动 Spot 队列
以下示例使用 `diversified` 分配策略。启动规范具有不同的实例类型，但具有相同的 AMI 和可用区或子网。Spot 队列在 3 个启动规范间分配 30 个实例，以便每种类型有 10 个实例。有关更多信息，请参阅 [使用分配策略确定 EC2 实例集或竞价型实例集如何满足竞价型和按需型容量](ec2-fleet-allocation-strategy.md)。
**可用区**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 30,
"AllocationStrategy": "diversified",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "m3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
}
]
}
```
**子网**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 30,
"AllocationStrategy": "diversified",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c4.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "m3.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
}
]
}
```
在其中一个可用区中断的情况下，增加 EC2 容量可以满足 Spot 请求的几率的最佳实践是跨区域实现多样化。对于这种情况，请在启动规范中包含每个对您可用的可用区。并且，不是每次使用同一个子网，而是使用三个唯一的子网（每个子网映射到不同的区域）。
**可用区**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 30,
"AllocationStrategy": "diversified",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c4.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2a"
}
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "m3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
}
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2c"
}
}
]
}
```
**子网**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 30,
"AllocationStrategy": "diversified",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c4.2xlarge",
"SubnetId": "subnet-1a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "m3.2xlarge",
"SubnetId": "subnet-2a2b3c4d"
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"SubnetId": "subnet-3a2b3c4d"
}
]
}
```
## 示例 6：使用实例权重启动 Spot 队列
以下示例使用实例权重，这意味着价格是每单位小时价格，而不是每实例小时价格。每个启动配置列出不同的实例类型和不同的权重。Spot 队列选择每单位小时价格最低的实例类型。竞价型实例集通过将目标容量除以实例权重，计算出要启动的竞价型实例数。如果结果不是整数，则 Spot 队列会将其向上舍入到下一个整数，以便队列的大小不低于其目标容量。
如果 `r3.2xlarge` 请求成功，Spot 将预置其中的 4 个实例。将 20 除以 6 可得到总共 3.33 个实例，然后向上舍入为 4 个实例。
如果 `c3.xlarge` 请求成功，Spot 将预置其中的 7 个实例。将 20 除以 3 可得到总共 6.66 个实例，然后向上舍入为 7 个实例。
有关更多信息，请参阅 [使用实例权重来管理 EC2 实例集或竞价型实例集的成本和性能](ec2-fleet-instance-weighting.md)。
**可用区**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
"WeightedCapacity": 6
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.xlarge",
"Placement": {
"AvailabilityZone": "us-west-2b"
},
"WeightedCapacity": 3
}
]
}
```
**子网**
```
{
"SpotPrice": "0.70",
"TargetCapacity": 20,
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchSpecifications": [
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "r3.2xlarge",
"SubnetId": "subnet-1a2b3c4d",
"WeightedCapacity": 6
},
{
"ImageId": "ami-1a2b3c4d",
"InstanceType": "c3.xlarge",
"SubnetId": "subnet-1a2b3c4d",
"WeightedCapacity": 3
}
]
}
```
## 示例 7：使用按需容量启动竞价型实例集
为确保始终拥有实例容量，您可以在 Spot 队列请求中包含按需容量请求。如果具有容量，则将始终执行按需请求。目标容量的余量将在具有容量且可用的情况下作为 Spot 容量执行。
以下示例将所需的目标容量指定为 10，其中 5 个必须为按需容量。未指定 Spot 容量；它由目标容量减去按需容量的余量隐含指定。Amazon EC2 启动 5 个容量单位作为按需容量，并在有可用的 Amazon EC2 容量并且可用时，启动 5 个容量单位 (10-5=5) 作为 Spot 容量。
```
{
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"AllocationStrategy": "lowestPrice",
"TargetCapacity": 10,
"SpotPrice": null,
"ValidFrom": "2018-04-04T15:58:13Z",
"ValidUntil": "2019-04-04T15:58:13Z",
"TerminateInstancesWithExpiration": true,
"LaunchSpecifications": [],
"Type": "maintain",
"OnDemandTargetCapacity": 5,
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0dbb04d4a6cca5ad1",
"Version": "2"
},
"Overrides": [
{
"InstanceType": "t2.medium",
"WeightedCapacity": 1,
"SubnetId": "subnet-d0dc51fb"
}
]
}
]
}
```
## 示例 8：配置容量再平衡以启动替换竞价型实例
下面的示例将竞价型实例集配置为在 Amazon EC2 为队列中的竞价型实例发出再平衡建议时启动替换竞价型实例。要配置 Spot 实例 的自动替换，对于 `ReplacementStrategy`，请指定 `launch-before-terminate`。要配置从启动新替换竞价型实例到自动删除旧竞价型实例的时间延迟，请对于 `termination-delay`，请指定值（以秒为单位）。有关更多信息，请参阅 [配置选项](ec2-fleet-capacity-rebalance.md#ec2-fleet-capacity-rebalance-config-options)。
**注意**
我们建议仅当您可以预测实例关闭过程完成所需的时长时才使用 `launch-before-terminate`。这将确保只有在关闭过程完成后才终止旧实例。在实例运行期间，您需要为它们付费。
容量再平衡策略的有效性取决于 Spot 队列请求中指定的 Spot 容量池的数量。我们建议您使用一组多样化的实例类型和可用区配置队列，对于 `AllocationStrategy`，请指定 `capacityOptimized`。有关为容量再平衡配置竞价型实例集时应考虑的内容的更多信息，请参阅 [在 EC2 实例集和竞价型实例集中使用“容量再平衡”功能来替换存在风险的竞价型实例](ec2-fleet-capacity-rebalance.md)。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "capacityOptimized",
"IamFleetRole": "arn:aws:iam::123456789012:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "LaunchTemplate",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "c3.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
},
{
"InstanceType": "c4.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
},
{
"InstanceType": "c5.large",
"WeightedCapacity": 1,
"Placement": {
"AvailabilityZone": "us-east-1a"
}
}
]
}
],
"TargetCapacity": 5,
"SpotMaintenanceStrategies": {
"CapacityRebalance": {
"ReplacementStrategy": "launch-before-terminate",
"TerminationDelay": "720"
}
}
}
}
```
## 示例 9：在容量优化的队列中启动竞价型实例
以下示例演示如何使用针对容量进行优化的 Spot 分配策略配置 Spot 队列。要优化容量，您必须将 `AllocationStrategy` 设置为 `capacityOptimized`。
在以下示例中，三个启动规范指定了三个 Spot 容量池。目标容量为 50 个竞价型实例。竞价型实例集尝试在 Spot 容量池中启动 50 个竞价型实例，并为启动的实例数量提供最佳容量。
```
{
"TargetCapacity": "50",
"SpotFleetRequestConfig": {
"AllocationStrategy": "capacityOptimized",
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"AvailabilityZone": "us-west-2a"
},
{
"InstanceType": "m4.2xlarge",
"AvailabilityZone": "us-west-2b"
},
{
"InstanceType": "c5.2xlarge",
"AvailabilityZone": "us-west-2b"
}
]
}
]
}
```
## 示例 10：在具有优先级的容量优化队列中启动竞价型实例
以下示例演示如何通过 Spot 分配策略配置 Spot 队列，该策略针对容量进行优化，同时尽最大努力使用优先级。
使用 `capacityOptimizedPrioritized` 分配策略时，您可以使用 `Priority` 参数指定 Spot 容量池的优先级，数字越小优先级越高。如果您平等地支持多个 Spot 容量池，您还可以为它们设置相同的优先级。如果您没有为某个池设置优先级，则该池将在优先级方面被视为最后一个。
要设置 Spot 容量池的优先级，您必须将 `AllocationStrategy` 设置为 `capacityOptimizedPrioritized`。Spot 队列首先会针对容量进行优化，但会尽最大努力遵循优先级。（例如，如果遵循优先级不会显著影响 Spot 队列预置最佳容量的能力）。对于必须最大限度地减少中断可能性，同时对某些实例类型的偏好也很重要的工作负载来说，这是一个不错的选择。
在以下示例中，三个启动规范指定了三个 Spot 容量池。对每个池进行优先级排序，数字越小优先级越高。目标容量为 50 个竞价型实例。竞价型实例集尝试以最高优先级在 Spot 容量池中启动 50 个竞价型实例，但首先针对容量进行优化。
```
{
"TargetCapacity": "50",
"SpotFleetRequestConfig": {
"AllocationStrategy": "capacityOptimizedPrioritized"
},
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"Priority": 1,
"AvailabilityZone": "us-west-2a"
},
{
"InstanceType": "m4.2xlarge",
"Priority": 2,
"AvailabilityZone": "us-west-2b"
},
{
"InstanceType": "c5.2xlarge",
"Priority": 3,
"AvailabilityZone": "us-west-2b"
}
]
}
]
}
```
## 示例 11：在 priceCapacityOptimized 实例集中启动竞价型实例
以下示例演示了如何通过 Spot 分配策略配置竞价型实例集，该策略针对容量和最低价格进行了优化。若要在考虑价格的同时优化容量，必须将 Spot `AllocationStrategy` 设置为 `priceCapacityOptimized`。
在以下示例中，三个启动规范指定了三个 Spot 容量池。目标容量为 50 个竞价型实例。竞价型实例集尝试在 Spot 容量池中启动 50 个竞价型实例，并为启动的实例数量提供最佳容量，同时选择最低价格的池。
```
{
"SpotFleetRequestConfig": {
"AllocationStrategy": "priceCapacityOptimized",
"OnDemandAllocationStrategy": "lowestPrice",
"ExcessCapacityTerminationPolicy": "default",
"IamFleetRole": "arn:aws:iam::111111111111:role/aws-ec2-spot-fleet-tagging-role",
"LaunchTemplateConfigs": [
{
"LaunchTemplateSpecification": {
"LaunchTemplateId": "lt-0123456789example",
"Version": "1"
},
"Overrides": [
{
"InstanceType": "r4.2xlarge",
"AvailabilityZone": "us-west-2a"
},
{
"InstanceType": "m4.2xlarge",
"AvailabilityZone": "us-west-2b"
},
{
"InstanceType": "c5.2xlarge",
"AvailabilityZone": "us-west-2b"
}
]
}
],
"TargetCapacity": 50,
"Type": "request"
}
}
```
## 示例 12：配置基于属性的实例类型选择
以下示例演示了如何配置竞价型实例集，以使用基于属性的实例类型选择来识别实例类型。若要指定所需的实例属性，请在 `InstanceRequirements` 结构中指定属性。
在以下示例中，指定了 2 个实例属性：
+ `VCpuCount` – 至少指定了 2 个 vCPU。由于未指定最大值，因此没有最大限制。
+ `MemoryMiB` – 至少指定了 4 MiB 的内存。由于未指定最大值，因此没有最大限制。
将识别具有 2 个或更多 vCPU 和 4 MiB 或更大内存的任何实例类型。然而，当[竞价型实例集预置实例集](ec2-fleet-attribute-based-instance-type-selection.md#how-ef-uses-abs)时，价格保护和分配策略可能会排除某些实例类型。
有关您可以指定的所有可能属性的列表和描述，请参阅 *Amazon EC2 API Reference*（《Amazon EC2 API 参考》）中的 [InstanceRequirements](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceRequirements.html)。
```
{
"AllocationStrategy": "priceCapacityOptimized",
"TargetCapacity": 20,
"Type": "request",
"LaunchTemplateConfigs": [{
"LaunchTemplateSpecification": {
"LaunchTemplateName": "my-launch-template",
"Version": "1"
},
"Overrides": [{
"InstanceRequirements": {
"VCpuCount": {
"Min": 2
},
"MemoryMiB": {
"Min": 4
}
}
}]
}]
}
```
# EC2 实例集和竞价型实例集的限额
对于每项 AWS 服务，您的 AWS 账户都具有默认配额（以前称为限制）。除非另有说明，否则，每个配额是区域特定的。
常用的 Amazon EC2 配额适用于由 EC2 队列或 Spot 队列启动的实例，例如 [Spot 实例限制](using-spot-limits.md)和[卷限制](volume_limits.md)。
此外，AWS 账户 存在以下与 EC2 实例集和竞价型实例集相关的限额：
****
| 配额描述 | 配额 |
| --- | --- |
| 每个区域中状态为 active、deleted\$1running 和 cancelled\$1running 的 maintain 和 request 类型 EC2 实例集和竞价型实例集的数量 | 1,000 ¹ ² ³ |
| instant 类型 EC2 实例集的数量 | 无限制 |
| maintain 和 request 类型 EC2 实例集和竞价型实例集的竞价型容量池数量（不重复的实例类型和子网组合） | 300¹ |
| instant 类型 EC2 实例集的竞价型容量池数量（不重复的实例类型和子网组合） | 无限制 |
| 启动规范中的用户数据大小 | 16 KB ² |
| 每个 EC2 实例集或竞价型实例集的目标容量 | 10000 |
| 区域中所有 EC2 实例集和竞价型实例集的目标容量 | 100,000 ¹ |
| EC2 队列请求或 Spot 队列请求不能跨区域。 | |
| EC2 队列请求或 Spot 队列请求不能跨同一可用区内的不同子网。 | |
¹ 这些限制同时适用于您的 EC2 实例集和竞价型实例集。
² 这些是硬配额。您不能请求提高这些限额。
³ 删除 EC2 实例集或取消竞价型实例集请求之后，如果您指定在您删除或取消请求时该实例集*不*应终止其竞价型实例，实例集请求将输入 `deleted_running`（EC2 实例集）或 `cancelled_running`（竞价型实例集）状态，并且实例将继续运行直至它们中断或您手动将其终止。如果终止这些实例，实例集请求将输入 `deleted_terminating`（EC2 实例集）或 `cancelled_terminating`（竞价型实例集）状态，并且不计入此配额。有关更多信息，请参阅[删除 EC2 实例集请求和实例集中的实例](delete-fleet.md)和[取消（删除）竞价型实例集请求](cancel-spot-fleet.md)。
## 请求增加目标容量配额
如果您需要的容量超出目标容量的默认配额，您可以在此请求增加配额。
**请求增加目标容量配额**
1. 打开 支持 Center 的 [Create case](https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-ec2-fleet)（创建案例）表。
1. 选择**提高服务限制**。
1. 对于 **Limit type**（限制类型），选择 **EC2 Fleet**（EC2 实例集）。
1. 对于 **Region**（区域），选择请求增加配额的 AWS 区域。
1. 对于 **Limit**（限制），选择 **Target Fleet Capacity per Fleet (in units)**（每个实例集的目标实例集容量（单位））或 **Target Fleet Capacity per Region (in units)**（每个区域的目标实例集容量（单位）），具体取决于您要增加的配额。
1. 对于 **New limit value**（新增限制值），输入新的配额值。
1. 要请求增加其他配额，选择 **Add another request**（添加另一个请求），然后重复步骤 4-6。
1. 对于 **Use case description**（使用案例描述），输入请求增加配额的原因。
1. 在 **Contact options**（联系选项）下，指定您首选的联系语言和联系方式。
1. 选择**提交**。