/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Aws { namespace Utils { namespace Xml { class XmlNode; } // namespace Xml } // namespace Utils namespace EC2 { namespace Model { /** *

Describes the configuration of a Spot Fleet request.

*/ class SpotFleetRequestConfigData { public: AWS_EC2_API SpotFleetRequestConfigData(); AWS_EC2_API SpotFleetRequestConfigData(const Aws::Utils::Xml::XmlNode& xmlNode); AWS_EC2_API SpotFleetRequestConfigData& operator=(const Aws::Utils::Xml::XmlNode& xmlNode); AWS_EC2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const; AWS_EC2_API void OutputToStream(Aws::OStream& oStream, const char* location) const; /** *

The strategy that determines how to allocate the target Spot Instance * capacity across the Spot Instance pools specified by the Spot Fleet launch * configuration. For more information, see Allocation * strategies for Spot Instances in the Amazon EC2 User Guide.

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline const AllocationStrategy& GetAllocationStrategy() const{ return m_allocationStrategy; } /** *

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline bool AllocationStrategyHasBeenSet() const { return m_allocationStrategyHasBeenSet; } /** *

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline void SetAllocationStrategy(const AllocationStrategy& value) { m_allocationStrategyHasBeenSet = true; m_allocationStrategy = value; } /** *

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline void SetAllocationStrategy(AllocationStrategy&& value) { m_allocationStrategyHasBeenSet = true; m_allocationStrategy = std::move(value); } /** *

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline SpotFleetRequestConfigData& WithAllocationStrategy(const AllocationStrategy& value) { SetAllocationStrategy(value); return *this;} /** *

priceCapacityOptimized (recommended): Spot Fleet identifies the * pools with the highest capacity availability for the number of instances that * are launching. This means that we will request Spot Instances from the pools * that we believe have the lowest chance of interruption in the near term. Spot * Fleet then requests Spot Instances from the lowest priced of these pools.
*
capacityOptimized: Spot Fleet identifies the pools with * the highest capacity availability for the number of instances that are * launching. This means that we will request Spot Instances from the pools that we * believe have the lowest chance of interruption in the near term. To give certain * instance types a higher chance of launching first, use * capacityOptimizedPrioritized. Set a priority for each instance type * by using the Priority parameter for * LaunchTemplateOverrides. You can assign the same priority to * different LaunchTemplateOverrides. EC2 implements the priorities on * a best-effort basis, but optimizes for capacity first. * capacityOptimizedPrioritized is supported only if your Spot Fleet * uses a launch template. Note that if the OnDemandAllocationStrategy * is set to prioritized, the same priority is applied when fulfilling * On-Demand capacity.
diversified: Spot Fleet requests * instances from all of the Spot Instance pools that you specify.
lowestPrice: Spot Fleet requests instances from the lowest * priced Spot Instance pool that has available capacity. If the lowest priced pool * doesn't have available capacity, the Spot Instances come from the next lowest * priced pool that has available capacity. If a pool runs out of capacity before * fulfilling your desired capacity, Spot Fleet will continue to fulfill your * request by drawing from the next lowest priced pool. To ensure that your desired * capacity is met, you might receive Spot Instances from several pools. Because * this strategy only considers instance price and not capacity availability, it * might lead to high interruption rates.

Default: * lowestPrice

*/ inline SpotFleetRequestConfigData& WithAllocationStrategy(AllocationStrategy&& value) { SetAllocationStrategy(std::move(value)); return *this;} /** *

The order of the launch template overrides to use in fulfilling On-Demand * capacity. If you specify lowestPrice, Spot Fleet uses price to * determine the order, launching the lowest price first. If you specify * prioritized, Spot Fleet uses the priority that you assign to each * Spot Fleet launch template override, launching the highest priority first. If * you do not specify a value, Spot Fleet defaults to lowestPrice.

*/ inline const OnDemandAllocationStrategy& GetOnDemandAllocationStrategy() const{ return m_onDemandAllocationStrategy; } /** *

*/ inline bool OnDemandAllocationStrategyHasBeenSet() const { return m_onDemandAllocationStrategyHasBeenSet; } /** *

*/ inline void SetOnDemandAllocationStrategy(const OnDemandAllocationStrategy& value) { m_onDemandAllocationStrategyHasBeenSet = true; m_onDemandAllocationStrategy = value; } /** *

*/ inline void SetOnDemandAllocationStrategy(OnDemandAllocationStrategy&& value) { m_onDemandAllocationStrategyHasBeenSet = true; m_onDemandAllocationStrategy = std::move(value); } /** *

*/ inline SpotFleetRequestConfigData& WithOnDemandAllocationStrategy(const OnDemandAllocationStrategy& value) { SetOnDemandAllocationStrategy(value); return *this;} /** *

*/ inline SpotFleetRequestConfigData& WithOnDemandAllocationStrategy(OnDemandAllocationStrategy&& value) { SetOnDemandAllocationStrategy(std::move(value)); return *this;} /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline const SpotMaintenanceStrategies& GetSpotMaintenanceStrategies() const{ return m_spotMaintenanceStrategies; } /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline bool SpotMaintenanceStrategiesHasBeenSet() const { return m_spotMaintenanceStrategiesHasBeenSet; } /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline void SetSpotMaintenanceStrategies(const SpotMaintenanceStrategies& value) { m_spotMaintenanceStrategiesHasBeenSet = true; m_spotMaintenanceStrategies = value; } /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline void SetSpotMaintenanceStrategies(SpotMaintenanceStrategies&& value) { m_spotMaintenanceStrategiesHasBeenSet = true; m_spotMaintenanceStrategies = std::move(value); } /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline SpotFleetRequestConfigData& WithSpotMaintenanceStrategies(const SpotMaintenanceStrategies& value) { SetSpotMaintenanceStrategies(value); return *this;} /** *

The strategies for managing your Spot Instances that are at an elevated risk * of being interrupted.

*/ inline SpotFleetRequestConfigData& WithSpotMaintenanceStrategies(SpotMaintenanceStrategies&& value) { SetSpotMaintenanceStrategies(std::move(value)); return *this;} /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline const Aws::String& GetClientToken() const{ return m_clientToken; } /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; } /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; } /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = std::move(value); } /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); } /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline SpotFleetRequestConfigData& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;} /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline SpotFleetRequestConfigData& WithClientToken(Aws::String&& value) { SetClientToken(std::move(value)); return *this;} /** *

A unique, case-sensitive identifier that you provide to ensure the * idempotency of your listings. This helps to avoid duplicate listings. For more * information, see Ensuring * Idempotency.

*/ inline SpotFleetRequestConfigData& WithClientToken(const char* value) { SetClientToken(value); return *this;} /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline const ExcessCapacityTerminationPolicy& GetExcessCapacityTerminationPolicy() const{ return m_excessCapacityTerminationPolicy; } /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline bool ExcessCapacityTerminationPolicyHasBeenSet() const { return m_excessCapacityTerminationPolicyHasBeenSet; } /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline void SetExcessCapacityTerminationPolicy(const ExcessCapacityTerminationPolicy& value) { m_excessCapacityTerminationPolicyHasBeenSet = true; m_excessCapacityTerminationPolicy = value; } /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline void SetExcessCapacityTerminationPolicy(ExcessCapacityTerminationPolicy&& value) { m_excessCapacityTerminationPolicyHasBeenSet = true; m_excessCapacityTerminationPolicy = std::move(value); } /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline SpotFleetRequestConfigData& WithExcessCapacityTerminationPolicy(const ExcessCapacityTerminationPolicy& value) { SetExcessCapacityTerminationPolicy(value); return *this;} /** *

Indicates whether running instances should be terminated if you decrease the * target capacity of the Spot Fleet request below the current size of the Spot * Fleet.

Supported only for fleets of type maintain.

*/ inline SpotFleetRequestConfigData& WithExcessCapacityTerminationPolicy(ExcessCapacityTerminationPolicy&& value) { SetExcessCapacityTerminationPolicy(std::move(value)); return *this;} /** *

The number of units fulfilled by this request compared to the set target * capacity. You cannot set this value.

*/ inline double GetFulfilledCapacity() const{ return m_fulfilledCapacity; } /** *

The number of units fulfilled by this request compared to the set target * capacity. You cannot set this value.

*/ inline bool FulfilledCapacityHasBeenSet() const { return m_fulfilledCapacityHasBeenSet; } /** *

The number of units fulfilled by this request compared to the set target * capacity. You cannot set this value.

*/ inline void SetFulfilledCapacity(double value) { m_fulfilledCapacityHasBeenSet = true; m_fulfilledCapacity = value; } /** *

The number of units fulfilled by this request compared to the set target * capacity. You cannot set this value.

*/ inline SpotFleetRequestConfigData& WithFulfilledCapacity(double value) { SetFulfilledCapacity(value); return *this;} /** *

The number of On-Demand units fulfilled by this request compared to the set * target On-Demand capacity.

*/ inline double GetOnDemandFulfilledCapacity() const{ return m_onDemandFulfilledCapacity; } /** *

The number of On-Demand units fulfilled by this request compared to the set * target On-Demand capacity.

*/ inline bool OnDemandFulfilledCapacityHasBeenSet() const { return m_onDemandFulfilledCapacityHasBeenSet; } /** *

The number of On-Demand units fulfilled by this request compared to the set * target On-Demand capacity.

*/ inline void SetOnDemandFulfilledCapacity(double value) { m_onDemandFulfilledCapacityHasBeenSet = true; m_onDemandFulfilledCapacity = value; } /** *

The number of On-Demand units fulfilled by this request compared to the set * target On-Demand capacity.

*/ inline SpotFleetRequestConfigData& WithOnDemandFulfilledCapacity(double value) { SetOnDemandFulfilledCapacity(value); return *this;} /** *

The Amazon Resource Name (ARN) of an Identity and Access Management (IAM) * role that grants the Spot Fleet the permission to request, launch, terminate, * and tag instances on your behalf. For more information, see Spot * Fleet prerequisites in the Amazon EC2 User Guide. Spot Fleet can * terminate Spot Instances on your behalf when you cancel its Spot Fleet request * using CancelSpotFleetRequests * or when the Spot Fleet request expires, if you set * TerminateInstancesWithExpiration.

*/ inline const Aws::String& GetIamFleetRole() const{ return m_iamFleetRole; } /** *

*/ inline bool IamFleetRoleHasBeenSet() const { return m_iamFleetRoleHasBeenSet; } /** *

*/ inline void SetIamFleetRole(const Aws::String& value) { m_iamFleetRoleHasBeenSet = true; m_iamFleetRole = value; } /** *

*/ inline void SetIamFleetRole(Aws::String&& value) { m_iamFleetRoleHasBeenSet = true; m_iamFleetRole = std::move(value); } /** *

*/ inline void SetIamFleetRole(const char* value) { m_iamFleetRoleHasBeenSet = true; m_iamFleetRole.assign(value); } /** *

*/ inline SpotFleetRequestConfigData& WithIamFleetRole(const Aws::String& value) { SetIamFleetRole(value); return *this;} /** *

*/ inline SpotFleetRequestConfigData& WithIamFleetRole(Aws::String&& value) { SetIamFleetRole(std::move(value)); return *this;} /** *

*/ inline SpotFleetRequestConfigData& WithIamFleetRole(const char* value) { SetIamFleetRole(value); return *this;} /** *

The launch specifications for the Spot Fleet request. If you specify * LaunchSpecifications, you can't specify * LaunchTemplateConfigs. If you include On-Demand capacity in your * request, you must use LaunchTemplateConfigs.

*/ inline const Aws::Vector& GetLaunchSpecifications() const{ return m_launchSpecifications; } /** *

*/ inline bool LaunchSpecificationsHasBeenSet() const { return m_launchSpecificationsHasBeenSet; } /** *

*/ inline void SetLaunchSpecifications(const Aws::Vector& value) { m_launchSpecificationsHasBeenSet = true; m_launchSpecifications = value; } /** *

*/ inline void SetLaunchSpecifications(Aws::Vector&& value) { m_launchSpecificationsHasBeenSet = true; m_launchSpecifications = std::move(value); } /** *

*/ inline SpotFleetRequestConfigData& WithLaunchSpecifications(const Aws::Vector& value) { SetLaunchSpecifications(value); return *this;} /** *

*/ inline SpotFleetRequestConfigData& WithLaunchSpecifications(Aws::Vector&& value) { SetLaunchSpecifications(std::move(value)); return *this;} /** *

*/ inline SpotFleetRequestConfigData& AddLaunchSpecifications(const SpotFleetLaunchSpecification& value) { m_launchSpecificationsHasBeenSet = true; m_launchSpecifications.push_back(value); return *this; } /** *

*/ inline SpotFleetRequestConfigData& AddLaunchSpecifications(SpotFleetLaunchSpecification&& value) { m_launchSpecificationsHasBeenSet = true; m_launchSpecifications.push_back(std::move(value)); return *this; } /** *

The launch template and overrides. If you specify * LaunchTemplateConfigs, you can't specify * LaunchSpecifications. If you include On-Demand capacity in your * request, you must use LaunchTemplateConfigs.

*/ inline const Aws::Vector& GetLaunchTemplateConfigs() const{ return m_launchTemplateConfigs; } /** *

*/ inline bool LaunchTemplateConfigsHasBeenSet() const { return m_launchTemplateConfigsHasBeenSet; } /** *

*/ inline void SetLaunchTemplateConfigs(const Aws::Vector& value) { m_launchTemplateConfigsHasBeenSet = true; m_launchTemplateConfigs = value; } /** *

*/ inline void SetLaunchTemplateConfigs(Aws::Vector&& value) { m_launchTemplateConfigsHasBeenSet = true; m_launchTemplateConfigs = std::move(value); } /** *

*/ inline SpotFleetRequestConfigData& WithLaunchTemplateConfigs(const Aws::Vector& value) { SetLaunchTemplateConfigs(value); return *this;} /** *

*/ inline SpotFleetRequestConfigData& WithLaunchTemplateConfigs(Aws::Vector&& value) { SetLaunchTemplateConfigs(std::move(value)); return *this;} /** *

*/ inline SpotFleetRequestConfigData& AddLaunchTemplateConfigs(const LaunchTemplateConfig& value) { m_launchTemplateConfigsHasBeenSet = true; m_launchTemplateConfigs.push_back(value); return *this; } /** *

*/ inline SpotFleetRequestConfigData& AddLaunchTemplateConfigs(LaunchTemplateConfig&& value) { m_launchTemplateConfigsHasBeenSet = true; m_launchTemplateConfigs.push_back(std::move(value)); return *this; } /** *

The maximum price per unit hour that you are willing to pay for a Spot * Instance. We do not recommend using this parameter because it can lead to * increased interruptions. If you do not specify this parameter, you will pay the * current Spot price.