/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace ApplicationAutoScaling { /** *

With Application Auto Scaling, you can configure automatic scaling for the * following resources:

  • Amazon AppStream 2.0 fleets

  • *

    Amazon Aurora Replicas

  • Amazon Comprehend document * classification and entity recognizer endpoints

  • Amazon DynamoDB * tables and global secondary indexes throughput capacity

  • Amazon * ECS services

  • Amazon ElastiCache for Redis clusters * (replication groups)

  • Amazon EMR clusters

  • *

    Amazon Keyspaces (for Apache Cassandra) tables

  • Lambda * function provisioned concurrency

  • Amazon Managed Streaming for * Apache Kafka broker storage

  • Amazon Neptune clusters

    • *

  • Amazon SageMaker endpoint variants

  • Amazon SageMaker * Serverless endpoint provisioned concurrency

  • Spot Fleets * (Amazon EC2)

  • Custom resources provided by your own * applications or services

To learn more about Application Auto * Scaling, see the Application * Auto Scaling User Guide.

API Summary

The Application * Auto Scaling service API includes three key sets of actions:

  • *

    Register and manage scalable targets - Register Amazon Web Services or custom * resources as scalable targets (a resource that Application Auto Scaling can * scale), set minimum and maximum capacity limits, and retrieve information on * existing scalable targets.

  • Configure and manage automatic * scaling - Define scaling policies to dynamically scale your resources in * response to CloudWatch alarms, schedule one-time or recurring scaling actions, * and retrieve your recent scaling activity history.

  • Suspend and * resume scaling - Temporarily suspend and later resume automatic scaling by * calling the RegisterScalableTarget * API action for any Application Auto Scaling scalable target. You can suspend and * resume (individually or in combination) scale-out activities that are triggered * by a scaling policy, scale-in activities that are triggered by a scaling policy, * and scheduled scaling.

*/ class AWS_APPLICATIONAUTOSCALING_API ApplicationAutoScalingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ApplicationAutoScalingClientConfiguration ClientConfigurationType; typedef ApplicationAutoScalingEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ApplicationAutoScalingClient(const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ApplicationAutoScalingClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ApplicationAutoScalingClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration& clientConfiguration = Aws::ApplicationAutoScaling::ApplicationAutoScalingClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ApplicationAutoScalingClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ApplicationAutoScalingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ApplicationAutoScalingClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ApplicationAutoScalingClient(); /** *

Deletes the specified scaling policy for an Application Auto Scaling scalable * target.

Deleting a step scaling policy deletes the underlying alarm * action, but does not delete the CloudWatch alarm associated with the scaling * policy, even if it no longer has an associated action.

For more * information, see Delete * a step scaling policy and Delete * a target tracking scaling policy in the Application Auto Scaling User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteScalingPolicyOutcome DeleteScalingPolicy(const Model::DeleteScalingPolicyRequest& request) const; /** * A Callable wrapper for DeleteScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteScalingPolicyOutcomeCallable DeleteScalingPolicyCallable(const DeleteScalingPolicyRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DeleteScalingPolicy, request); } /** * An Async wrapper for DeleteScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteScalingPolicyAsync(const DeleteScalingPolicyRequestT& request, const DeleteScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DeleteScalingPolicy, request, handler, context); } /** *

Deletes the specified scheduled action for an Application Auto Scaling * scalable target.

For more information, see Delete * a scheduled action in the Application Auto Scaling User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteScheduledActionOutcome DeleteScheduledAction(const Model::DeleteScheduledActionRequest& request) const; /** * A Callable wrapper for DeleteScheduledAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteScheduledActionOutcomeCallable DeleteScheduledActionCallable(const DeleteScheduledActionRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DeleteScheduledAction, request); } /** * An Async wrapper for DeleteScheduledAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteScheduledActionAsync(const DeleteScheduledActionRequestT& request, const DeleteScheduledActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DeleteScheduledAction, request, handler, context); } /** *

Deregisters an Application Auto Scaling scalable target when you have * finished using it. To see which resources have been registered, use DescribeScalableTargets. *

Deregistering a scalable target deletes the scaling policies and * the scheduled actions that are associated with it.

See * Also:

AWS * API Reference

*/ virtual Model::DeregisterScalableTargetOutcome DeregisterScalableTarget(const Model::DeregisterScalableTargetRequest& request) const; /** * A Callable wrapper for DeregisterScalableTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterScalableTargetOutcomeCallable DeregisterScalableTargetCallable(const DeregisterScalableTargetRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DeregisterScalableTarget, request); } /** * An Async wrapper for DeregisterScalableTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterScalableTargetAsync(const DeregisterScalableTargetRequestT& request, const DeregisterScalableTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DeregisterScalableTarget, request, handler, context); } /** *

Gets information about the scalable targets in the specified namespace.

*

You can filter the results using ResourceIds and * ScalableDimension.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScalableTargetsOutcome DescribeScalableTargets(const Model::DescribeScalableTargetsRequest& request) const; /** * A Callable wrapper for DescribeScalableTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScalableTargetsOutcomeCallable DescribeScalableTargetsCallable(const DescribeScalableTargetsRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalableTargets, request); } /** * An Async wrapper for DescribeScalableTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScalableTargetsAsync(const DescribeScalableTargetsRequestT& request, const DescribeScalableTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalableTargets, request, handler, context); } /** *

Provides descriptive information about the scaling activities in the * specified namespace from the previous six weeks.

You can filter the * results using ResourceId and ScalableDimension.

*

For information about viewing scaling activities using the Amazon Web * Services CLI, see Scaling * activities for Application Auto Scaling.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScalingActivitiesOutcome DescribeScalingActivities(const Model::DescribeScalingActivitiesRequest& request) const; /** * A Callable wrapper for DescribeScalingActivities that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScalingActivitiesOutcomeCallable DescribeScalingActivitiesCallable(const DescribeScalingActivitiesRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalingActivities, request); } /** * An Async wrapper for DescribeScalingActivities that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScalingActivitiesAsync(const DescribeScalingActivitiesRequestT& request, const DescribeScalingActivitiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalingActivities, request, handler, context); } /** *

Describes the Application Auto Scaling scaling policies for the specified * service namespace.

You can filter the results using * ResourceId, ScalableDimension, and * PolicyNames.

For more information, see Target * tracking scaling policies and Step * scaling policies in the Application Auto Scaling User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScalingPoliciesOutcome DescribeScalingPolicies(const Model::DescribeScalingPoliciesRequest& request) const; /** * A Callable wrapper for DescribeScalingPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScalingPoliciesOutcomeCallable DescribeScalingPoliciesCallable(const DescribeScalingPoliciesRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DescribeScalingPolicies, request); } /** * An Async wrapper for DescribeScalingPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScalingPoliciesAsync(const DescribeScalingPoliciesRequestT& request, const DescribeScalingPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DescribeScalingPolicies, request, handler, context); } /** *

Describes the Application Auto Scaling scheduled actions for the specified * service namespace.

You can filter the results using the * ResourceId, ScalableDimension, and * ScheduledActionNames parameters.

For more information, see * Scheduled * scaling and Managing * scheduled scaling in the Application Auto Scaling User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScheduledActionsOutcome DescribeScheduledActions(const Model::DescribeScheduledActionsRequest& request) const; /** * A Callable wrapper for DescribeScheduledActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScheduledActionsOutcomeCallable DescribeScheduledActionsCallable(const DescribeScheduledActionsRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::DescribeScheduledActions, request); } /** * An Async wrapper for DescribeScheduledActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScheduledActionsAsync(const DescribeScheduledActionsRequestT& request, const DescribeScheduledActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::DescribeScheduledActions, request, handler, context); } /** *

Returns all the tags on the specified Application Auto Scaling scalable * target.

For general information about tags, including the format and * syntax, see Tagging * Amazon Web Services resources in the Amazon Web Services General * Reference.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::ListTagsForResource, request, handler, context); } /** *

Creates or updates a scaling policy for an Application Auto Scaling scalable * target.

Each scalable target is identified by a service namespace, * resource ID, and scalable dimension. A scaling policy applies to the scalable * target identified by those three attributes. You cannot create a scaling policy * until you have registered the resource as a scalable target.

Multiple * scaling policies can be in force at the same time for the same scalable target. * You can have one or more target tracking scaling policies, one or more step * scaling policies, or both. However, there is a chance that multiple policies * could conflict, instructing the scalable target to scale out or in at the same * time. Application Auto Scaling gives precedence to the policy that provides the * largest capacity for both scale out and scale in. For example, if one policy * increases capacity by 3, another policy increases capacity by 200 percent, and * the current capacity is 10, Application Auto Scaling uses the policy with the * highest calculated capacity (200% of 10 = 20) and scales out to 30.

We * recommend caution, however, when using target tracking scaling policies with * step scaling policies because conflicts between these policies can cause * undesirable behavior. For example, if the step scaling policy initiates a * scale-in activity before the target tracking policy is ready to scale in, the * scale-in activity will not be blocked. After the scale-in activity completes, * the target tracking policy could instruct the scalable target to scale out * again.

For more information, see Target * tracking scaling policies and Step * scaling policies in the Application Auto Scaling User Guide.

*

If a scalable target is deregistered, the scalable target is no longer * available to use scaling policies. Any scaling policies that were specified for * the scalable target are deleted.

See Also:

AWS * API Reference

*/ virtual Model::PutScalingPolicyOutcome PutScalingPolicy(const Model::PutScalingPolicyRequest& request) const; /** * A Callable wrapper for PutScalingPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutScalingPolicyOutcomeCallable PutScalingPolicyCallable(const PutScalingPolicyRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::PutScalingPolicy, request); } /** * An Async wrapper for PutScalingPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutScalingPolicyAsync(const PutScalingPolicyRequestT& request, const PutScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::PutScalingPolicy, request, handler, context); } /** *

Creates or updates a scheduled action for an Application Auto Scaling * scalable target.

Each scalable target is identified by a service * namespace, resource ID, and scalable dimension. A scheduled action applies to * the scalable target identified by those three attributes. You cannot create a * scheduled action until you have registered the resource as a scalable * target.

When you specify start and end times with a recurring schedule * using a cron expression or rates, they form the boundaries for when the * recurring action starts and stops.

To update a scheduled action, specify * the parameters that you want to change. If you don't specify start and end * times, the old values are deleted.

For more information, see Scheduled * scaling in the Application Auto Scaling User Guide.

If * a scalable target is deregistered, the scalable target is no longer available to * run scheduled actions. Any scheduled actions that were specified for the * scalable target are deleted.

See Also:

AWS * API Reference

*/ virtual Model::PutScheduledActionOutcome PutScheduledAction(const Model::PutScheduledActionRequest& request) const; /** * A Callable wrapper for PutScheduledAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutScheduledActionOutcomeCallable PutScheduledActionCallable(const PutScheduledActionRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::PutScheduledAction, request); } /** * An Async wrapper for PutScheduledAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutScheduledActionAsync(const PutScheduledActionRequestT& request, const PutScheduledActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::PutScheduledAction, request, handler, context); } /** *

Registers or updates a scalable target, which is the resource that you want * to scale.

Scalable targets are uniquely identified by the combination of * resource ID, scalable dimension, and namespace, which represents some capacity * dimension of the underlying service.

When you register a new scalable * target, you must specify values for the minimum and maximum capacity. If the * specified resource is not active in the target service, this operation does not * change the resource's current capacity. Otherwise, it changes the resource's * current capacity to a value that is inside of this range.

If you add a * scaling policy, current capacity is adjustable within the specified range when * scaling starts. Application Auto Scaling scaling policies will not scale * capacity to values that are outside of the minimum and maximum range.

*

After you register a scalable target, you do not need to register it again to * use other Application Auto Scaling operations. To see which resources have been * registered, use DescribeScalableTargets. * You can also view the scaling policies for a service namespace by using DescribeScalableTargets. * If you no longer need a scalable target, you can deregister it by using DeregisterScalableTarget.

*

To update a scalable target, specify the parameters that you want to change. * Include the parameters that identify the scalable target: resource ID, scalable * dimension, and namespace. Any parameters that you don't specify are not changed * by this update request.

If you call the * RegisterScalableTarget API operation to create a scalable target, * there might be a brief delay until the operation achieves eventual * consistency. You might become aware of this brief delay if you get * unexpected errors when performing sequential operations. The typical strategy is * to retry the request, and some Amazon Web Services SDKs include automatic * backoff and retry logic.

If you call the * RegisterScalableTarget API operation to update an existing scalable * target, Application Auto Scaling retrieves the current capacity of the resource. * If it's below the minimum capacity or above the maximum capacity, Application * Auto Scaling adjusts the capacity of the scalable target to place it within * these bounds, even if you don't include the MinCapacity or * MaxCapacity request parameters.

See Also:

* AWS * API Reference

*/ virtual Model::RegisterScalableTargetOutcome RegisterScalableTarget(const Model::RegisterScalableTargetRequest& request) const; /** * A Callable wrapper for RegisterScalableTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterScalableTargetOutcomeCallable RegisterScalableTargetCallable(const RegisterScalableTargetRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::RegisterScalableTarget, request); } /** * An Async wrapper for RegisterScalableTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterScalableTargetAsync(const RegisterScalableTargetRequestT& request, const RegisterScalableTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::RegisterScalableTarget, request, handler, context); } /** *

Adds or edits tags on an Application Auto Scaling scalable target.

*

Each tag consists of a tag key and a tag value, which are both case-sensitive * strings. To add a tag, specify a new tag key and a tag value. To edit a tag, * specify an existing tag key and a new tag value.

You can use this * operation to tag an Application Auto Scaling scalable target, but you cannot tag * a scaling policy or scheduled action.

You can also add tags to an * Application Auto Scaling scalable target while creating it * (RegisterScalableTarget).

For general information about * tags, including the format and syntax, see Tagging * Amazon Web Services resources in the Amazon Web Services General * Reference.

Use tags to control access to a scalable target. For more * information, see Tagging * support for Application Auto Scaling in the Application Auto Scaling User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::TagResource, request, handler, context); } /** *

Deletes tags from an Application Auto Scaling scalable target. To delete a * tag, specify the tag key and the Application Auto Scaling scalable * target.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&ApplicationAutoScalingClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ApplicationAutoScalingClient::UntagResource, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ApplicationAutoScalingClientConfiguration& clientConfiguration); ApplicationAutoScalingClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace ApplicationAutoScaling } // namespace Aws