/** * 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 namespace Aws { namespace Utils { namespace Xml { class XmlNode; } // namespace Xml } // namespace Utils namespace EC2 { namespace Model { /** *

Describes the configuration of Spot Instances in an EC2 Fleet.

See * Also:

AWS API * Reference

*/ class SpotOptions { public: AWS_EC2_API SpotOptions(); AWS_EC2_API SpotOptions(const Aws::Utils::Xml::XmlNode& xmlNode); AWS_EC2_API SpotOptions& 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 EC2 Fleet launch * configuration. For more information, see Allocation * strategies for Spot Instances in the Amazon EC2 User Guide.

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

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

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

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

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

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

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

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

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

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

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

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

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

*/ inline SpotOptions& WithAllocationStrategy(const SpotAllocationStrategy& value) { SetAllocationStrategy(value); return *this;} /** *

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

*
price-capacity-optimized (recommended)

EC2 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. EC2 * Fleet then requests Spot Instances from the lowest priced of these pools.

*
capacity-optimized

EC2 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 * capacity-optimized-prioritized. 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. * capacity-optimized-prioritized is supported only if your EC2 Fleet * uses a launch template. Note that if the On-Demand * AllocationStrategy is set to prioritized, the same * priority is applied when fulfilling On-Demand capacity.

*
diversified

EC2 Fleet requests instances from all of the Spot * Instance pools that you specify.

lowest-price

EC2 * 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, EC2 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: lowest-price

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

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline const FleetSpotMaintenanceStrategies& GetMaintenanceStrategies() const{ return m_maintenanceStrategies; } /** *

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline bool MaintenanceStrategiesHasBeenSet() const { return m_maintenanceStrategiesHasBeenSet; } /** *

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline void SetMaintenanceStrategies(const FleetSpotMaintenanceStrategies& value) { m_maintenanceStrategiesHasBeenSet = true; m_maintenanceStrategies = value; } /** *

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline void SetMaintenanceStrategies(FleetSpotMaintenanceStrategies&& value) { m_maintenanceStrategiesHasBeenSet = true; m_maintenanceStrategies = std::move(value); } /** *

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline SpotOptions& WithMaintenanceStrategies(const FleetSpotMaintenanceStrategies& value) { SetMaintenanceStrategies(value); return *this;} /** *

The strategies for managing your workloads on your Spot Instances that will * be interrupted. Currently only the capacity rebalance strategy is available.

*/ inline SpotOptions& WithMaintenanceStrategies(FleetSpotMaintenanceStrategies&& value) { SetMaintenanceStrategies(std::move(value)); return *this;} /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline const SpotInstanceInterruptionBehavior& GetInstanceInterruptionBehavior() const{ return m_instanceInterruptionBehavior; } /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline bool InstanceInterruptionBehaviorHasBeenSet() const { return m_instanceInterruptionBehaviorHasBeenSet; } /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline void SetInstanceInterruptionBehavior(const SpotInstanceInterruptionBehavior& value) { m_instanceInterruptionBehaviorHasBeenSet = true; m_instanceInterruptionBehavior = value; } /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline void SetInstanceInterruptionBehavior(SpotInstanceInterruptionBehavior&& value) { m_instanceInterruptionBehaviorHasBeenSet = true; m_instanceInterruptionBehavior = std::move(value); } /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline SpotOptions& WithInstanceInterruptionBehavior(const SpotInstanceInterruptionBehavior& value) { SetInstanceInterruptionBehavior(value); return *this;} /** *

The behavior when a Spot Instance is interrupted.

Default: * terminate

*/ inline SpotOptions& WithInstanceInterruptionBehavior(SpotInstanceInterruptionBehavior&& value) { SetInstanceInterruptionBehavior(std::move(value)); return *this;} /** *

The number of Spot pools across which to allocate your target Spot capacity. * Supported only when AllocationStrategy is set to * lowest-price. EC2 Fleet selects the cheapest Spot pools and evenly * allocates your target Spot capacity across the number of Spot pools that you * specify.

Note that EC2 Fleet attempts to draw Spot Instances from the * number of pools that you specify on a best effort basis. If a pool runs out of * Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to * fulfill your request by drawing from the next cheapest pool. To ensure that your * target capacity is met, you might receive Spot Instances from more than the * number of pools that you specified. Similarly, if most of the pools have no Spot * capacity, you might receive your full target capacity from fewer than the number * of pools that you specified.

*/ inline int GetInstancePoolsToUseCount() const{ return m_instancePoolsToUseCount; } /** *

The number of Spot pools across which to allocate your target Spot capacity. * Supported only when AllocationStrategy is set to * lowest-price. EC2 Fleet selects the cheapest Spot pools and evenly * allocates your target Spot capacity across the number of Spot pools that you * specify.

Note that EC2 Fleet attempts to draw Spot Instances from the * number of pools that you specify on a best effort basis. If a pool runs out of * Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to * fulfill your request by drawing from the next cheapest pool. To ensure that your * target capacity is met, you might receive Spot Instances from more than the * number of pools that you specified. Similarly, if most of the pools have no Spot * capacity, you might receive your full target capacity from fewer than the number * of pools that you specified.

*/ inline bool InstancePoolsToUseCountHasBeenSet() const { return m_instancePoolsToUseCountHasBeenSet; } /** *

The number of Spot pools across which to allocate your target Spot capacity. * Supported only when AllocationStrategy is set to * lowest-price. EC2 Fleet selects the cheapest Spot pools and evenly * allocates your target Spot capacity across the number of Spot pools that you * specify.

Note that EC2 Fleet attempts to draw Spot Instances from the * number of pools that you specify on a best effort basis. If a pool runs out of * Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to * fulfill your request by drawing from the next cheapest pool. To ensure that your * target capacity is met, you might receive Spot Instances from more than the * number of pools that you specified. Similarly, if most of the pools have no Spot * capacity, you might receive your full target capacity from fewer than the number * of pools that you specified.

*/ inline void SetInstancePoolsToUseCount(int value) { m_instancePoolsToUseCountHasBeenSet = true; m_instancePoolsToUseCount = value; } /** *

The number of Spot pools across which to allocate your target Spot capacity. * Supported only when AllocationStrategy is set to * lowest-price. EC2 Fleet selects the cheapest Spot pools and evenly * allocates your target Spot capacity across the number of Spot pools that you * specify.

Note that EC2 Fleet attempts to draw Spot Instances from the * number of pools that you specify on a best effort basis. If a pool runs out of * Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to * fulfill your request by drawing from the next cheapest pool. To ensure that your * target capacity is met, you might receive Spot Instances from more than the * number of pools that you specified. Similarly, if most of the pools have no Spot * capacity, you might receive your full target capacity from fewer than the number * of pools that you specified.

*/ inline SpotOptions& WithInstancePoolsToUseCount(int value) { SetInstancePoolsToUseCount(value); return *this;} /** *

Indicates that the fleet uses a single instance type to launch all Spot * Instances in the fleet.

Supported only for fleets of type * instant.

*/ inline bool GetSingleInstanceType() const{ return m_singleInstanceType; } /** *

Indicates that the fleet uses a single instance type to launch all Spot * Instances in the fleet.

Supported only for fleets of type * instant.

*/ inline bool SingleInstanceTypeHasBeenSet() const { return m_singleInstanceTypeHasBeenSet; } /** *

Indicates that the fleet uses a single instance type to launch all Spot * Instances in the fleet.

Supported only for fleets of type * instant.

*/ inline void SetSingleInstanceType(bool value) { m_singleInstanceTypeHasBeenSet = true; m_singleInstanceType = value; } /** *

Indicates that the fleet uses a single instance type to launch all Spot * Instances in the fleet.

Supported only for fleets of type * instant.

*/ inline SpotOptions& WithSingleInstanceType(bool value) { SetSingleInstanceType(value); return *this;} /** *

Indicates that the fleet launches all Spot Instances into a single * Availability Zone.

Supported only for fleets of type * instant.

*/ inline bool GetSingleAvailabilityZone() const{ return m_singleAvailabilityZone; } /** *

Indicates that the fleet launches all Spot Instances into a single * Availability Zone.

Supported only for fleets of type * instant.

*/ inline bool SingleAvailabilityZoneHasBeenSet() const { return m_singleAvailabilityZoneHasBeenSet; } /** *

Indicates that the fleet launches all Spot Instances into a single * Availability Zone.

Supported only for fleets of type * instant.

*/ inline void SetSingleAvailabilityZone(bool value) { m_singleAvailabilityZoneHasBeenSet = true; m_singleAvailabilityZone = value; } /** *

Indicates that the fleet launches all Spot Instances into a single * Availability Zone.

Supported only for fleets of type * instant.

*/ inline SpotOptions& WithSingleAvailabilityZone(bool value) { SetSingleAvailabilityZone(value); return *this;} /** *

The minimum target capacity for Spot Instances in the fleet. If the minimum * target capacity is not reached, the fleet launches no instances.

*

Supported only for fleets of type instant.

At least one * of the following must be specified: SingleAvailabilityZone | * SingleInstanceType

*/ inline int GetMinTargetCapacity() const{ return m_minTargetCapacity; } /** *

The minimum target capacity for Spot Instances in the fleet. If the minimum * target capacity is not reached, the fleet launches no instances.

*

Supported only for fleets of type instant.

At least one * of the following must be specified: SingleAvailabilityZone | * SingleInstanceType

*/ inline bool MinTargetCapacityHasBeenSet() const { return m_minTargetCapacityHasBeenSet; } /** *

The minimum target capacity for Spot Instances in the fleet. If the minimum * target capacity is not reached, the fleet launches no instances.

*

Supported only for fleets of type instant.

At least one * of the following must be specified: SingleAvailabilityZone | * SingleInstanceType

*/ inline void SetMinTargetCapacity(int value) { m_minTargetCapacityHasBeenSet = true; m_minTargetCapacity = value; } /** *

The minimum target capacity for Spot Instances in the fleet. If the minimum * target capacity is not reached, the fleet launches no instances.

*

Supported only for fleets of type instant.

At least one * of the following must be specified: SingleAvailabilityZone | * SingleInstanceType

*/ inline SpotOptions& WithMinTargetCapacity(int value) { SetMinTargetCapacity(value); return *this;} /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline const Aws::String& GetMaxTotalPrice() const{ return m_maxTotalPrice; } /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline bool MaxTotalPriceHasBeenSet() const { return m_maxTotalPriceHasBeenSet; } /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline void SetMaxTotalPrice(const Aws::String& value) { m_maxTotalPriceHasBeenSet = true; m_maxTotalPrice = value; } /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline void SetMaxTotalPrice(Aws::String&& value) { m_maxTotalPriceHasBeenSet = true; m_maxTotalPrice = std::move(value); } /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline void SetMaxTotalPrice(const char* value) { m_maxTotalPriceHasBeenSet = true; m_maxTotalPrice.assign(value); } /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline SpotOptions& WithMaxTotalPrice(const Aws::String& value) { SetMaxTotalPrice(value); return *this;} /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline SpotOptions& WithMaxTotalPrice(Aws::String&& value) { SetMaxTotalPrice(std::move(value)); return *this;} /** *

The maximum amount per hour for Spot Instances that you're willing to pay. 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.

If you specify a maximum price, your Spot * Instances will be interrupted more frequently than if you do not specify this * parameter.

*/ inline SpotOptions& WithMaxTotalPrice(const char* value) { SetMaxTotalPrice(value); return *this;} private: SpotAllocationStrategy m_allocationStrategy; bool m_allocationStrategyHasBeenSet = false; FleetSpotMaintenanceStrategies m_maintenanceStrategies; bool m_maintenanceStrategiesHasBeenSet = false; SpotInstanceInterruptionBehavior m_instanceInterruptionBehavior; bool m_instanceInterruptionBehaviorHasBeenSet = false; int m_instancePoolsToUseCount; bool m_instancePoolsToUseCountHasBeenSet = false; bool m_singleInstanceType; bool m_singleInstanceTypeHasBeenSet = false; bool m_singleAvailabilityZone; bool m_singleAvailabilityZoneHasBeenSet = false; int m_minTargetCapacity; bool m_minTargetCapacityHasBeenSet = false; Aws::String m_maxTotalPrice; bool m_maxTotalPriceHasBeenSet = false; }; } // namespace Model } // namespace EC2 } // namespace Aws