Struct aws_sdk_ec2::model::TargetCapacitySpecification

#[non_exhaustive]
pub struct TargetCapacitySpecification { /* private fields */ }

The number of units to request. You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is maintain, you can specify a target capacity of 0 and add capacity later.

You can use the On-Demand Instance MaxTotalPrice parameter, the Spot Instance MaxTotalPrice, or both to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, EC2 Fleet will launch instances until it reaches the maximum amount that you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity. The MaxTotalPrice parameters are located in OnDemandOptions and SpotOptions.

Implementations

impl TargetCapacitySpecification

pub fn total_target_capacity(&self) -> Option<i32>

The number of units to request, filled using DefaultTargetCapacityType.

pub fn on_demand_target_capacity(&self) -> Option<i32>

The number of On-Demand units to request. If you specify a target capacity for Spot units, you cannot specify a target capacity for On-Demand units.

pub fn spot_target_capacity(&self) -> Option<i32>

The maximum number of Spot units to launch. If you specify a target capacity for On-Demand units, you cannot specify a target capacity for Spot units.

pub fn default_target_capacity_type(&self) -> Option<&DefaultTargetCapacityType>

The default TotalTargetCapacity, which is either Spot or On-Demand.

pub fn target_capacity_unit_type(&self) -> Option<&TargetCapacityUnitType>

The unit for the target capacity.

Default: units (translates to number of instances)

impl TargetCapacitySpecification

pub fn builder() -> Builder

Creates a new builder-style object to manufacture TargetCapacitySpecification.

Examples found in repository

src/xml_deser.rs (line 58519)

pub fn deser_structure_crate_model_target_capacity_specification(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetCapacitySpecification, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetCapacitySpecification::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("totalTargetCapacity") /* TotalTargetCapacity com.amazonaws.ec2#TargetCapacitySpecification$TotalTargetCapacity */ =>  {
                let var_2848 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_total_target_capacity(var_2848);
            }
            ,
            s if s.matches("onDemandTargetCapacity") /* OnDemandTargetCapacity com.amazonaws.ec2#TargetCapacitySpecification$OnDemandTargetCapacity */ =>  {
                let var_2849 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_on_demand_target_capacity(var_2849);
            }
            ,
            s if s.matches("spotTargetCapacity") /* SpotTargetCapacity com.amazonaws.ec2#TargetCapacitySpecification$SpotTargetCapacity */ =>  {
                let var_2850 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_spot_target_capacity(var_2850);
            }
            ,
            s if s.matches("defaultTargetCapacityType") /* DefaultTargetCapacityType com.amazonaws.ec2#TargetCapacitySpecification$DefaultTargetCapacityType */ =>  {
                let var_2851 =
                    Some(
                        Result::<crate::model::DefaultTargetCapacityType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::DefaultTargetCapacityType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_default_target_capacity_type(var_2851);
            }
            ,
            s if s.matches("targetCapacityUnitType") /* TargetCapacityUnitType com.amazonaws.ec2#TargetCapacitySpecification$TargetCapacityUnitType */ =>  {
                let var_2852 =
                    Some(
                        Result::<crate::model::TargetCapacityUnitType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TargetCapacityUnitType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_target_capacity_unit_type(var_2852);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for TargetCapacitySpecification

fn clone(&self) -> TargetCapacitySpecification

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TargetCapacitySpecification

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<TargetCapacitySpecification> for TargetCapacitySpecification

fn eq(&self, other: &TargetCapacitySpecification) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TargetCapacitySpecification