Module aws_sdk_computeoptimizer::model

Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

Modules

account_enrollment_status

See AccountEnrollmentStatus.

auto_scaling_group_configuration

See AutoScalingGroupConfiguration.

auto_scaling_group_recommendation

See AutoScalingGroupRecommendation.

auto_scaling_group_recommendation_option

See AutoScalingGroupRecommendationOption.

current_performance_risk_ratings

See CurrentPerformanceRiskRatings.

ebs_filter

See EbsFilter.

ebs_utilization_metric

See EbsUtilizationMetric.

effective_recommendation_preferences

See EffectiveRecommendationPreferences.

enrollment_filter

See EnrollmentFilter.

estimated_monthly_savings

See EstimatedMonthlySavings.

export_destination

See ExportDestination.

filter

See Filter.

get_recommendation_error

See GetRecommendationError.

instance_recommendation

See InstanceRecommendation.

instance_recommendation_option

See InstanceRecommendationOption.

job_filter

See JobFilter.

lambda_function_memory_projected_metric

See LambdaFunctionMemoryProjectedMetric.

lambda_function_memory_recommendation_option

See LambdaFunctionMemoryRecommendationOption.

lambda_function_recommendation

See LambdaFunctionRecommendation.

lambda_function_recommendation_filter

See LambdaFunctionRecommendationFilter.

lambda_function_utilization_metric

See LambdaFunctionUtilizationMetric.

projected_metric

See ProjectedMetric.

reason_code_summary

See ReasonCodeSummary.

recommendation_export_job

See RecommendationExportJob.

recommendation_preferences

See RecommendationPreferences.

recommendation_preferences_detail

See RecommendationPreferencesDetail.

recommendation_source

See RecommendationSource.

recommendation_summary

See RecommendationSummary.

recommended_option_projected_metric

See RecommendedOptionProjectedMetric.

s3_destination

See S3Destination.

s3_destination_config

See S3DestinationConfig.

savings_opportunity

See SavingsOpportunity.

scope

See Scope.

summary

See Summary.

utilization_metric

See UtilizationMetric.

volume_configuration

See VolumeConfiguration.

volume_recommendation

See VolumeRecommendation.

volume_recommendation_option

See VolumeRecommendationOption.

Structs

AccountEnrollmentStatus

Describes the enrollment status of an organization's member accounts in Compute Optimizer.

AutoScalingGroupConfiguration

Describes the configuration of an Auto Scaling group.

AutoScalingGroupRecommendation

Describes an Auto Scaling group recommendation.

AutoScalingGroupRecommendationOption

Describes a recommendation option for an Auto Scaling group.

CurrentPerformanceRiskRatings

Describes the performance risk ratings for a given resource type.

EbsFilter

Describes a filter that returns a more specific list of Amazon Elastic Block Store (Amazon EBS) volume recommendations. Use this filter with the GetEBSVolumeRecommendations action.

EbsUtilizationMetric

Describes a utilization metric of an Amazon Elastic Block Store (Amazon EBS) volume.

EffectiveRecommendationPreferences

Describes the effective recommendation preferences for a resource.

EnrollmentFilter

Describes a filter that returns a more specific list of account enrollment statuses. Use this filter with the GetEnrollmentStatusesForOrganization action.

EstimatedMonthlySavings

Describes the estimated monthly savings amount possible, based on On-Demand instance pricing, by adopting Compute Optimizer recommendations for a given resource.

ExportDestination

Describes the destination of the recommendations export and metadata files.

Filter

Describes a filter that returns a more specific list of recommendations. Use this filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.

GetRecommendationError

Describes an error experienced when getting recommendations.

InstanceRecommendation

Describes an Amazon EC2 instance recommendation.

InstanceRecommendationOption

Describes a recommendation option for an Amazon EC2 instance.

JobFilter

Describes a filter that returns a more specific list of recommendation export jobs. Use this filter with the DescribeRecommendationExportJobs action.

LambdaFunctionMemoryProjectedMetric

Describes a projected utilization metric of an Lambda function recommendation option.

LambdaFunctionMemoryRecommendationOption

Describes a recommendation option for an Lambda function.

LambdaFunctionRecommendation

Describes an Lambda function recommendation.

LambdaFunctionRecommendationFilter

Describes a filter that returns a more specific list of Lambda function recommendations. Use this filter with the GetLambdaFunctionRecommendations action.

LambdaFunctionUtilizationMetric

Describes a utilization metric of an Lambda function.

ProjectedMetric

Describes a projected utilization metric of a recommendation option, such as an Amazon EC2 instance. This represents the projected utilization of a recommendation option had you used that resource during the analyzed period.

ReasonCodeSummary

A summary of a finding reason code.

RecommendationExportJob

Describes a recommendation export job.

RecommendationPreferences

Describes the recommendation preferences to return in the response of a GetAutoScalingGroupRecommendations, GetEC2InstanceRecommendations, and GetEC2RecommendationProjectedMetrics request.

RecommendationPreferencesDetail

Describes a recommendation preference.

RecommendationSource

Describes the source of a recommendation, such as an Amazon EC2 instance or Auto Scaling group.

RecommendationSummary

A summary of a recommendation.

RecommendedOptionProjectedMetric

Describes a projected utilization metric of a recommendation option.

S3Destination

Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name and object keys of a recommendations export file, and its associated metadata file.

S3DestinationConfig

Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name and key prefix for a recommendations export job.

SavingsOpportunity

Describes the savings opportunity for recommendations of a given resource type or for the recommendation option of an individual resource.

Scope

Describes the scope of a recommendation preference.

Summary

The summary of a recommendation.

UtilizationMetric

Describes a utilization metric of a resource, such as an Amazon EC2 instance.

VolumeConfiguration

Describes the configuration of an Amazon Elastic Block Store (Amazon EBS) volume.

VolumeRecommendation

Describes an Amazon Elastic Block Store (Amazon EBS) volume recommendation.

VolumeRecommendationOption

Describes a recommendation option for an Amazon Elastic Block Store (Amazon EBS) instance.

Enums

CpuVendorArchitecture

When writing a match expression against CpuVendorArchitecture, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Currency

When writing a match expression against Currency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CurrentPerformanceRisk

When writing a match expression against CurrentPerformanceRisk, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EbsFilterName

When writing a match expression against EbsFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EbsFinding

When writing a match expression against EbsFinding, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EbsMetricName

When writing a match expression against EbsMetricName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnhancedInfrastructureMetrics

When writing a match expression against EnhancedInfrastructureMetrics, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EnrollmentFilterName

When writing a match expression against EnrollmentFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportableAutoScalingGroupField

When writing a match expression against ExportableAutoScalingGroupField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportableInstanceField

When writing a match expression against ExportableInstanceField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportableLambdaFunctionField

When writing a match expression against ExportableLambdaFunctionField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportableVolumeField

When writing a match expression against ExportableVolumeField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FileFormat

When writing a match expression against FileFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FilterName

When writing a match expression against FilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Finding

When writing a match expression against Finding, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FindingReasonCode

When writing a match expression against FindingReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InferredWorkloadType

When writing a match expression against InferredWorkloadType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InferredWorkloadTypesPreference

When writing a match expression against InferredWorkloadTypesPreference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InstanceRecommendationFindingReasonCode

When writing a match expression against InstanceRecommendationFindingReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JobFilterName

When writing a match expression against JobFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

JobStatus

When writing a match expression against JobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionMemoryMetricName

When writing a match expression against LambdaFunctionMemoryMetricName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionMemoryMetricStatistic

When writing a match expression against LambdaFunctionMemoryMetricStatistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionMetricName

When writing a match expression against LambdaFunctionMetricName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionMetricStatistic

When writing a match expression against LambdaFunctionMetricStatistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionRecommendationFilterName

When writing a match expression against LambdaFunctionRecommendationFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionRecommendationFinding

When writing a match expression against LambdaFunctionRecommendationFinding, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LambdaFunctionRecommendationFindingReasonCode

When writing a match expression against LambdaFunctionRecommendationFindingReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MetricName

When writing a match expression against MetricName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MetricStatistic

When writing a match expression against MetricStatistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MigrationEffort

When writing a match expression against MigrationEffort, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PlatformDifference

When writing a match expression against PlatformDifference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecommendationPreferenceName

When writing a match expression against RecommendationPreferenceName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecommendationSourceType

When writing a match expression against RecommendationSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceType

When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScopeName

When writing a match expression against ScopeName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Status

When writing a match expression against Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.