1 /** 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * SPDX-License-Identifier: Apache-2.0. 4 */ 5 6 #pragma once 7 #include <aws/ecs/ECS_EXPORTS.h> 8 #include <aws/ecs/ECSErrors.h> 9 #include <aws/core/client/AWSError.h> 10 #include <aws/core/client/ClientConfiguration.h> 11 #include <aws/core/client/AWSClient.h> 12 #include <aws/core/utils/memory/stl/AWSString.h> 13 #include <aws/core/utils/json/JsonSerializer.h> 14 #include <aws/ecs/model/CreateCapacityProviderResult.h> 15 #include <aws/ecs/model/CreateClusterResult.h> 16 #include <aws/ecs/model/CreateServiceResult.h> 17 #include <aws/ecs/model/CreateTaskSetResult.h> 18 #include <aws/ecs/model/DeleteAccountSettingResult.h> 19 #include <aws/ecs/model/DeleteAttributesResult.h> 20 #include <aws/ecs/model/DeleteCapacityProviderResult.h> 21 #include <aws/ecs/model/DeleteClusterResult.h> 22 #include <aws/ecs/model/DeleteServiceResult.h> 23 #include <aws/ecs/model/DeleteTaskSetResult.h> 24 #include <aws/ecs/model/DeregisterContainerInstanceResult.h> 25 #include <aws/ecs/model/DeregisterTaskDefinitionResult.h> 26 #include <aws/ecs/model/DescribeCapacityProvidersResult.h> 27 #include <aws/ecs/model/DescribeClustersResult.h> 28 #include <aws/ecs/model/DescribeContainerInstancesResult.h> 29 #include <aws/ecs/model/DescribeServicesResult.h> 30 #include <aws/ecs/model/DescribeTaskDefinitionResult.h> 31 #include <aws/ecs/model/DescribeTaskSetsResult.h> 32 #include <aws/ecs/model/DescribeTasksResult.h> 33 #include <aws/ecs/model/DiscoverPollEndpointResult.h> 34 #include <aws/ecs/model/ExecuteCommandResult.h> 35 #include <aws/ecs/model/ListAccountSettingsResult.h> 36 #include <aws/ecs/model/ListAttributesResult.h> 37 #include <aws/ecs/model/ListClustersResult.h> 38 #include <aws/ecs/model/ListContainerInstancesResult.h> 39 #include <aws/ecs/model/ListServicesResult.h> 40 #include <aws/ecs/model/ListTagsForResourceResult.h> 41 #include <aws/ecs/model/ListTaskDefinitionFamiliesResult.h> 42 #include <aws/ecs/model/ListTaskDefinitionsResult.h> 43 #include <aws/ecs/model/ListTasksResult.h> 44 #include <aws/ecs/model/PutAccountSettingResult.h> 45 #include <aws/ecs/model/PutAccountSettingDefaultResult.h> 46 #include <aws/ecs/model/PutAttributesResult.h> 47 #include <aws/ecs/model/PutClusterCapacityProvidersResult.h> 48 #include <aws/ecs/model/RegisterContainerInstanceResult.h> 49 #include <aws/ecs/model/RegisterTaskDefinitionResult.h> 50 #include <aws/ecs/model/RunTaskResult.h> 51 #include <aws/ecs/model/StartTaskResult.h> 52 #include <aws/ecs/model/StopTaskResult.h> 53 #include <aws/ecs/model/SubmitAttachmentStateChangesResult.h> 54 #include <aws/ecs/model/SubmitContainerStateChangeResult.h> 55 #include <aws/ecs/model/SubmitTaskStateChangeResult.h> 56 #include <aws/ecs/model/TagResourceResult.h> 57 #include <aws/ecs/model/UntagResourceResult.h> 58 #include <aws/ecs/model/UpdateCapacityProviderResult.h> 59 #include <aws/ecs/model/UpdateClusterResult.h> 60 #include <aws/ecs/model/UpdateClusterSettingsResult.h> 61 #include <aws/ecs/model/UpdateContainerAgentResult.h> 62 #include <aws/ecs/model/UpdateContainerInstancesStateResult.h> 63 #include <aws/ecs/model/UpdateServiceResult.h> 64 #include <aws/ecs/model/UpdateServicePrimaryTaskSetResult.h> 65 #include <aws/ecs/model/UpdateTaskSetResult.h> 66 #include <aws/core/client/AsyncCallerContext.h> 67 #include <aws/core/http/HttpTypes.h> 68 #include <future> 69 #include <functional> 70 71 namespace Aws 72 { 73 74 namespace Http 75 { 76 class HttpClient; 77 class HttpClientFactory; 78 } // namespace Http 79 80 namespace Utils 81 { 82 template< typename R, typename E> class Outcome; 83 namespace Threading 84 { 85 class Executor; 86 } // namespace Threading 87 } // namespace Utils 88 89 namespace Auth 90 { 91 class AWSCredentials; 92 class AWSCredentialsProvider; 93 } // namespace Auth 94 95 namespace Client 96 { 97 class RetryStrategy; 98 } // namespace Client 99 100 namespace ECS 101 { 102 103 namespace Model 104 { 105 class CreateCapacityProviderRequest; 106 class CreateClusterRequest; 107 class CreateServiceRequest; 108 class CreateTaskSetRequest; 109 class DeleteAccountSettingRequest; 110 class DeleteAttributesRequest; 111 class DeleteCapacityProviderRequest; 112 class DeleteClusterRequest; 113 class DeleteServiceRequest; 114 class DeleteTaskSetRequest; 115 class DeregisterContainerInstanceRequest; 116 class DeregisterTaskDefinitionRequest; 117 class DescribeCapacityProvidersRequest; 118 class DescribeClustersRequest; 119 class DescribeContainerInstancesRequest; 120 class DescribeServicesRequest; 121 class DescribeTaskDefinitionRequest; 122 class DescribeTaskSetsRequest; 123 class DescribeTasksRequest; 124 class DiscoverPollEndpointRequest; 125 class ExecuteCommandRequest; 126 class ListAccountSettingsRequest; 127 class ListAttributesRequest; 128 class ListClustersRequest; 129 class ListContainerInstancesRequest; 130 class ListServicesRequest; 131 class ListTagsForResourceRequest; 132 class ListTaskDefinitionFamiliesRequest; 133 class ListTaskDefinitionsRequest; 134 class ListTasksRequest; 135 class PutAccountSettingRequest; 136 class PutAccountSettingDefaultRequest; 137 class PutAttributesRequest; 138 class PutClusterCapacityProvidersRequest; 139 class RegisterContainerInstanceRequest; 140 class RegisterTaskDefinitionRequest; 141 class RunTaskRequest; 142 class StartTaskRequest; 143 class StopTaskRequest; 144 class SubmitAttachmentStateChangesRequest; 145 class SubmitContainerStateChangeRequest; 146 class SubmitTaskStateChangeRequest; 147 class TagResourceRequest; 148 class UntagResourceRequest; 149 class UpdateCapacityProviderRequest; 150 class UpdateClusterRequest; 151 class UpdateClusterSettingsRequest; 152 class UpdateContainerAgentRequest; 153 class UpdateContainerInstancesStateRequest; 154 class UpdateServiceRequest; 155 class UpdateServicePrimaryTaskSetRequest; 156 class UpdateTaskSetRequest; 157 158 typedef Aws::Utils::Outcome<CreateCapacityProviderResult, ECSError> CreateCapacityProviderOutcome; 159 typedef Aws::Utils::Outcome<CreateClusterResult, ECSError> CreateClusterOutcome; 160 typedef Aws::Utils::Outcome<CreateServiceResult, ECSError> CreateServiceOutcome; 161 typedef Aws::Utils::Outcome<CreateTaskSetResult, ECSError> CreateTaskSetOutcome; 162 typedef Aws::Utils::Outcome<DeleteAccountSettingResult, ECSError> DeleteAccountSettingOutcome; 163 typedef Aws::Utils::Outcome<DeleteAttributesResult, ECSError> DeleteAttributesOutcome; 164 typedef Aws::Utils::Outcome<DeleteCapacityProviderResult, ECSError> DeleteCapacityProviderOutcome; 165 typedef Aws::Utils::Outcome<DeleteClusterResult, ECSError> DeleteClusterOutcome; 166 typedef Aws::Utils::Outcome<DeleteServiceResult, ECSError> DeleteServiceOutcome; 167 typedef Aws::Utils::Outcome<DeleteTaskSetResult, ECSError> DeleteTaskSetOutcome; 168 typedef Aws::Utils::Outcome<DeregisterContainerInstanceResult, ECSError> DeregisterContainerInstanceOutcome; 169 typedef Aws::Utils::Outcome<DeregisterTaskDefinitionResult, ECSError> DeregisterTaskDefinitionOutcome; 170 typedef Aws::Utils::Outcome<DescribeCapacityProvidersResult, ECSError> DescribeCapacityProvidersOutcome; 171 typedef Aws::Utils::Outcome<DescribeClustersResult, ECSError> DescribeClustersOutcome; 172 typedef Aws::Utils::Outcome<DescribeContainerInstancesResult, ECSError> DescribeContainerInstancesOutcome; 173 typedef Aws::Utils::Outcome<DescribeServicesResult, ECSError> DescribeServicesOutcome; 174 typedef Aws::Utils::Outcome<DescribeTaskDefinitionResult, ECSError> DescribeTaskDefinitionOutcome; 175 typedef Aws::Utils::Outcome<DescribeTaskSetsResult, ECSError> DescribeTaskSetsOutcome; 176 typedef Aws::Utils::Outcome<DescribeTasksResult, ECSError> DescribeTasksOutcome; 177 typedef Aws::Utils::Outcome<DiscoverPollEndpointResult, ECSError> DiscoverPollEndpointOutcome; 178 typedef Aws::Utils::Outcome<ExecuteCommandResult, ECSError> ExecuteCommandOutcome; 179 typedef Aws::Utils::Outcome<ListAccountSettingsResult, ECSError> ListAccountSettingsOutcome; 180 typedef Aws::Utils::Outcome<ListAttributesResult, ECSError> ListAttributesOutcome; 181 typedef Aws::Utils::Outcome<ListClustersResult, ECSError> ListClustersOutcome; 182 typedef Aws::Utils::Outcome<ListContainerInstancesResult, ECSError> ListContainerInstancesOutcome; 183 typedef Aws::Utils::Outcome<ListServicesResult, ECSError> ListServicesOutcome; 184 typedef Aws::Utils::Outcome<ListTagsForResourceResult, ECSError> ListTagsForResourceOutcome; 185 typedef Aws::Utils::Outcome<ListTaskDefinitionFamiliesResult, ECSError> ListTaskDefinitionFamiliesOutcome; 186 typedef Aws::Utils::Outcome<ListTaskDefinitionsResult, ECSError> ListTaskDefinitionsOutcome; 187 typedef Aws::Utils::Outcome<ListTasksResult, ECSError> ListTasksOutcome; 188 typedef Aws::Utils::Outcome<PutAccountSettingResult, ECSError> PutAccountSettingOutcome; 189 typedef Aws::Utils::Outcome<PutAccountSettingDefaultResult, ECSError> PutAccountSettingDefaultOutcome; 190 typedef Aws::Utils::Outcome<PutAttributesResult, ECSError> PutAttributesOutcome; 191 typedef Aws::Utils::Outcome<PutClusterCapacityProvidersResult, ECSError> PutClusterCapacityProvidersOutcome; 192 typedef Aws::Utils::Outcome<RegisterContainerInstanceResult, ECSError> RegisterContainerInstanceOutcome; 193 typedef Aws::Utils::Outcome<RegisterTaskDefinitionResult, ECSError> RegisterTaskDefinitionOutcome; 194 typedef Aws::Utils::Outcome<RunTaskResult, ECSError> RunTaskOutcome; 195 typedef Aws::Utils::Outcome<StartTaskResult, ECSError> StartTaskOutcome; 196 typedef Aws::Utils::Outcome<StopTaskResult, ECSError> StopTaskOutcome; 197 typedef Aws::Utils::Outcome<SubmitAttachmentStateChangesResult, ECSError> SubmitAttachmentStateChangesOutcome; 198 typedef Aws::Utils::Outcome<SubmitContainerStateChangeResult, ECSError> SubmitContainerStateChangeOutcome; 199 typedef Aws::Utils::Outcome<SubmitTaskStateChangeResult, ECSError> SubmitTaskStateChangeOutcome; 200 typedef Aws::Utils::Outcome<TagResourceResult, ECSError> TagResourceOutcome; 201 typedef Aws::Utils::Outcome<UntagResourceResult, ECSError> UntagResourceOutcome; 202 typedef Aws::Utils::Outcome<UpdateCapacityProviderResult, ECSError> UpdateCapacityProviderOutcome; 203 typedef Aws::Utils::Outcome<UpdateClusterResult, ECSError> UpdateClusterOutcome; 204 typedef Aws::Utils::Outcome<UpdateClusterSettingsResult, ECSError> UpdateClusterSettingsOutcome; 205 typedef Aws::Utils::Outcome<UpdateContainerAgentResult, ECSError> UpdateContainerAgentOutcome; 206 typedef Aws::Utils::Outcome<UpdateContainerInstancesStateResult, ECSError> UpdateContainerInstancesStateOutcome; 207 typedef Aws::Utils::Outcome<UpdateServiceResult, ECSError> UpdateServiceOutcome; 208 typedef Aws::Utils::Outcome<UpdateServicePrimaryTaskSetResult, ECSError> UpdateServicePrimaryTaskSetOutcome; 209 typedef Aws::Utils::Outcome<UpdateTaskSetResult, ECSError> UpdateTaskSetOutcome; 210 211 typedef std::future<CreateCapacityProviderOutcome> CreateCapacityProviderOutcomeCallable; 212 typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable; 213 typedef std::future<CreateServiceOutcome> CreateServiceOutcomeCallable; 214 typedef std::future<CreateTaskSetOutcome> CreateTaskSetOutcomeCallable; 215 typedef std::future<DeleteAccountSettingOutcome> DeleteAccountSettingOutcomeCallable; 216 typedef std::future<DeleteAttributesOutcome> DeleteAttributesOutcomeCallable; 217 typedef std::future<DeleteCapacityProviderOutcome> DeleteCapacityProviderOutcomeCallable; 218 typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable; 219 typedef std::future<DeleteServiceOutcome> DeleteServiceOutcomeCallable; 220 typedef std::future<DeleteTaskSetOutcome> DeleteTaskSetOutcomeCallable; 221 typedef std::future<DeregisterContainerInstanceOutcome> DeregisterContainerInstanceOutcomeCallable; 222 typedef std::future<DeregisterTaskDefinitionOutcome> DeregisterTaskDefinitionOutcomeCallable; 223 typedef std::future<DescribeCapacityProvidersOutcome> DescribeCapacityProvidersOutcomeCallable; 224 typedef std::future<DescribeClustersOutcome> DescribeClustersOutcomeCallable; 225 typedef std::future<DescribeContainerInstancesOutcome> DescribeContainerInstancesOutcomeCallable; 226 typedef std::future<DescribeServicesOutcome> DescribeServicesOutcomeCallable; 227 typedef std::future<DescribeTaskDefinitionOutcome> DescribeTaskDefinitionOutcomeCallable; 228 typedef std::future<DescribeTaskSetsOutcome> DescribeTaskSetsOutcomeCallable; 229 typedef std::future<DescribeTasksOutcome> DescribeTasksOutcomeCallable; 230 typedef std::future<DiscoverPollEndpointOutcome> DiscoverPollEndpointOutcomeCallable; 231 typedef std::future<ExecuteCommandOutcome> ExecuteCommandOutcomeCallable; 232 typedef std::future<ListAccountSettingsOutcome> ListAccountSettingsOutcomeCallable; 233 typedef std::future<ListAttributesOutcome> ListAttributesOutcomeCallable; 234 typedef std::future<ListClustersOutcome> ListClustersOutcomeCallable; 235 typedef std::future<ListContainerInstancesOutcome> ListContainerInstancesOutcomeCallable; 236 typedef std::future<ListServicesOutcome> ListServicesOutcomeCallable; 237 typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable; 238 typedef std::future<ListTaskDefinitionFamiliesOutcome> ListTaskDefinitionFamiliesOutcomeCallable; 239 typedef std::future<ListTaskDefinitionsOutcome> ListTaskDefinitionsOutcomeCallable; 240 typedef std::future<ListTasksOutcome> ListTasksOutcomeCallable; 241 typedef std::future<PutAccountSettingOutcome> PutAccountSettingOutcomeCallable; 242 typedef std::future<PutAccountSettingDefaultOutcome> PutAccountSettingDefaultOutcomeCallable; 243 typedef std::future<PutAttributesOutcome> PutAttributesOutcomeCallable; 244 typedef std::future<PutClusterCapacityProvidersOutcome> PutClusterCapacityProvidersOutcomeCallable; 245 typedef std::future<RegisterContainerInstanceOutcome> RegisterContainerInstanceOutcomeCallable; 246 typedef std::future<RegisterTaskDefinitionOutcome> RegisterTaskDefinitionOutcomeCallable; 247 typedef std::future<RunTaskOutcome> RunTaskOutcomeCallable; 248 typedef std::future<StartTaskOutcome> StartTaskOutcomeCallable; 249 typedef std::future<StopTaskOutcome> StopTaskOutcomeCallable; 250 typedef std::future<SubmitAttachmentStateChangesOutcome> SubmitAttachmentStateChangesOutcomeCallable; 251 typedef std::future<SubmitContainerStateChangeOutcome> SubmitContainerStateChangeOutcomeCallable; 252 typedef std::future<SubmitTaskStateChangeOutcome> SubmitTaskStateChangeOutcomeCallable; 253 typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable; 254 typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable; 255 typedef std::future<UpdateCapacityProviderOutcome> UpdateCapacityProviderOutcomeCallable; 256 typedef std::future<UpdateClusterOutcome> UpdateClusterOutcomeCallable; 257 typedef std::future<UpdateClusterSettingsOutcome> UpdateClusterSettingsOutcomeCallable; 258 typedef std::future<UpdateContainerAgentOutcome> UpdateContainerAgentOutcomeCallable; 259 typedef std::future<UpdateContainerInstancesStateOutcome> UpdateContainerInstancesStateOutcomeCallable; 260 typedef std::future<UpdateServiceOutcome> UpdateServiceOutcomeCallable; 261 typedef std::future<UpdateServicePrimaryTaskSetOutcome> UpdateServicePrimaryTaskSetOutcomeCallable; 262 typedef std::future<UpdateTaskSetOutcome> UpdateTaskSetOutcomeCallable; 263 } // namespace Model 264 265 class ECSClient; 266 267 typedef std::function<void(const ECSClient*, const Model::CreateCapacityProviderRequest&, const Model::CreateCapacityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateCapacityProviderResponseReceivedHandler; 268 typedef std::function<void(const ECSClient*, const Model::CreateClusterRequest&, const Model::CreateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateClusterResponseReceivedHandler; 269 typedef std::function<void(const ECSClient*, const Model::CreateServiceRequest&, const Model::CreateServiceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateServiceResponseReceivedHandler; 270 typedef std::function<void(const ECSClient*, const Model::CreateTaskSetRequest&, const Model::CreateTaskSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateTaskSetResponseReceivedHandler; 271 typedef std::function<void(const ECSClient*, const Model::DeleteAccountSettingRequest&, const Model::DeleteAccountSettingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAccountSettingResponseReceivedHandler; 272 typedef std::function<void(const ECSClient*, const Model::DeleteAttributesRequest&, const Model::DeleteAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAttributesResponseReceivedHandler; 273 typedef std::function<void(const ECSClient*, const Model::DeleteCapacityProviderRequest&, const Model::DeleteCapacityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteCapacityProviderResponseReceivedHandler; 274 typedef std::function<void(const ECSClient*, const Model::DeleteClusterRequest&, const Model::DeleteClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteClusterResponseReceivedHandler; 275 typedef std::function<void(const ECSClient*, const Model::DeleteServiceRequest&, const Model::DeleteServiceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteServiceResponseReceivedHandler; 276 typedef std::function<void(const ECSClient*, const Model::DeleteTaskSetRequest&, const Model::DeleteTaskSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteTaskSetResponseReceivedHandler; 277 typedef std::function<void(const ECSClient*, const Model::DeregisterContainerInstanceRequest&, const Model::DeregisterContainerInstanceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterContainerInstanceResponseReceivedHandler; 278 typedef std::function<void(const ECSClient*, const Model::DeregisterTaskDefinitionRequest&, const Model::DeregisterTaskDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterTaskDefinitionResponseReceivedHandler; 279 typedef std::function<void(const ECSClient*, const Model::DescribeCapacityProvidersRequest&, const Model::DescribeCapacityProvidersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeCapacityProvidersResponseReceivedHandler; 280 typedef std::function<void(const ECSClient*, const Model::DescribeClustersRequest&, const Model::DescribeClustersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeClustersResponseReceivedHandler; 281 typedef std::function<void(const ECSClient*, const Model::DescribeContainerInstancesRequest&, const Model::DescribeContainerInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContainerInstancesResponseReceivedHandler; 282 typedef std::function<void(const ECSClient*, const Model::DescribeServicesRequest&, const Model::DescribeServicesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeServicesResponseReceivedHandler; 283 typedef std::function<void(const ECSClient*, const Model::DescribeTaskDefinitionRequest&, const Model::DescribeTaskDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTaskDefinitionResponseReceivedHandler; 284 typedef std::function<void(const ECSClient*, const Model::DescribeTaskSetsRequest&, const Model::DescribeTaskSetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTaskSetsResponseReceivedHandler; 285 typedef std::function<void(const ECSClient*, const Model::DescribeTasksRequest&, const Model::DescribeTasksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTasksResponseReceivedHandler; 286 typedef std::function<void(const ECSClient*, const Model::DiscoverPollEndpointRequest&, const Model::DiscoverPollEndpointOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DiscoverPollEndpointResponseReceivedHandler; 287 typedef std::function<void(const ECSClient*, const Model::ExecuteCommandRequest&, const Model::ExecuteCommandOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExecuteCommandResponseReceivedHandler; 288 typedef std::function<void(const ECSClient*, const Model::ListAccountSettingsRequest&, const Model::ListAccountSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListAccountSettingsResponseReceivedHandler; 289 typedef std::function<void(const ECSClient*, const Model::ListAttributesRequest&, const Model::ListAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListAttributesResponseReceivedHandler; 290 typedef std::function<void(const ECSClient*, const Model::ListClustersRequest&, const Model::ListClustersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListClustersResponseReceivedHandler; 291 typedef std::function<void(const ECSClient*, const Model::ListContainerInstancesRequest&, const Model::ListContainerInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContainerInstancesResponseReceivedHandler; 292 typedef std::function<void(const ECSClient*, const Model::ListServicesRequest&, const Model::ListServicesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServicesResponseReceivedHandler; 293 typedef std::function<void(const ECSClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler; 294 typedef std::function<void(const ECSClient*, const Model::ListTaskDefinitionFamiliesRequest&, const Model::ListTaskDefinitionFamiliesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTaskDefinitionFamiliesResponseReceivedHandler; 295 typedef std::function<void(const ECSClient*, const Model::ListTaskDefinitionsRequest&, const Model::ListTaskDefinitionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTaskDefinitionsResponseReceivedHandler; 296 typedef std::function<void(const ECSClient*, const Model::ListTasksRequest&, const Model::ListTasksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTasksResponseReceivedHandler; 297 typedef std::function<void(const ECSClient*, const Model::PutAccountSettingRequest&, const Model::PutAccountSettingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutAccountSettingResponseReceivedHandler; 298 typedef std::function<void(const ECSClient*, const Model::PutAccountSettingDefaultRequest&, const Model::PutAccountSettingDefaultOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutAccountSettingDefaultResponseReceivedHandler; 299 typedef std::function<void(const ECSClient*, const Model::PutAttributesRequest&, const Model::PutAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutAttributesResponseReceivedHandler; 300 typedef std::function<void(const ECSClient*, const Model::PutClusterCapacityProvidersRequest&, const Model::PutClusterCapacityProvidersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutClusterCapacityProvidersResponseReceivedHandler; 301 typedef std::function<void(const ECSClient*, const Model::RegisterContainerInstanceRequest&, const Model::RegisterContainerInstanceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterContainerInstanceResponseReceivedHandler; 302 typedef std::function<void(const ECSClient*, const Model::RegisterTaskDefinitionRequest&, const Model::RegisterTaskDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterTaskDefinitionResponseReceivedHandler; 303 typedef std::function<void(const ECSClient*, const Model::RunTaskRequest&, const Model::RunTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RunTaskResponseReceivedHandler; 304 typedef std::function<void(const ECSClient*, const Model::StartTaskRequest&, const Model::StartTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartTaskResponseReceivedHandler; 305 typedef std::function<void(const ECSClient*, const Model::StopTaskRequest&, const Model::StopTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopTaskResponseReceivedHandler; 306 typedef std::function<void(const ECSClient*, const Model::SubmitAttachmentStateChangesRequest&, const Model::SubmitAttachmentStateChangesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubmitAttachmentStateChangesResponseReceivedHandler; 307 typedef std::function<void(const ECSClient*, const Model::SubmitContainerStateChangeRequest&, const Model::SubmitContainerStateChangeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubmitContainerStateChangeResponseReceivedHandler; 308 typedef std::function<void(const ECSClient*, const Model::SubmitTaskStateChangeRequest&, const Model::SubmitTaskStateChangeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SubmitTaskStateChangeResponseReceivedHandler; 309 typedef std::function<void(const ECSClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler; 310 typedef std::function<void(const ECSClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler; 311 typedef std::function<void(const ECSClient*, const Model::UpdateCapacityProviderRequest&, const Model::UpdateCapacityProviderOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateCapacityProviderResponseReceivedHandler; 312 typedef std::function<void(const ECSClient*, const Model::UpdateClusterRequest&, const Model::UpdateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateClusterResponseReceivedHandler; 313 typedef std::function<void(const ECSClient*, const Model::UpdateClusterSettingsRequest&, const Model::UpdateClusterSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateClusterSettingsResponseReceivedHandler; 314 typedef std::function<void(const ECSClient*, const Model::UpdateContainerAgentRequest&, const Model::UpdateContainerAgentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContainerAgentResponseReceivedHandler; 315 typedef std::function<void(const ECSClient*, const Model::UpdateContainerInstancesStateRequest&, const Model::UpdateContainerInstancesStateOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContainerInstancesStateResponseReceivedHandler; 316 typedef std::function<void(const ECSClient*, const Model::UpdateServiceRequest&, const Model::UpdateServiceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateServiceResponseReceivedHandler; 317 typedef std::function<void(const ECSClient*, const Model::UpdateServicePrimaryTaskSetRequest&, const Model::UpdateServicePrimaryTaskSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateServicePrimaryTaskSetResponseReceivedHandler; 318 typedef std::function<void(const ECSClient*, const Model::UpdateTaskSetRequest&, const Model::UpdateTaskSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateTaskSetResponseReceivedHandler; 319 320 /** 321 * <fullname>Amazon Elastic Container Service</fullname> <p>Amazon Elastic 322 * Container Service (Amazon ECS) is a highly scalable, fast, container management 323 * service that makes it easy to run, stop, and manage Docker containers on a 324 * cluster. You can host your cluster on a serverless infrastructure that is 325 * managed by Amazon ECS by launching your services or tasks on Fargate. For more 326 * control, you can host your tasks on a cluster of Amazon Elastic Compute Cloud 327 * (Amazon EC2) instances that you manage.</p> <p>Amazon ECS makes it easy to 328 * launch and stop container-based applications with simple API calls, allows you 329 * to get the state of your cluster from a centralized service, and gives you 330 * access to many familiar Amazon EC2 features.</p> <p>You can use Amazon ECS to 331 * schedule the placement of containers across your cluster based on your resource 332 * needs, isolation policies, and availability requirements. Amazon ECS eliminates 333 * the need for you to operate your own cluster management and configuration 334 * management systems or worry about scaling your management infrastructure.</p> 335 */ 336 class AWS_ECS_API ECSClient : public Aws::Client::AWSJsonClient 337 { 338 public: 339 typedef Aws::Client::AWSJsonClient BASECLASS; 340 341 /** 342 * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config 343 * is not specified, it will be initialized to default values. 344 */ 345 ECSClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 346 347 /** 348 * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config 349 * is not specified, it will be initialized to default values. 350 */ 351 ECSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 352 353 /** 354 * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, 355 * the default http client factory will be used 356 */ 357 ECSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider, 358 const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 359 360 virtual ~ECSClient(); 361 362 363 /** 364 * <p>Creates a new capacity provider. Capacity providers are associated with an 365 * Amazon ECS cluster and are used in capacity provider strategies to facilitate 366 * cluster auto scaling.</p> <p>Only capacity providers using an Auto Scaling group 367 * can be created. Amazon ECS tasks on Fargate use the <code>FARGATE</code> and 368 * <code>FARGATE_SPOT</code> capacity providers which are already created and 369 * available to all accounts in Regions supported by Fargate.</p><p><h3>See 370 * Also:</h3> <a 371 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCapacityProvider">AWS 372 * API Reference</a></p> 373 */ 374 virtual Model::CreateCapacityProviderOutcome CreateCapacityProvider(const Model::CreateCapacityProviderRequest& request) const; 375 376 /** 377 * <p>Creates a new capacity provider. Capacity providers are associated with an 378 * Amazon ECS cluster and are used in capacity provider strategies to facilitate 379 * cluster auto scaling.</p> <p>Only capacity providers using an Auto Scaling group 380 * can be created. Amazon ECS tasks on Fargate use the <code>FARGATE</code> and 381 * <code>FARGATE_SPOT</code> capacity providers which are already created and 382 * available to all accounts in Regions supported by Fargate.</p><p><h3>See 383 * Also:</h3> <a 384 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCapacityProvider">AWS 385 * API Reference</a></p> 386 * 387 * returns a future to the operation so that it can be executed in parallel to other requests. 388 */ 389 virtual Model::CreateCapacityProviderOutcomeCallable CreateCapacityProviderCallable(const Model::CreateCapacityProviderRequest& request) const; 390 391 /** 392 * <p>Creates a new capacity provider. Capacity providers are associated with an 393 * Amazon ECS cluster and are used in capacity provider strategies to facilitate 394 * cluster auto scaling.</p> <p>Only capacity providers using an Auto Scaling group 395 * can be created. Amazon ECS tasks on Fargate use the <code>FARGATE</code> and 396 * <code>FARGATE_SPOT</code> capacity providers which are already created and 397 * available to all accounts in Regions supported by Fargate.</p><p><h3>See 398 * Also:</h3> <a 399 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCapacityProvider">AWS 400 * API Reference</a></p> 401 * 402 * Queues the request into a thread executor and triggers associated callback when operation has finished. 403 */ 404 virtual void CreateCapacityProviderAsync(const Model::CreateCapacityProviderRequest& request, const CreateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 405 406 /** 407 * <p>Creates a new Amazon ECS cluster. By default, your account receives a 408 * <code>default</code> cluster when you launch your first container instance. 409 * However, you can create your own cluster with a unique name with the 410 * <code>CreateCluster</code> action.</p> <p>When you call the 411 * <a>CreateCluster</a> API operation, Amazon ECS attempts to create the Amazon ECS 412 * service-linked role for your account so that required resources in other Amazon 413 * Web Services services can be managed on your behalf. However, if the IAM user 414 * that makes the call does not have permissions to create the service-linked role, 415 * it is not created. For more information, see <a 416 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using 417 * Service-Linked Roles for Amazon ECS</a> in the <i>Amazon Elastic Container 418 * Service Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 419 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCluster">AWS 420 * API Reference</a></p> 421 */ 422 virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const; 423 424 /** 425 * <p>Creates a new Amazon ECS cluster. By default, your account receives a 426 * <code>default</code> cluster when you launch your first container instance. 427 * However, you can create your own cluster with a unique name with the 428 * <code>CreateCluster</code> action.</p> <p>When you call the 429 * <a>CreateCluster</a> API operation, Amazon ECS attempts to create the Amazon ECS 430 * service-linked role for your account so that required resources in other Amazon 431 * Web Services services can be managed on your behalf. However, if the IAM user 432 * that makes the call does not have permissions to create the service-linked role, 433 * it is not created. For more information, see <a 434 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using 435 * Service-Linked Roles for Amazon ECS</a> in the <i>Amazon Elastic Container 436 * Service Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 437 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCluster">AWS 438 * API Reference</a></p> 439 * 440 * returns a future to the operation so that it can be executed in parallel to other requests. 441 */ 442 virtual Model::CreateClusterOutcomeCallable CreateClusterCallable(const Model::CreateClusterRequest& request) const; 443 444 /** 445 * <p>Creates a new Amazon ECS cluster. By default, your account receives a 446 * <code>default</code> cluster when you launch your first container instance. 447 * However, you can create your own cluster with a unique name with the 448 * <code>CreateCluster</code> action.</p> <p>When you call the 449 * <a>CreateCluster</a> API operation, Amazon ECS attempts to create the Amazon ECS 450 * service-linked role for your account so that required resources in other Amazon 451 * Web Services services can be managed on your behalf. However, if the IAM user 452 * that makes the call does not have permissions to create the service-linked role, 453 * it is not created. For more information, see <a 454 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using 455 * Service-Linked Roles for Amazon ECS</a> in the <i>Amazon Elastic Container 456 * Service Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 457 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCluster">AWS 458 * API Reference</a></p> 459 * 460 * Queues the request into a thread executor and triggers associated callback when operation has finished. 461 */ 462 virtual void CreateClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 463 464 /** 465 * <p>Runs and maintains a desired number of tasks from a specified task 466 * definition. If the number of tasks running in a service drops below the 467 * <code>desiredCount</code>, Amazon ECS runs another copy of the task in the 468 * specified cluster. To update an existing service, see the UpdateService 469 * action.</p> <p>In addition to maintaining the desired count of tasks in your 470 * service, you can optionally run your service behind one or more load balancers. 471 * The load balancers distribute traffic across the tasks that are associated with 472 * the service. For more information, see <a 473 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service 474 * Load Balancing</a> in the <i>Amazon Elastic Container Service Developer 475 * Guide</i>.</p> <p>Tasks for services that <i>do not</i> use a load balancer are 476 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 477 * services that <i>do</i> use a load balancer are considered healthy if they're in 478 * the <code>RUNNING</code> state and the container instance that they're hosted on 479 * is reported as healthy by the load balancer.</p> <p>There are two service 480 * scheduler strategies available:</p> <ul> <li> <p> <code>REPLICA</code> - The 481 * replica scheduling strategy places and maintains the desired number of tasks 482 * across your cluster. By default, the service scheduler spreads tasks across 483 * Availability Zones. You can use task placement strategies and constraints to 484 * customize task placement decisions. For more information, see <a 485 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 486 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 487 * Guide</i>.</p> </li> <li> <p> <code>DAEMON</code> - The daemon scheduling 488 * strategy deploys exactly one task on each active container instance that meets 489 * all of the task placement constraints that you specify in your cluster. The 490 * service scheduler also evaluates the task placement constraints for running 491 * tasks and will stop tasks that do not meet the placement constraints. When using 492 * this strategy, you don't need to specify a desired number of tasks, a task 493 * placement strategy, or use Service Auto Scaling policies. For more information, 494 * see <a 495 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 496 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 497 * Guide</i>.</p> </li> </ul> <p>You can optionally specify a deployment 498 * configuration for your service. The deployment is triggered by changing 499 * properties, such as the task definition or the desired count of a service, with 500 * an <a>UpdateService</a> operation. The default value for a replica service for 501 * <code>minimumHealthyPercent</code> is 100%. The default value for a daemon 502 * service for <code>minimumHealthyPercent</code> is 0%.</p> <p>If a service is 503 * using the <code>ECS</code> deployment controller, the minimum healthy percent 504 * represents a lower limit on the number of tasks in a service that must remain in 505 * the <code>RUNNING</code> state during a deployment, as a percentage of the 506 * desired number of tasks (rounded up to the nearest integer), and while any 507 * container instances are in the <code>DRAINING</code> state if the service 508 * contains tasks using the EC2 launch type. This parameter enables you to deploy 509 * without using additional cluster capacity. For example, if your service has a 510 * desired number of four tasks and a minimum healthy percent of 50%, the scheduler 511 * might stop two existing tasks to free up cluster capacity before starting two 512 * new tasks. Tasks for services that <i>do not</i> use a load balancer are 513 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 514 * services that <i>do</i> use a load balancer are considered healthy if they're in 515 * the <code>RUNNING</code> state and they're reported as healthy by the load 516 * balancer. The default value for minimum healthy percent is 100%.</p> <p>If a 517 * service is using the <code>ECS</code> deployment controller, the <b>maximum 518 * percent</b> parameter represents an upper limit on the number of tasks in a 519 * service that are allowed in the <code>RUNNING</code> or <code>PENDING</code> 520 * state during a deployment, as a percentage of the desired number of tasks 521 * (rounded down to the nearest integer), and while any container instances are in 522 * the <code>DRAINING</code> state if the service contains tasks using the EC2 523 * launch type. This parameter enables you to define the deployment batch size. For 524 * example, if your service has a desired number of four tasks and a maximum 525 * percent value of 200%, the scheduler may start four new tasks before stopping 526 * the four older tasks (provided that the cluster resources required to do this 527 * are available). The default value for maximum percent is 200%.</p> <p>If a 528 * service is using either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code> 529 * deployment controller types and tasks that use the EC2 launch type, the 530 * <b>minimum healthy percent</b> and <b>maximum percent</b> values are used only 531 * to define the lower and upper limit on the number of the tasks in the service 532 * that remain in the <code>RUNNING</code> state while the container instances are 533 * in the <code>DRAINING</code> state. If the tasks in the service use the Fargate 534 * launch type, the minimum healthy percent and maximum percent values aren't used, 535 * although they're currently visible when describing your service.</p> <p>When 536 * creating a service that uses the <code>EXTERNAL</code> deployment controller, 537 * you can specify only parameters that aren't controlled at the task set level. 538 * The only required parameter is the service name. You control your services using 539 * the <a>CreateTaskSet</a> operation. For more information, see <a 540 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 541 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 542 * Guide</i>.</p> <p>When the service scheduler launches new tasks, it determines 543 * task placement in your cluster using the following logic:</p> <ul> <li> 544 * <p>Determine which of the container instances in your cluster can support your 545 * service's task definition (for example, they have the required CPU, memory, 546 * ports, and container instance attributes).</p> </li> <li> <p>By default, the 547 * service scheduler attempts to balance tasks across Availability Zones in this 548 * manner (although you can choose a different placement strategy) with the 549 * <code>placementStrategy</code> parameter):</p> <ul> <li> <p>Sort the valid 550 * container instances, giving priority to instances that have the fewest number of 551 * running tasks for this service in their respective Availability Zone. For 552 * example, if zone A has one running service task and zones B and C each have 553 * zero, valid container instances in either zone B or C are considered optimal for 554 * placement.</p> </li> <li> <p>Place the new service task on a valid container 555 * instance in an optimal Availability Zone (based on the previous steps), favoring 556 * container instances with the fewest number of running tasks for this 557 * service.</p> </li> </ul> </li> </ul><p><h3>See Also:</h3> <a 558 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateService">AWS 559 * API Reference</a></p> 560 */ 561 virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const; 562 563 /** 564 * <p>Runs and maintains a desired number of tasks from a specified task 565 * definition. If the number of tasks running in a service drops below the 566 * <code>desiredCount</code>, Amazon ECS runs another copy of the task in the 567 * specified cluster. To update an existing service, see the UpdateService 568 * action.</p> <p>In addition to maintaining the desired count of tasks in your 569 * service, you can optionally run your service behind one or more load balancers. 570 * The load balancers distribute traffic across the tasks that are associated with 571 * the service. For more information, see <a 572 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service 573 * Load Balancing</a> in the <i>Amazon Elastic Container Service Developer 574 * Guide</i>.</p> <p>Tasks for services that <i>do not</i> use a load balancer are 575 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 576 * services that <i>do</i> use a load balancer are considered healthy if they're in 577 * the <code>RUNNING</code> state and the container instance that they're hosted on 578 * is reported as healthy by the load balancer.</p> <p>There are two service 579 * scheduler strategies available:</p> <ul> <li> <p> <code>REPLICA</code> - The 580 * replica scheduling strategy places and maintains the desired number of tasks 581 * across your cluster. By default, the service scheduler spreads tasks across 582 * Availability Zones. You can use task placement strategies and constraints to 583 * customize task placement decisions. For more information, see <a 584 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 585 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 586 * Guide</i>.</p> </li> <li> <p> <code>DAEMON</code> - The daemon scheduling 587 * strategy deploys exactly one task on each active container instance that meets 588 * all of the task placement constraints that you specify in your cluster. The 589 * service scheduler also evaluates the task placement constraints for running 590 * tasks and will stop tasks that do not meet the placement constraints. When using 591 * this strategy, you don't need to specify a desired number of tasks, a task 592 * placement strategy, or use Service Auto Scaling policies. For more information, 593 * see <a 594 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 595 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 596 * Guide</i>.</p> </li> </ul> <p>You can optionally specify a deployment 597 * configuration for your service. The deployment is triggered by changing 598 * properties, such as the task definition or the desired count of a service, with 599 * an <a>UpdateService</a> operation. The default value for a replica service for 600 * <code>minimumHealthyPercent</code> is 100%. The default value for a daemon 601 * service for <code>minimumHealthyPercent</code> is 0%.</p> <p>If a service is 602 * using the <code>ECS</code> deployment controller, the minimum healthy percent 603 * represents a lower limit on the number of tasks in a service that must remain in 604 * the <code>RUNNING</code> state during a deployment, as a percentage of the 605 * desired number of tasks (rounded up to the nearest integer), and while any 606 * container instances are in the <code>DRAINING</code> state if the service 607 * contains tasks using the EC2 launch type. This parameter enables you to deploy 608 * without using additional cluster capacity. For example, if your service has a 609 * desired number of four tasks and a minimum healthy percent of 50%, the scheduler 610 * might stop two existing tasks to free up cluster capacity before starting two 611 * new tasks. Tasks for services that <i>do not</i> use a load balancer are 612 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 613 * services that <i>do</i> use a load balancer are considered healthy if they're in 614 * the <code>RUNNING</code> state and they're reported as healthy by the load 615 * balancer. The default value for minimum healthy percent is 100%.</p> <p>If a 616 * service is using the <code>ECS</code> deployment controller, the <b>maximum 617 * percent</b> parameter represents an upper limit on the number of tasks in a 618 * service that are allowed in the <code>RUNNING</code> or <code>PENDING</code> 619 * state during a deployment, as a percentage of the desired number of tasks 620 * (rounded down to the nearest integer), and while any container instances are in 621 * the <code>DRAINING</code> state if the service contains tasks using the EC2 622 * launch type. This parameter enables you to define the deployment batch size. For 623 * example, if your service has a desired number of four tasks and a maximum 624 * percent value of 200%, the scheduler may start four new tasks before stopping 625 * the four older tasks (provided that the cluster resources required to do this 626 * are available). The default value for maximum percent is 200%.</p> <p>If a 627 * service is using either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code> 628 * deployment controller types and tasks that use the EC2 launch type, the 629 * <b>minimum healthy percent</b> and <b>maximum percent</b> values are used only 630 * to define the lower and upper limit on the number of the tasks in the service 631 * that remain in the <code>RUNNING</code> state while the container instances are 632 * in the <code>DRAINING</code> state. If the tasks in the service use the Fargate 633 * launch type, the minimum healthy percent and maximum percent values aren't used, 634 * although they're currently visible when describing your service.</p> <p>When 635 * creating a service that uses the <code>EXTERNAL</code> deployment controller, 636 * you can specify only parameters that aren't controlled at the task set level. 637 * The only required parameter is the service name. You control your services using 638 * the <a>CreateTaskSet</a> operation. For more information, see <a 639 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 640 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 641 * Guide</i>.</p> <p>When the service scheduler launches new tasks, it determines 642 * task placement in your cluster using the following logic:</p> <ul> <li> 643 * <p>Determine which of the container instances in your cluster can support your 644 * service's task definition (for example, they have the required CPU, memory, 645 * ports, and container instance attributes).</p> </li> <li> <p>By default, the 646 * service scheduler attempts to balance tasks across Availability Zones in this 647 * manner (although you can choose a different placement strategy) with the 648 * <code>placementStrategy</code> parameter):</p> <ul> <li> <p>Sort the valid 649 * container instances, giving priority to instances that have the fewest number of 650 * running tasks for this service in their respective Availability Zone. For 651 * example, if zone A has one running service task and zones B and C each have 652 * zero, valid container instances in either zone B or C are considered optimal for 653 * placement.</p> </li> <li> <p>Place the new service task on a valid container 654 * instance in an optimal Availability Zone (based on the previous steps), favoring 655 * container instances with the fewest number of running tasks for this 656 * service.</p> </li> </ul> </li> </ul><p><h3>See Also:</h3> <a 657 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateService">AWS 658 * API Reference</a></p> 659 * 660 * returns a future to the operation so that it can be executed in parallel to other requests. 661 */ 662 virtual Model::CreateServiceOutcomeCallable CreateServiceCallable(const Model::CreateServiceRequest& request) const; 663 664 /** 665 * <p>Runs and maintains a desired number of tasks from a specified task 666 * definition. If the number of tasks running in a service drops below the 667 * <code>desiredCount</code>, Amazon ECS runs another copy of the task in the 668 * specified cluster. To update an existing service, see the UpdateService 669 * action.</p> <p>In addition to maintaining the desired count of tasks in your 670 * service, you can optionally run your service behind one or more load balancers. 671 * The load balancers distribute traffic across the tasks that are associated with 672 * the service. For more information, see <a 673 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service 674 * Load Balancing</a> in the <i>Amazon Elastic Container Service Developer 675 * Guide</i>.</p> <p>Tasks for services that <i>do not</i> use a load balancer are 676 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 677 * services that <i>do</i> use a load balancer are considered healthy if they're in 678 * the <code>RUNNING</code> state and the container instance that they're hosted on 679 * is reported as healthy by the load balancer.</p> <p>There are two service 680 * scheduler strategies available:</p> <ul> <li> <p> <code>REPLICA</code> - The 681 * replica scheduling strategy places and maintains the desired number of tasks 682 * across your cluster. By default, the service scheduler spreads tasks across 683 * Availability Zones. You can use task placement strategies and constraints to 684 * customize task placement decisions. For more information, see <a 685 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 686 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 687 * Guide</i>.</p> </li> <li> <p> <code>DAEMON</code> - The daemon scheduling 688 * strategy deploys exactly one task on each active container instance that meets 689 * all of the task placement constraints that you specify in your cluster. The 690 * service scheduler also evaluates the task placement constraints for running 691 * tasks and will stop tasks that do not meet the placement constraints. When using 692 * this strategy, you don't need to specify a desired number of tasks, a task 693 * placement strategy, or use Service Auto Scaling policies. For more information, 694 * see <a 695 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service 696 * Scheduler Concepts</a> in the <i>Amazon Elastic Container Service Developer 697 * Guide</i>.</p> </li> </ul> <p>You can optionally specify a deployment 698 * configuration for your service. The deployment is triggered by changing 699 * properties, such as the task definition or the desired count of a service, with 700 * an <a>UpdateService</a> operation. The default value for a replica service for 701 * <code>minimumHealthyPercent</code> is 100%. The default value for a daemon 702 * service for <code>minimumHealthyPercent</code> is 0%.</p> <p>If a service is 703 * using the <code>ECS</code> deployment controller, the minimum healthy percent 704 * represents a lower limit on the number of tasks in a service that must remain in 705 * the <code>RUNNING</code> state during a deployment, as a percentage of the 706 * desired number of tasks (rounded up to the nearest integer), and while any 707 * container instances are in the <code>DRAINING</code> state if the service 708 * contains tasks using the EC2 launch type. This parameter enables you to deploy 709 * without using additional cluster capacity. For example, if your service has a 710 * desired number of four tasks and a minimum healthy percent of 50%, the scheduler 711 * might stop two existing tasks to free up cluster capacity before starting two 712 * new tasks. Tasks for services that <i>do not</i> use a load balancer are 713 * considered healthy if they're in the <code>RUNNING</code> state. Tasks for 714 * services that <i>do</i> use a load balancer are considered healthy if they're in 715 * the <code>RUNNING</code> state and they're reported as healthy by the load 716 * balancer. The default value for minimum healthy percent is 100%.</p> <p>If a 717 * service is using the <code>ECS</code> deployment controller, the <b>maximum 718 * percent</b> parameter represents an upper limit on the number of tasks in a 719 * service that are allowed in the <code>RUNNING</code> or <code>PENDING</code> 720 * state during a deployment, as a percentage of the desired number of tasks 721 * (rounded down to the nearest integer), and while any container instances are in 722 * the <code>DRAINING</code> state if the service contains tasks using the EC2 723 * launch type. This parameter enables you to define the deployment batch size. For 724 * example, if your service has a desired number of four tasks and a maximum 725 * percent value of 200%, the scheduler may start four new tasks before stopping 726 * the four older tasks (provided that the cluster resources required to do this 727 * are available). The default value for maximum percent is 200%.</p> <p>If a 728 * service is using either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code> 729 * deployment controller types and tasks that use the EC2 launch type, the 730 * <b>minimum healthy percent</b> and <b>maximum percent</b> values are used only 731 * to define the lower and upper limit on the number of the tasks in the service 732 * that remain in the <code>RUNNING</code> state while the container instances are 733 * in the <code>DRAINING</code> state. If the tasks in the service use the Fargate 734 * launch type, the minimum healthy percent and maximum percent values aren't used, 735 * although they're currently visible when describing your service.</p> <p>When 736 * creating a service that uses the <code>EXTERNAL</code> deployment controller, 737 * you can specify only parameters that aren't controlled at the task set level. 738 * The only required parameter is the service name. You control your services using 739 * the <a>CreateTaskSet</a> operation. For more information, see <a 740 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 741 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 742 * Guide</i>.</p> <p>When the service scheduler launches new tasks, it determines 743 * task placement in your cluster using the following logic:</p> <ul> <li> 744 * <p>Determine which of the container instances in your cluster can support your 745 * service's task definition (for example, they have the required CPU, memory, 746 * ports, and container instance attributes).</p> </li> <li> <p>By default, the 747 * service scheduler attempts to balance tasks across Availability Zones in this 748 * manner (although you can choose a different placement strategy) with the 749 * <code>placementStrategy</code> parameter):</p> <ul> <li> <p>Sort the valid 750 * container instances, giving priority to instances that have the fewest number of 751 * running tasks for this service in their respective Availability Zone. For 752 * example, if zone A has one running service task and zones B and C each have 753 * zero, valid container instances in either zone B or C are considered optimal for 754 * placement.</p> </li> <li> <p>Place the new service task on a valid container 755 * instance in an optimal Availability Zone (based on the previous steps), favoring 756 * container instances with the fewest number of running tasks for this 757 * service.</p> </li> </ul> </li> </ul><p><h3>See Also:</h3> <a 758 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateService">AWS 759 * API Reference</a></p> 760 * 761 * Queues the request into a thread executor and triggers associated callback when operation has finished. 762 */ 763 virtual void CreateServiceAsync(const Model::CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 764 765 /** 766 * <p>Create a task set in the specified cluster and service. This is used when a 767 * service uses the <code>EXTERNAL</code> deployment controller type. For more 768 * information, see <a 769 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 770 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 771 * Guide</i>.</p><p><h3>See Also:</h3> <a 772 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateTaskSet">AWS 773 * API Reference</a></p> 774 */ 775 virtual Model::CreateTaskSetOutcome CreateTaskSet(const Model::CreateTaskSetRequest& request) const; 776 777 /** 778 * <p>Create a task set in the specified cluster and service. This is used when a 779 * service uses the <code>EXTERNAL</code> deployment controller type. For more 780 * information, see <a 781 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 782 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 783 * Guide</i>.</p><p><h3>See Also:</h3> <a 784 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateTaskSet">AWS 785 * API Reference</a></p> 786 * 787 * returns a future to the operation so that it can be executed in parallel to other requests. 788 */ 789 virtual Model::CreateTaskSetOutcomeCallable CreateTaskSetCallable(const Model::CreateTaskSetRequest& request) const; 790 791 /** 792 * <p>Create a task set in the specified cluster and service. This is used when a 793 * service uses the <code>EXTERNAL</code> deployment controller type. For more 794 * information, see <a 795 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 796 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 797 * Guide</i>.</p><p><h3>See Also:</h3> <a 798 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateTaskSet">AWS 799 * API Reference</a></p> 800 * 801 * Queues the request into a thread executor and triggers associated callback when operation has finished. 802 */ 803 virtual void CreateTaskSetAsync(const Model::CreateTaskSetRequest& request, const CreateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 804 805 /** 806 * <p>Disables an account setting for a specified IAM user, IAM role, or the root 807 * user for an account.</p><p><h3>See Also:</h3> <a 808 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAccountSetting">AWS 809 * API Reference</a></p> 810 */ 811 virtual Model::DeleteAccountSettingOutcome DeleteAccountSetting(const Model::DeleteAccountSettingRequest& request) const; 812 813 /** 814 * <p>Disables an account setting for a specified IAM user, IAM role, or the root 815 * user for an account.</p><p><h3>See Also:</h3> <a 816 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAccountSetting">AWS 817 * API Reference</a></p> 818 * 819 * returns a future to the operation so that it can be executed in parallel to other requests. 820 */ 821 virtual Model::DeleteAccountSettingOutcomeCallable DeleteAccountSettingCallable(const Model::DeleteAccountSettingRequest& request) const; 822 823 /** 824 * <p>Disables an account setting for a specified IAM user, IAM role, or the root 825 * user for an account.</p><p><h3>See Also:</h3> <a 826 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAccountSetting">AWS 827 * API Reference</a></p> 828 * 829 * Queues the request into a thread executor and triggers associated callback when operation has finished. 830 */ 831 virtual void DeleteAccountSettingAsync(const Model::DeleteAccountSettingRequest& request, const DeleteAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 832 833 /** 834 * <p>Deletes one or more custom attributes from an Amazon ECS 835 * resource.</p><p><h3>See Also:</h3> <a 836 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAttributes">AWS 837 * API Reference</a></p> 838 */ 839 virtual Model::DeleteAttributesOutcome DeleteAttributes(const Model::DeleteAttributesRequest& request) const; 840 841 /** 842 * <p>Deletes one or more custom attributes from an Amazon ECS 843 * resource.</p><p><h3>See Also:</h3> <a 844 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAttributes">AWS 845 * API Reference</a></p> 846 * 847 * returns a future to the operation so that it can be executed in parallel to other requests. 848 */ 849 virtual Model::DeleteAttributesOutcomeCallable DeleteAttributesCallable(const Model::DeleteAttributesRequest& request) const; 850 851 /** 852 * <p>Deletes one or more custom attributes from an Amazon ECS 853 * resource.</p><p><h3>See Also:</h3> <a 854 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAttributes">AWS 855 * API Reference</a></p> 856 * 857 * Queues the request into a thread executor and triggers associated callback when operation has finished. 858 */ 859 virtual void DeleteAttributesAsync(const Model::DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 860 861 /** 862 * <p>Deletes the specified capacity provider.</p> <p>The 863 * <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers are 864 * reserved and cannot be deleted. You can disassociate them from a cluster using 865 * either the <a>PutClusterCapacityProviders</a> API or by deleting the 866 * cluster.</p> <p>Prior to a capacity provider being deleted, the capacity 867 * provider must be removed from the capacity provider strategy from all services. 868 * The <a>UpdateService</a> API can be used to remove a capacity provider from a 869 * service's capacity provider strategy. When updating a service, the 870 * <code>forceNewDeployment</code> option can be used to ensure that any tasks 871 * using the Amazon EC2 instance capacity provided by the capacity provider are 872 * transitioned to use the capacity from the remaining capacity providers. Only 873 * capacity providers that are not associated with a cluster can be deleted. To 874 * remove a capacity provider from a cluster, you can either use 875 * <a>PutClusterCapacityProviders</a> or delete the cluster.</p><p><h3>See 876 * Also:</h3> <a 877 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCapacityProvider">AWS 878 * API Reference</a></p> 879 */ 880 virtual Model::DeleteCapacityProviderOutcome DeleteCapacityProvider(const Model::DeleteCapacityProviderRequest& request) const; 881 882 /** 883 * <p>Deletes the specified capacity provider.</p> <p>The 884 * <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers are 885 * reserved and cannot be deleted. You can disassociate them from a cluster using 886 * either the <a>PutClusterCapacityProviders</a> API or by deleting the 887 * cluster.</p> <p>Prior to a capacity provider being deleted, the capacity 888 * provider must be removed from the capacity provider strategy from all services. 889 * The <a>UpdateService</a> API can be used to remove a capacity provider from a 890 * service's capacity provider strategy. When updating a service, the 891 * <code>forceNewDeployment</code> option can be used to ensure that any tasks 892 * using the Amazon EC2 instance capacity provided by the capacity provider are 893 * transitioned to use the capacity from the remaining capacity providers. Only 894 * capacity providers that are not associated with a cluster can be deleted. To 895 * remove a capacity provider from a cluster, you can either use 896 * <a>PutClusterCapacityProviders</a> or delete the cluster.</p><p><h3>See 897 * Also:</h3> <a 898 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCapacityProvider">AWS 899 * API Reference</a></p> 900 * 901 * returns a future to the operation so that it can be executed in parallel to other requests. 902 */ 903 virtual Model::DeleteCapacityProviderOutcomeCallable DeleteCapacityProviderCallable(const Model::DeleteCapacityProviderRequest& request) const; 904 905 /** 906 * <p>Deletes the specified capacity provider.</p> <p>The 907 * <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers are 908 * reserved and cannot be deleted. You can disassociate them from a cluster using 909 * either the <a>PutClusterCapacityProviders</a> API or by deleting the 910 * cluster.</p> <p>Prior to a capacity provider being deleted, the capacity 911 * provider must be removed from the capacity provider strategy from all services. 912 * The <a>UpdateService</a> API can be used to remove a capacity provider from a 913 * service's capacity provider strategy. When updating a service, the 914 * <code>forceNewDeployment</code> option can be used to ensure that any tasks 915 * using the Amazon EC2 instance capacity provided by the capacity provider are 916 * transitioned to use the capacity from the remaining capacity providers. Only 917 * capacity providers that are not associated with a cluster can be deleted. To 918 * remove a capacity provider from a cluster, you can either use 919 * <a>PutClusterCapacityProviders</a> or delete the cluster.</p><p><h3>See 920 * Also:</h3> <a 921 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCapacityProvider">AWS 922 * API Reference</a></p> 923 * 924 * Queues the request into a thread executor and triggers associated callback when operation has finished. 925 */ 926 virtual void DeleteCapacityProviderAsync(const Model::DeleteCapacityProviderRequest& request, const DeleteCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 927 928 /** 929 * <p>Deletes the specified cluster. The cluster will transition to the 930 * <code>INACTIVE</code> state. Clusters with an <code>INACTIVE</code> status may 931 * remain discoverable in your account for a period of time. However, this behavior 932 * is subject to change in the future, so you should not rely on 933 * <code>INACTIVE</code> clusters persisting.</p> <p>You must deregister all 934 * container instances from this cluster before you may delete it. You can list the 935 * container instances in a cluster with <a>ListContainerInstances</a> and 936 * deregister them with <a>DeregisterContainerInstance</a>.</p><p><h3>See 937 * Also:</h3> <a 938 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCluster">AWS 939 * API Reference</a></p> 940 */ 941 virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const; 942 943 /** 944 * <p>Deletes the specified cluster. The cluster will transition to the 945 * <code>INACTIVE</code> state. Clusters with an <code>INACTIVE</code> status may 946 * remain discoverable in your account for a period of time. However, this behavior 947 * is subject to change in the future, so you should not rely on 948 * <code>INACTIVE</code> clusters persisting.</p> <p>You must deregister all 949 * container instances from this cluster before you may delete it. You can list the 950 * container instances in a cluster with <a>ListContainerInstances</a> and 951 * deregister them with <a>DeregisterContainerInstance</a>.</p><p><h3>See 952 * Also:</h3> <a 953 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCluster">AWS 954 * API Reference</a></p> 955 * 956 * returns a future to the operation so that it can be executed in parallel to other requests. 957 */ 958 virtual Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const Model::DeleteClusterRequest& request) const; 959 960 /** 961 * <p>Deletes the specified cluster. The cluster will transition to the 962 * <code>INACTIVE</code> state. Clusters with an <code>INACTIVE</code> status may 963 * remain discoverable in your account for a period of time. However, this behavior 964 * is subject to change in the future, so you should not rely on 965 * <code>INACTIVE</code> clusters persisting.</p> <p>You must deregister all 966 * container instances from this cluster before you may delete it. You can list the 967 * container instances in a cluster with <a>ListContainerInstances</a> and 968 * deregister them with <a>DeregisterContainerInstance</a>.</p><p><h3>See 969 * Also:</h3> <a 970 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCluster">AWS 971 * API Reference</a></p> 972 * 973 * Queues the request into a thread executor and triggers associated callback when operation has finished. 974 */ 975 virtual void DeleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 976 977 /** 978 * <p>Deletes a specified service within a cluster. You can delete a service if you 979 * have no running tasks in it and the desired task count is zero. If the service 980 * is actively maintaining tasks, you cannot delete it, and you must update the 981 * service to a desired task count of zero. For more information, see 982 * <a>UpdateService</a>.</p> <p>When you delete a service, if there are 983 * still running tasks that require cleanup, the service status moves from 984 * <code>ACTIVE</code> to <code>DRAINING</code>, and the service is no longer 985 * visible in the console or in the <a>ListServices</a> API operation. After all 986 * tasks have transitioned to either <code>STOPPING</code> or <code>STOPPED</code> 987 * status, the service status moves from <code>DRAINING</code> to 988 * <code>INACTIVE</code>. Services in the <code>DRAINING</code> or 989 * <code>INACTIVE</code> status can still be viewed with the 990 * <a>DescribeServices</a> API operation. However, in the future, 991 * <code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS 992 * record keeping, and <a>DescribeServices</a> calls on those services return a 993 * <code>ServiceNotFoundException</code> error.</p> <p>If you 994 * attempt to create a new service with the same name as an existing service in 995 * either <code>ACTIVE</code> or <code>DRAINING</code> status, you receive an 996 * error.</p> <p><h3>See Also:</h3> <a 997 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteService">AWS 998 * API Reference</a></p> 999 */ 1000 virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const; 1001 1002 /** 1003 * <p>Deletes a specified service within a cluster. You can delete a service if you 1004 * have no running tasks in it and the desired task count is zero. If the service 1005 * is actively maintaining tasks, you cannot delete it, and you must update the 1006 * service to a desired task count of zero. For more information, see 1007 * <a>UpdateService</a>.</p> <p>When you delete a service, if there are 1008 * still running tasks that require cleanup, the service status moves from 1009 * <code>ACTIVE</code> to <code>DRAINING</code>, and the service is no longer 1010 * visible in the console or in the <a>ListServices</a> API operation. After all 1011 * tasks have transitioned to either <code>STOPPING</code> or <code>STOPPED</code> 1012 * status, the service status moves from <code>DRAINING</code> to 1013 * <code>INACTIVE</code>. Services in the <code>DRAINING</code> or 1014 * <code>INACTIVE</code> status can still be viewed with the 1015 * <a>DescribeServices</a> API operation. However, in the future, 1016 * <code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS 1017 * record keeping, and <a>DescribeServices</a> calls on those services return a 1018 * <code>ServiceNotFoundException</code> error.</p> <p>If you 1019 * attempt to create a new service with the same name as an existing service in 1020 * either <code>ACTIVE</code> or <code>DRAINING</code> status, you receive an 1021 * error.</p> <p><h3>See Also:</h3> <a 1022 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteService">AWS 1023 * API Reference</a></p> 1024 * 1025 * returns a future to the operation so that it can be executed in parallel to other requests. 1026 */ 1027 virtual Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const Model::DeleteServiceRequest& request) const; 1028 1029 /** 1030 * <p>Deletes a specified service within a cluster. You can delete a service if you 1031 * have no running tasks in it and the desired task count is zero. If the service 1032 * is actively maintaining tasks, you cannot delete it, and you must update the 1033 * service to a desired task count of zero. For more information, see 1034 * <a>UpdateService</a>.</p> <p>When you delete a service, if there are 1035 * still running tasks that require cleanup, the service status moves from 1036 * <code>ACTIVE</code> to <code>DRAINING</code>, and the service is no longer 1037 * visible in the console or in the <a>ListServices</a> API operation. After all 1038 * tasks have transitioned to either <code>STOPPING</code> or <code>STOPPED</code> 1039 * status, the service status moves from <code>DRAINING</code> to 1040 * <code>INACTIVE</code>. Services in the <code>DRAINING</code> or 1041 * <code>INACTIVE</code> status can still be viewed with the 1042 * <a>DescribeServices</a> API operation. However, in the future, 1043 * <code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS 1044 * record keeping, and <a>DescribeServices</a> calls on those services return a 1045 * <code>ServiceNotFoundException</code> error.</p> <p>If you 1046 * attempt to create a new service with the same name as an existing service in 1047 * either <code>ACTIVE</code> or <code>DRAINING</code> status, you receive an 1048 * error.</p> <p><h3>See Also:</h3> <a 1049 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteService">AWS 1050 * API Reference</a></p> 1051 * 1052 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1053 */ 1054 virtual void DeleteServiceAsync(const Model::DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1055 1056 /** 1057 * <p>Deletes a specified task set within a service. This is used when a service 1058 * uses the <code>EXTERNAL</code> deployment controller type. For more information, 1059 * see <a 1060 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1061 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1062 * Guide</i>.</p><p><h3>See Also:</h3> <a 1063 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteTaskSet">AWS 1064 * API Reference</a></p> 1065 */ 1066 virtual Model::DeleteTaskSetOutcome DeleteTaskSet(const Model::DeleteTaskSetRequest& request) const; 1067 1068 /** 1069 * <p>Deletes a specified task set within a service. This is used when a service 1070 * uses the <code>EXTERNAL</code> deployment controller type. For more information, 1071 * see <a 1072 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1073 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1074 * Guide</i>.</p><p><h3>See Also:</h3> <a 1075 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteTaskSet">AWS 1076 * API Reference</a></p> 1077 * 1078 * returns a future to the operation so that it can be executed in parallel to other requests. 1079 */ 1080 virtual Model::DeleteTaskSetOutcomeCallable DeleteTaskSetCallable(const Model::DeleteTaskSetRequest& request) const; 1081 1082 /** 1083 * <p>Deletes a specified task set within a service. This is used when a service 1084 * uses the <code>EXTERNAL</code> deployment controller type. For more information, 1085 * see <a 1086 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1087 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1088 * Guide</i>.</p><p><h3>See Also:</h3> <a 1089 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteTaskSet">AWS 1090 * API Reference</a></p> 1091 * 1092 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1093 */ 1094 virtual void DeleteTaskSetAsync(const Model::DeleteTaskSetRequest& request, const DeleteTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1095 1096 /** 1097 * <p>Deregisters an Amazon ECS container instance from the specified cluster. This 1098 * instance is no longer available to run tasks.</p> <p>If you intend to use the 1099 * container instance for some other purpose after deregistration, you should stop 1100 * all of the tasks running on the container instance before deregistration. That 1101 * prevents any orphaned tasks from consuming resources.</p> <p>Deregistering a 1102 * container instance removes the instance from a cluster, but it does not 1103 * terminate the EC2 instance. If you are finished using the instance, be sure to 1104 * terminate it in the Amazon EC2 console to stop billing.</p> <p>If you 1105 * terminate a running container instance, Amazon ECS automatically deregisters the 1106 * instance from your cluster (stopped container instances or instances with 1107 * disconnected agents are not automatically deregistered when terminated).</p> 1108 * <p><h3>See Also:</h3> <a 1109 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterContainerInstance">AWS 1110 * API Reference</a></p> 1111 */ 1112 virtual Model::DeregisterContainerInstanceOutcome DeregisterContainerInstance(const Model::DeregisterContainerInstanceRequest& request) const; 1113 1114 /** 1115 * <p>Deregisters an Amazon ECS container instance from the specified cluster. This 1116 * instance is no longer available to run tasks.</p> <p>If you intend to use the 1117 * container instance for some other purpose after deregistration, you should stop 1118 * all of the tasks running on the container instance before deregistration. That 1119 * prevents any orphaned tasks from consuming resources.</p> <p>Deregistering a 1120 * container instance removes the instance from a cluster, but it does not 1121 * terminate the EC2 instance. If you are finished using the instance, be sure to 1122 * terminate it in the Amazon EC2 console to stop billing.</p> <p>If you 1123 * terminate a running container instance, Amazon ECS automatically deregisters the 1124 * instance from your cluster (stopped container instances or instances with 1125 * disconnected agents are not automatically deregistered when terminated).</p> 1126 * <p><h3>See Also:</h3> <a 1127 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterContainerInstance">AWS 1128 * API Reference</a></p> 1129 * 1130 * returns a future to the operation so that it can be executed in parallel to other requests. 1131 */ 1132 virtual Model::DeregisterContainerInstanceOutcomeCallable DeregisterContainerInstanceCallable(const Model::DeregisterContainerInstanceRequest& request) const; 1133 1134 /** 1135 * <p>Deregisters an Amazon ECS container instance from the specified cluster. This 1136 * instance is no longer available to run tasks.</p> <p>If you intend to use the 1137 * container instance for some other purpose after deregistration, you should stop 1138 * all of the tasks running on the container instance before deregistration. That 1139 * prevents any orphaned tasks from consuming resources.</p> <p>Deregistering a 1140 * container instance removes the instance from a cluster, but it does not 1141 * terminate the EC2 instance. If you are finished using the instance, be sure to 1142 * terminate it in the Amazon EC2 console to stop billing.</p> <p>If you 1143 * terminate a running container instance, Amazon ECS automatically deregisters the 1144 * instance from your cluster (stopped container instances or instances with 1145 * disconnected agents are not automatically deregistered when terminated).</p> 1146 * <p><h3>See Also:</h3> <a 1147 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterContainerInstance">AWS 1148 * API Reference</a></p> 1149 * 1150 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1151 */ 1152 virtual void DeregisterContainerInstanceAsync(const Model::DeregisterContainerInstanceRequest& request, const DeregisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1153 1154 /** 1155 * <p>Deregisters the specified task definition by family and revision. Upon 1156 * deregistration, the task definition is marked as <code>INACTIVE</code>. Existing 1157 * tasks and services that reference an <code>INACTIVE</code> task definition 1158 * continue to run without disruption. Existing services that reference an 1159 * <code>INACTIVE</code> task definition can still scale up or down by modifying 1160 * the service's desired count.</p> <p>You cannot use an <code>INACTIVE</code> task 1161 * definition to run new tasks or create new services, and you cannot update an 1162 * existing service to reference an <code>INACTIVE</code> task definition. However, 1163 * there may be up to a 10-minute window following deregistration where these 1164 * restrictions have not yet taken effect.</p> <p>At this time, 1165 * <code>INACTIVE</code> task definitions remain discoverable in your account 1166 * indefinitely. However, this behavior is subject to change in the future, so you 1167 * should not rely on <code>INACTIVE</code> task definitions persisting beyond the 1168 * lifecycle of any associated tasks and services.</p> <p><h3>See Also:</h3> 1169 * <a 1170 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterTaskDefinition">AWS 1171 * API Reference</a></p> 1172 */ 1173 virtual Model::DeregisterTaskDefinitionOutcome DeregisterTaskDefinition(const Model::DeregisterTaskDefinitionRequest& request) const; 1174 1175 /** 1176 * <p>Deregisters the specified task definition by family and revision. Upon 1177 * deregistration, the task definition is marked as <code>INACTIVE</code>. Existing 1178 * tasks and services that reference an <code>INACTIVE</code> task definition 1179 * continue to run without disruption. Existing services that reference an 1180 * <code>INACTIVE</code> task definition can still scale up or down by modifying 1181 * the service's desired count.</p> <p>You cannot use an <code>INACTIVE</code> task 1182 * definition to run new tasks or create new services, and you cannot update an 1183 * existing service to reference an <code>INACTIVE</code> task definition. However, 1184 * there may be up to a 10-minute window following deregistration where these 1185 * restrictions have not yet taken effect.</p> <p>At this time, 1186 * <code>INACTIVE</code> task definitions remain discoverable in your account 1187 * indefinitely. However, this behavior is subject to change in the future, so you 1188 * should not rely on <code>INACTIVE</code> task definitions persisting beyond the 1189 * lifecycle of any associated tasks and services.</p> <p><h3>See Also:</h3> 1190 * <a 1191 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterTaskDefinition">AWS 1192 * API Reference</a></p> 1193 * 1194 * returns a future to the operation so that it can be executed in parallel to other requests. 1195 */ 1196 virtual Model::DeregisterTaskDefinitionOutcomeCallable DeregisterTaskDefinitionCallable(const Model::DeregisterTaskDefinitionRequest& request) const; 1197 1198 /** 1199 * <p>Deregisters the specified task definition by family and revision. Upon 1200 * deregistration, the task definition is marked as <code>INACTIVE</code>. Existing 1201 * tasks and services that reference an <code>INACTIVE</code> task definition 1202 * continue to run without disruption. Existing services that reference an 1203 * <code>INACTIVE</code> task definition can still scale up or down by modifying 1204 * the service's desired count.</p> <p>You cannot use an <code>INACTIVE</code> task 1205 * definition to run new tasks or create new services, and you cannot update an 1206 * existing service to reference an <code>INACTIVE</code> task definition. However, 1207 * there may be up to a 10-minute window following deregistration where these 1208 * restrictions have not yet taken effect.</p> <p>At this time, 1209 * <code>INACTIVE</code> task definitions remain discoverable in your account 1210 * indefinitely. However, this behavior is subject to change in the future, so you 1211 * should not rely on <code>INACTIVE</code> task definitions persisting beyond the 1212 * lifecycle of any associated tasks and services.</p> <p><h3>See Also:</h3> 1213 * <a 1214 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterTaskDefinition">AWS 1215 * API Reference</a></p> 1216 * 1217 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1218 */ 1219 virtual void DeregisterTaskDefinitionAsync(const Model::DeregisterTaskDefinitionRequest& request, const DeregisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1220 1221 /** 1222 * <p>Describes one or more of your capacity providers.</p><p><h3>See Also:</h3> 1223 * <a 1224 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeCapacityProviders">AWS 1225 * API Reference</a></p> 1226 */ 1227 virtual Model::DescribeCapacityProvidersOutcome DescribeCapacityProviders(const Model::DescribeCapacityProvidersRequest& request) const; 1228 1229 /** 1230 * <p>Describes one or more of your capacity providers.</p><p><h3>See Also:</h3> 1231 * <a 1232 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeCapacityProviders">AWS 1233 * API Reference</a></p> 1234 * 1235 * returns a future to the operation so that it can be executed in parallel to other requests. 1236 */ 1237 virtual Model::DescribeCapacityProvidersOutcomeCallable DescribeCapacityProvidersCallable(const Model::DescribeCapacityProvidersRequest& request) const; 1238 1239 /** 1240 * <p>Describes one or more of your capacity providers.</p><p><h3>See Also:</h3> 1241 * <a 1242 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeCapacityProviders">AWS 1243 * API Reference</a></p> 1244 * 1245 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1246 */ 1247 virtual void DescribeCapacityProvidersAsync(const Model::DescribeCapacityProvidersRequest& request, const DescribeCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1248 1249 /** 1250 * <p>Describes one or more of your clusters.</p><p><h3>See Also:</h3> <a 1251 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeClusters">AWS 1252 * API Reference</a></p> 1253 */ 1254 virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request) const; 1255 1256 /** 1257 * <p>Describes one or more of your clusters.</p><p><h3>See Also:</h3> <a 1258 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeClusters">AWS 1259 * API Reference</a></p> 1260 * 1261 * returns a future to the operation so that it can be executed in parallel to other requests. 1262 */ 1263 virtual Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const Model::DescribeClustersRequest& request) const; 1264 1265 /** 1266 * <p>Describes one or more of your clusters.</p><p><h3>See Also:</h3> <a 1267 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeClusters">AWS 1268 * API Reference</a></p> 1269 * 1270 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1271 */ 1272 virtual void DescribeClustersAsync(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1273 1274 /** 1275 * <p>Describes one or more container instances. Returns metadata about each 1276 * container instance requested.</p><p><h3>See Also:</h3> <a 1277 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeContainerInstances">AWS 1278 * API Reference</a></p> 1279 */ 1280 virtual Model::DescribeContainerInstancesOutcome DescribeContainerInstances(const Model::DescribeContainerInstancesRequest& request) const; 1281 1282 /** 1283 * <p>Describes one or more container instances. Returns metadata about each 1284 * container instance requested.</p><p><h3>See Also:</h3> <a 1285 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeContainerInstances">AWS 1286 * API Reference</a></p> 1287 * 1288 * returns a future to the operation so that it can be executed in parallel to other requests. 1289 */ 1290 virtual Model::DescribeContainerInstancesOutcomeCallable DescribeContainerInstancesCallable(const Model::DescribeContainerInstancesRequest& request) const; 1291 1292 /** 1293 * <p>Describes one or more container instances. Returns metadata about each 1294 * container instance requested.</p><p><h3>See Also:</h3> <a 1295 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeContainerInstances">AWS 1296 * API Reference</a></p> 1297 * 1298 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1299 */ 1300 virtual void DescribeContainerInstancesAsync(const Model::DescribeContainerInstancesRequest& request, const DescribeContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1301 1302 /** 1303 * <p>Describes the specified services running in your cluster.</p><p><h3>See 1304 * Also:</h3> <a 1305 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeServices">AWS 1306 * API Reference</a></p> 1307 */ 1308 virtual Model::DescribeServicesOutcome DescribeServices(const Model::DescribeServicesRequest& request) const; 1309 1310 /** 1311 * <p>Describes the specified services running in your cluster.</p><p><h3>See 1312 * Also:</h3> <a 1313 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeServices">AWS 1314 * API Reference</a></p> 1315 * 1316 * returns a future to the operation so that it can be executed in parallel to other requests. 1317 */ 1318 virtual Model::DescribeServicesOutcomeCallable DescribeServicesCallable(const Model::DescribeServicesRequest& request) const; 1319 1320 /** 1321 * <p>Describes the specified services running in your cluster.</p><p><h3>See 1322 * Also:</h3> <a 1323 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeServices">AWS 1324 * API Reference</a></p> 1325 * 1326 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1327 */ 1328 virtual void DescribeServicesAsync(const Model::DescribeServicesRequest& request, const DescribeServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1329 1330 /** 1331 * <p>Describes a task definition. You can specify a <code>family</code> and 1332 * <code>revision</code> to find information about a specific task definition, or 1333 * you can simply specify the family to find the latest <code>ACTIVE</code> 1334 * revision in that family.</p> <p>You can only describe 1335 * <code>INACTIVE</code> task definitions while an active task or service 1336 * references them.</p> <p><h3>See Also:</h3> <a 1337 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskDefinition">AWS 1338 * API Reference</a></p> 1339 */ 1340 virtual Model::DescribeTaskDefinitionOutcome DescribeTaskDefinition(const Model::DescribeTaskDefinitionRequest& request) const; 1341 1342 /** 1343 * <p>Describes a task definition. You can specify a <code>family</code> and 1344 * <code>revision</code> to find information about a specific task definition, or 1345 * you can simply specify the family to find the latest <code>ACTIVE</code> 1346 * revision in that family.</p> <p>You can only describe 1347 * <code>INACTIVE</code> task definitions while an active task or service 1348 * references them.</p> <p><h3>See Also:</h3> <a 1349 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskDefinition">AWS 1350 * API Reference</a></p> 1351 * 1352 * returns a future to the operation so that it can be executed in parallel to other requests. 1353 */ 1354 virtual Model::DescribeTaskDefinitionOutcomeCallable DescribeTaskDefinitionCallable(const Model::DescribeTaskDefinitionRequest& request) const; 1355 1356 /** 1357 * <p>Describes a task definition. You can specify a <code>family</code> and 1358 * <code>revision</code> to find information about a specific task definition, or 1359 * you can simply specify the family to find the latest <code>ACTIVE</code> 1360 * revision in that family.</p> <p>You can only describe 1361 * <code>INACTIVE</code> task definitions while an active task or service 1362 * references them.</p> <p><h3>See Also:</h3> <a 1363 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskDefinition">AWS 1364 * API Reference</a></p> 1365 * 1366 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1367 */ 1368 virtual void DescribeTaskDefinitionAsync(const Model::DescribeTaskDefinitionRequest& request, const DescribeTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1369 1370 /** 1371 * <p>Describes the task sets in the specified cluster and service. This is used 1372 * when a service uses the <code>EXTERNAL</code> deployment controller type. For 1373 * more information, see <a 1374 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1375 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1376 * Guide</i>.</p><p><h3>See Also:</h3> <a 1377 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskSets">AWS 1378 * API Reference</a></p> 1379 */ 1380 virtual Model::DescribeTaskSetsOutcome DescribeTaskSets(const Model::DescribeTaskSetsRequest& request) const; 1381 1382 /** 1383 * <p>Describes the task sets in the specified cluster and service. This is used 1384 * when a service uses the <code>EXTERNAL</code> deployment controller type. For 1385 * more information, see <a 1386 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1387 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1388 * Guide</i>.</p><p><h3>See Also:</h3> <a 1389 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskSets">AWS 1390 * API Reference</a></p> 1391 * 1392 * returns a future to the operation so that it can be executed in parallel to other requests. 1393 */ 1394 virtual Model::DescribeTaskSetsOutcomeCallable DescribeTaskSetsCallable(const Model::DescribeTaskSetsRequest& request) const; 1395 1396 /** 1397 * <p>Describes the task sets in the specified cluster and service. This is used 1398 * when a service uses the <code>EXTERNAL</code> deployment controller type. For 1399 * more information, see <a 1400 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 1401 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 1402 * Guide</i>.</p><p><h3>See Also:</h3> <a 1403 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskSets">AWS 1404 * API Reference</a></p> 1405 * 1406 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1407 */ 1408 virtual void DescribeTaskSetsAsync(const Model::DescribeTaskSetsRequest& request, const DescribeTaskSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1409 1410 /** 1411 * <p>Describes a specified task or tasks.</p><p><h3>See Also:</h3> <a 1412 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTasks">AWS 1413 * API Reference</a></p> 1414 */ 1415 virtual Model::DescribeTasksOutcome DescribeTasks(const Model::DescribeTasksRequest& request) const; 1416 1417 /** 1418 * <p>Describes a specified task or tasks.</p><p><h3>See Also:</h3> <a 1419 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTasks">AWS 1420 * API Reference</a></p> 1421 * 1422 * returns a future to the operation so that it can be executed in parallel to other requests. 1423 */ 1424 virtual Model::DescribeTasksOutcomeCallable DescribeTasksCallable(const Model::DescribeTasksRequest& request) const; 1425 1426 /** 1427 * <p>Describes a specified task or tasks.</p><p><h3>See Also:</h3> <a 1428 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTasks">AWS 1429 * API Reference</a></p> 1430 * 1431 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1432 */ 1433 virtual void DescribeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1434 1435 /** 1436 * <p>This action is only used by the Amazon ECS agent, and it is not 1437 * intended for use outside of the agent.</p> <p>Returns an endpoint for 1438 * the Amazon ECS agent to poll for updates.</p><p><h3>See Also:</h3> <a 1439 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DiscoverPollEndpoint">AWS 1440 * API Reference</a></p> 1441 */ 1442 virtual Model::DiscoverPollEndpointOutcome DiscoverPollEndpoint(const Model::DiscoverPollEndpointRequest& request) const; 1443 1444 /** 1445 * <p>This action is only used by the Amazon ECS agent, and it is not 1446 * intended for use outside of the agent.</p> <p>Returns an endpoint for 1447 * the Amazon ECS agent to poll for updates.</p><p><h3>See Also:</h3> <a 1448 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DiscoverPollEndpoint">AWS 1449 * API Reference</a></p> 1450 * 1451 * returns a future to the operation so that it can be executed in parallel to other requests. 1452 */ 1453 virtual Model::DiscoverPollEndpointOutcomeCallable DiscoverPollEndpointCallable(const Model::DiscoverPollEndpointRequest& request) const; 1454 1455 /** 1456 * <p>This action is only used by the Amazon ECS agent, and it is not 1457 * intended for use outside of the agent.</p> <p>Returns an endpoint for 1458 * the Amazon ECS agent to poll for updates.</p><p><h3>See Also:</h3> <a 1459 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DiscoverPollEndpoint">AWS 1460 * API Reference</a></p> 1461 * 1462 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1463 */ 1464 virtual void DiscoverPollEndpointAsync(const Model::DiscoverPollEndpointRequest& request, const DiscoverPollEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1465 1466 /** 1467 * <p>Runs a command remotely on a container within a task.</p><p><h3>See 1468 * Also:</h3> <a 1469 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ExecuteCommand">AWS 1470 * API Reference</a></p> 1471 */ 1472 virtual Model::ExecuteCommandOutcome ExecuteCommand(const Model::ExecuteCommandRequest& request) const; 1473 1474 /** 1475 * <p>Runs a command remotely on a container within a task.</p><p><h3>See 1476 * Also:</h3> <a 1477 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ExecuteCommand">AWS 1478 * API Reference</a></p> 1479 * 1480 * returns a future to the operation so that it can be executed in parallel to other requests. 1481 */ 1482 virtual Model::ExecuteCommandOutcomeCallable ExecuteCommandCallable(const Model::ExecuteCommandRequest& request) const; 1483 1484 /** 1485 * <p>Runs a command remotely on a container within a task.</p><p><h3>See 1486 * Also:</h3> <a 1487 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ExecuteCommand">AWS 1488 * API Reference</a></p> 1489 * 1490 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1491 */ 1492 virtual void ExecuteCommandAsync(const Model::ExecuteCommandRequest& request, const ExecuteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1493 1494 /** 1495 * <p>Lists the account settings for a specified principal.</p><p><h3>See 1496 * Also:</h3> <a 1497 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAccountSettings">AWS 1498 * API Reference</a></p> 1499 */ 1500 virtual Model::ListAccountSettingsOutcome ListAccountSettings(const Model::ListAccountSettingsRequest& request) const; 1501 1502 /** 1503 * <p>Lists the account settings for a specified principal.</p><p><h3>See 1504 * Also:</h3> <a 1505 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAccountSettings">AWS 1506 * API Reference</a></p> 1507 * 1508 * returns a future to the operation so that it can be executed in parallel to other requests. 1509 */ 1510 virtual Model::ListAccountSettingsOutcomeCallable ListAccountSettingsCallable(const Model::ListAccountSettingsRequest& request) const; 1511 1512 /** 1513 * <p>Lists the account settings for a specified principal.</p><p><h3>See 1514 * Also:</h3> <a 1515 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAccountSettings">AWS 1516 * API Reference</a></p> 1517 * 1518 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1519 */ 1520 virtual void ListAccountSettingsAsync(const Model::ListAccountSettingsRequest& request, const ListAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1521 1522 /** 1523 * <p>Lists the attributes for Amazon ECS resources within a specified target type 1524 * and cluster. When you specify a target type and cluster, 1525 * <code>ListAttributes</code> returns a list of attribute objects, one for each 1526 * attribute on each resource. You can filter the list of results to a single 1527 * attribute name to only return results that have that name. You can also filter 1528 * the results by attribute name and value, for example, to see which container 1529 * instances in a cluster are running a Linux AMI (<code>ecs.os-type=linux</code>). 1530 * </p><p><h3>See Also:</h3> <a 1531 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAttributes">AWS 1532 * API Reference</a></p> 1533 */ 1534 virtual Model::ListAttributesOutcome ListAttributes(const Model::ListAttributesRequest& request) const; 1535 1536 /** 1537 * <p>Lists the attributes for Amazon ECS resources within a specified target type 1538 * and cluster. When you specify a target type and cluster, 1539 * <code>ListAttributes</code> returns a list of attribute objects, one for each 1540 * attribute on each resource. You can filter the list of results to a single 1541 * attribute name to only return results that have that name. You can also filter 1542 * the results by attribute name and value, for example, to see which container 1543 * instances in a cluster are running a Linux AMI (<code>ecs.os-type=linux</code>). 1544 * </p><p><h3>See Also:</h3> <a 1545 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAttributes">AWS 1546 * API Reference</a></p> 1547 * 1548 * returns a future to the operation so that it can be executed in parallel to other requests. 1549 */ 1550 virtual Model::ListAttributesOutcomeCallable ListAttributesCallable(const Model::ListAttributesRequest& request) const; 1551 1552 /** 1553 * <p>Lists the attributes for Amazon ECS resources within a specified target type 1554 * and cluster. When you specify a target type and cluster, 1555 * <code>ListAttributes</code> returns a list of attribute objects, one for each 1556 * attribute on each resource. You can filter the list of results to a single 1557 * attribute name to only return results that have that name. You can also filter 1558 * the results by attribute name and value, for example, to see which container 1559 * instances in a cluster are running a Linux AMI (<code>ecs.os-type=linux</code>). 1560 * </p><p><h3>See Also:</h3> <a 1561 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAttributes">AWS 1562 * API Reference</a></p> 1563 * 1564 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1565 */ 1566 virtual void ListAttributesAsync(const Model::ListAttributesRequest& request, const ListAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1567 1568 /** 1569 * <p>Returns a list of existing clusters.</p><p><h3>See Also:</h3> <a 1570 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListClusters">AWS 1571 * API Reference</a></p> 1572 */ 1573 virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request) const; 1574 1575 /** 1576 * <p>Returns a list of existing clusters.</p><p><h3>See Also:</h3> <a 1577 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListClusters">AWS 1578 * API Reference</a></p> 1579 * 1580 * returns a future to the operation so that it can be executed in parallel to other requests. 1581 */ 1582 virtual Model::ListClustersOutcomeCallable ListClustersCallable(const Model::ListClustersRequest& request) const; 1583 1584 /** 1585 * <p>Returns a list of existing clusters.</p><p><h3>See Also:</h3> <a 1586 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListClusters">AWS 1587 * API Reference</a></p> 1588 * 1589 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1590 */ 1591 virtual void ListClustersAsync(const Model::ListClustersRequest& request, const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1592 1593 /** 1594 * <p>Returns a list of container instances in a specified cluster. You can filter 1595 * the results of a <code>ListContainerInstances</code> operation with cluster 1596 * query language statements inside the <code>filter</code> parameter. For more 1597 * information, see <a 1598 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster 1599 * Query Language</a> in the <i>Amazon Elastic Container Service Developer 1600 * Guide</i>.</p><p><h3>See Also:</h3> <a 1601 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListContainerInstances">AWS 1602 * API Reference</a></p> 1603 */ 1604 virtual Model::ListContainerInstancesOutcome ListContainerInstances(const Model::ListContainerInstancesRequest& request) const; 1605 1606 /** 1607 * <p>Returns a list of container instances in a specified cluster. You can filter 1608 * the results of a <code>ListContainerInstances</code> operation with cluster 1609 * query language statements inside the <code>filter</code> parameter. For more 1610 * information, see <a 1611 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster 1612 * Query Language</a> in the <i>Amazon Elastic Container Service Developer 1613 * Guide</i>.</p><p><h3>See Also:</h3> <a 1614 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListContainerInstances">AWS 1615 * API Reference</a></p> 1616 * 1617 * returns a future to the operation so that it can be executed in parallel to other requests. 1618 */ 1619 virtual Model::ListContainerInstancesOutcomeCallable ListContainerInstancesCallable(const Model::ListContainerInstancesRequest& request) const; 1620 1621 /** 1622 * <p>Returns a list of container instances in a specified cluster. You can filter 1623 * the results of a <code>ListContainerInstances</code> operation with cluster 1624 * query language statements inside the <code>filter</code> parameter. For more 1625 * information, see <a 1626 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster 1627 * Query Language</a> in the <i>Amazon Elastic Container Service Developer 1628 * Guide</i>.</p><p><h3>See Also:</h3> <a 1629 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListContainerInstances">AWS 1630 * API Reference</a></p> 1631 * 1632 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1633 */ 1634 virtual void ListContainerInstancesAsync(const Model::ListContainerInstancesRequest& request, const ListContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1635 1636 /** 1637 * <p>Returns a list of services. You can filter the results by cluster, launch 1638 * type, and scheduling strategy.</p><p><h3>See Also:</h3> <a 1639 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListServices">AWS 1640 * API Reference</a></p> 1641 */ 1642 virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request) const; 1643 1644 /** 1645 * <p>Returns a list of services. You can filter the results by cluster, launch 1646 * type, and scheduling strategy.</p><p><h3>See Also:</h3> <a 1647 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListServices">AWS 1648 * API Reference</a></p> 1649 * 1650 * returns a future to the operation so that it can be executed in parallel to other requests. 1651 */ 1652 virtual Model::ListServicesOutcomeCallable ListServicesCallable(const Model::ListServicesRequest& request) const; 1653 1654 /** 1655 * <p>Returns a list of services. You can filter the results by cluster, launch 1656 * type, and scheduling strategy.</p><p><h3>See Also:</h3> <a 1657 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListServices">AWS 1658 * API Reference</a></p> 1659 * 1660 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1661 */ 1662 virtual void ListServicesAsync(const Model::ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1663 1664 /** 1665 * <p>List the tags for an Amazon ECS resource.</p><p><h3>See Also:</h3> <a 1666 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTagsForResource">AWS 1667 * API Reference</a></p> 1668 */ 1669 virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; 1670 1671 /** 1672 * <p>List the tags for an Amazon ECS resource.</p><p><h3>See Also:</h3> <a 1673 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTagsForResource">AWS 1674 * API Reference</a></p> 1675 * 1676 * returns a future to the operation so that it can be executed in parallel to other requests. 1677 */ 1678 virtual Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const Model::ListTagsForResourceRequest& request) const; 1679 1680 /** 1681 * <p>List the tags for an Amazon ECS resource.</p><p><h3>See Also:</h3> <a 1682 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTagsForResource">AWS 1683 * API Reference</a></p> 1684 * 1685 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1686 */ 1687 virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1688 1689 /** 1690 * <p>Returns a list of task definition families that are registered to your 1691 * account (which may include task definition families that no longer have any 1692 * <code>ACTIVE</code> task definition revisions).</p> <p>You can filter out task 1693 * definition families that do not contain any <code>ACTIVE</code> task definition 1694 * revisions by setting the <code>status</code> parameter to <code>ACTIVE</code>. 1695 * You can also filter the results with the <code>familyPrefix</code> 1696 * parameter.</p><p><h3>See Also:</h3> <a 1697 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitionFamilies">AWS 1698 * API Reference</a></p> 1699 */ 1700 virtual Model::ListTaskDefinitionFamiliesOutcome ListTaskDefinitionFamilies(const Model::ListTaskDefinitionFamiliesRequest& request) const; 1701 1702 /** 1703 * <p>Returns a list of task definition families that are registered to your 1704 * account (which may include task definition families that no longer have any 1705 * <code>ACTIVE</code> task definition revisions).</p> <p>You can filter out task 1706 * definition families that do not contain any <code>ACTIVE</code> task definition 1707 * revisions by setting the <code>status</code> parameter to <code>ACTIVE</code>. 1708 * You can also filter the results with the <code>familyPrefix</code> 1709 * parameter.</p><p><h3>See Also:</h3> <a 1710 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitionFamilies">AWS 1711 * API Reference</a></p> 1712 * 1713 * returns a future to the operation so that it can be executed in parallel to other requests. 1714 */ 1715 virtual Model::ListTaskDefinitionFamiliesOutcomeCallable ListTaskDefinitionFamiliesCallable(const Model::ListTaskDefinitionFamiliesRequest& request) const; 1716 1717 /** 1718 * <p>Returns a list of task definition families that are registered to your 1719 * account (which may include task definition families that no longer have any 1720 * <code>ACTIVE</code> task definition revisions).</p> <p>You can filter out task 1721 * definition families that do not contain any <code>ACTIVE</code> task definition 1722 * revisions by setting the <code>status</code> parameter to <code>ACTIVE</code>. 1723 * You can also filter the results with the <code>familyPrefix</code> 1724 * parameter.</p><p><h3>See Also:</h3> <a 1725 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitionFamilies">AWS 1726 * API Reference</a></p> 1727 * 1728 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1729 */ 1730 virtual void ListTaskDefinitionFamiliesAsync(const Model::ListTaskDefinitionFamiliesRequest& request, const ListTaskDefinitionFamiliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1731 1732 /** 1733 * <p>Returns a list of task definitions that are registered to your account. You 1734 * can filter the results by family name with the <code>familyPrefix</code> 1735 * parameter or by status with the <code>status</code> parameter.</p><p><h3>See 1736 * Also:</h3> <a 1737 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitions">AWS 1738 * API Reference</a></p> 1739 */ 1740 virtual Model::ListTaskDefinitionsOutcome ListTaskDefinitions(const Model::ListTaskDefinitionsRequest& request) const; 1741 1742 /** 1743 * <p>Returns a list of task definitions that are registered to your account. You 1744 * can filter the results by family name with the <code>familyPrefix</code> 1745 * parameter or by status with the <code>status</code> parameter.</p><p><h3>See 1746 * Also:</h3> <a 1747 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitions">AWS 1748 * API Reference</a></p> 1749 * 1750 * returns a future to the operation so that it can be executed in parallel to other requests. 1751 */ 1752 virtual Model::ListTaskDefinitionsOutcomeCallable ListTaskDefinitionsCallable(const Model::ListTaskDefinitionsRequest& request) const; 1753 1754 /** 1755 * <p>Returns a list of task definitions that are registered to your account. You 1756 * can filter the results by family name with the <code>familyPrefix</code> 1757 * parameter or by status with the <code>status</code> parameter.</p><p><h3>See 1758 * Also:</h3> <a 1759 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitions">AWS 1760 * API Reference</a></p> 1761 * 1762 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1763 */ 1764 virtual void ListTaskDefinitionsAsync(const Model::ListTaskDefinitionsRequest& request, const ListTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1765 1766 /** 1767 * <p>Returns a list of tasks. You can filter the results by cluster, task 1768 * definition family, container instance, launch type, what IAM principal started 1769 * the task, or by the desired status of the task.</p> <p>Recently stopped tasks 1770 * might appear in the returned results. Currently, stopped tasks appear in the 1771 * returned results for at least one hour.</p><p><h3>See Also:</h3> <a 1772 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTasks">AWS API 1773 * Reference</a></p> 1774 */ 1775 virtual Model::ListTasksOutcome ListTasks(const Model::ListTasksRequest& request) const; 1776 1777 /** 1778 * <p>Returns a list of tasks. You can filter the results by cluster, task 1779 * definition family, container instance, launch type, what IAM principal started 1780 * the task, or by the desired status of the task.</p> <p>Recently stopped tasks 1781 * might appear in the returned results. Currently, stopped tasks appear in the 1782 * returned results for at least one hour.</p><p><h3>See Also:</h3> <a 1783 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTasks">AWS API 1784 * Reference</a></p> 1785 * 1786 * returns a future to the operation so that it can be executed in parallel to other requests. 1787 */ 1788 virtual Model::ListTasksOutcomeCallable ListTasksCallable(const Model::ListTasksRequest& request) const; 1789 1790 /** 1791 * <p>Returns a list of tasks. You can filter the results by cluster, task 1792 * definition family, container instance, launch type, what IAM principal started 1793 * the task, or by the desired status of the task.</p> <p>Recently stopped tasks 1794 * might appear in the returned results. Currently, stopped tasks appear in the 1795 * returned results for at least one hour.</p><p><h3>See Also:</h3> <a 1796 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTasks">AWS API 1797 * Reference</a></p> 1798 * 1799 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1800 */ 1801 virtual void ListTasksAsync(const Model::ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1802 1803 /** 1804 * <p>Modifies an account setting. Account settings are set on a per-Region 1805 * basis.</p> <p>If you change the account setting for the root user, the default 1806 * settings for all of the IAM users and roles for which no individual account 1807 * setting has been specified are reset. For more information, see <a 1808 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html">Account 1809 * Settings</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1810 * <p>When <code>serviceLongArnFormat</code>, <code>taskLongArnFormat</code>, or 1811 * <code>containerInstanceLongArnFormat</code> are specified, the Amazon Resource 1812 * Name (ARN) and resource ID format of the resource type for a specified IAM user, 1813 * IAM role, or the root user for an account is affected. The opt-in and opt-out 1814 * account setting must be set for each Amazon ECS resource separately. The ARN and 1815 * resource ID format of a resource will be defined by the opt-in status of the IAM 1816 * user or role that created the resource. You must enable this setting to use 1817 * Amazon ECS features such as resource tagging.</p> <p>When 1818 * <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI) 1819 * limit for any new container instances that support the feature is changed. If 1820 * <code>awsvpcTrunking</code> is enabled, any new container instances that support 1821 * the feature are launched have the increased ENI limits available to them. For 1822 * more information, see <a 1823 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html">Elastic 1824 * Network Interface Trunking</a> in the <i>Amazon Elastic Container Service 1825 * Developer Guide</i>.</p> <p>When <code>containerInsights</code> is specified, 1826 * the default setting indicating whether CloudWatch Container Insights is enabled 1827 * for your clusters is changed. If <code>containerInsights</code> is enabled, any 1828 * new clusters that are created will have Container Insights enabled unless you 1829 * disable it during cluster creation. For more information, see <a 1830 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html">CloudWatch 1831 * Container Insights</a> in the <i>Amazon Elastic Container Service Developer 1832 * Guide</i>.</p><p><h3>See Also:</h3> <a 1833 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSetting">AWS 1834 * API Reference</a></p> 1835 */ 1836 virtual Model::PutAccountSettingOutcome PutAccountSetting(const Model::PutAccountSettingRequest& request) const; 1837 1838 /** 1839 * <p>Modifies an account setting. Account settings are set on a per-Region 1840 * basis.</p> <p>If you change the account setting for the root user, the default 1841 * settings for all of the IAM users and roles for which no individual account 1842 * setting has been specified are reset. For more information, see <a 1843 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html">Account 1844 * Settings</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1845 * <p>When <code>serviceLongArnFormat</code>, <code>taskLongArnFormat</code>, or 1846 * <code>containerInstanceLongArnFormat</code> are specified, the Amazon Resource 1847 * Name (ARN) and resource ID format of the resource type for a specified IAM user, 1848 * IAM role, or the root user for an account is affected. The opt-in and opt-out 1849 * account setting must be set for each Amazon ECS resource separately. The ARN and 1850 * resource ID format of a resource will be defined by the opt-in status of the IAM 1851 * user or role that created the resource. You must enable this setting to use 1852 * Amazon ECS features such as resource tagging.</p> <p>When 1853 * <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI) 1854 * limit for any new container instances that support the feature is changed. If 1855 * <code>awsvpcTrunking</code> is enabled, any new container instances that support 1856 * the feature are launched have the increased ENI limits available to them. For 1857 * more information, see <a 1858 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html">Elastic 1859 * Network Interface Trunking</a> in the <i>Amazon Elastic Container Service 1860 * Developer Guide</i>.</p> <p>When <code>containerInsights</code> is specified, 1861 * the default setting indicating whether CloudWatch Container Insights is enabled 1862 * for your clusters is changed. If <code>containerInsights</code> is enabled, any 1863 * new clusters that are created will have Container Insights enabled unless you 1864 * disable it during cluster creation. For more information, see <a 1865 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html">CloudWatch 1866 * Container Insights</a> in the <i>Amazon Elastic Container Service Developer 1867 * Guide</i>.</p><p><h3>See Also:</h3> <a 1868 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSetting">AWS 1869 * API Reference</a></p> 1870 * 1871 * returns a future to the operation so that it can be executed in parallel to other requests. 1872 */ 1873 virtual Model::PutAccountSettingOutcomeCallable PutAccountSettingCallable(const Model::PutAccountSettingRequest& request) const; 1874 1875 /** 1876 * <p>Modifies an account setting. Account settings are set on a per-Region 1877 * basis.</p> <p>If you change the account setting for the root user, the default 1878 * settings for all of the IAM users and roles for which no individual account 1879 * setting has been specified are reset. For more information, see <a 1880 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html">Account 1881 * Settings</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 1882 * <p>When <code>serviceLongArnFormat</code>, <code>taskLongArnFormat</code>, or 1883 * <code>containerInstanceLongArnFormat</code> are specified, the Amazon Resource 1884 * Name (ARN) and resource ID format of the resource type for a specified IAM user, 1885 * IAM role, or the root user for an account is affected. The opt-in and opt-out 1886 * account setting must be set for each Amazon ECS resource separately. The ARN and 1887 * resource ID format of a resource will be defined by the opt-in status of the IAM 1888 * user or role that created the resource. You must enable this setting to use 1889 * Amazon ECS features such as resource tagging.</p> <p>When 1890 * <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI) 1891 * limit for any new container instances that support the feature is changed. If 1892 * <code>awsvpcTrunking</code> is enabled, any new container instances that support 1893 * the feature are launched have the increased ENI limits available to them. For 1894 * more information, see <a 1895 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html">Elastic 1896 * Network Interface Trunking</a> in the <i>Amazon Elastic Container Service 1897 * Developer Guide</i>.</p> <p>When <code>containerInsights</code> is specified, 1898 * the default setting indicating whether CloudWatch Container Insights is enabled 1899 * for your clusters is changed. If <code>containerInsights</code> is enabled, any 1900 * new clusters that are created will have Container Insights enabled unless you 1901 * disable it during cluster creation. For more information, see <a 1902 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html">CloudWatch 1903 * Container Insights</a> in the <i>Amazon Elastic Container Service Developer 1904 * Guide</i>.</p><p><h3>See Also:</h3> <a 1905 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSetting">AWS 1906 * API Reference</a></p> 1907 * 1908 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1909 */ 1910 virtual void PutAccountSettingAsync(const Model::PutAccountSettingRequest& request, const PutAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1911 1912 /** 1913 * <p>Modifies an account setting for all IAM users on an account for whom no 1914 * individual account setting has been specified. Account settings are set on a 1915 * per-Region basis.</p><p><h3>See Also:</h3> <a 1916 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSettingDefault">AWS 1917 * API Reference</a></p> 1918 */ 1919 virtual Model::PutAccountSettingDefaultOutcome PutAccountSettingDefault(const Model::PutAccountSettingDefaultRequest& request) const; 1920 1921 /** 1922 * <p>Modifies an account setting for all IAM users on an account for whom no 1923 * individual account setting has been specified. Account settings are set on a 1924 * per-Region basis.</p><p><h3>See Also:</h3> <a 1925 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSettingDefault">AWS 1926 * API Reference</a></p> 1927 * 1928 * returns a future to the operation so that it can be executed in parallel to other requests. 1929 */ 1930 virtual Model::PutAccountSettingDefaultOutcomeCallable PutAccountSettingDefaultCallable(const Model::PutAccountSettingDefaultRequest& request) const; 1931 1932 /** 1933 * <p>Modifies an account setting for all IAM users on an account for whom no 1934 * individual account setting has been specified. Account settings are set on a 1935 * per-Region basis.</p><p><h3>See Also:</h3> <a 1936 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAccountSettingDefault">AWS 1937 * API Reference</a></p> 1938 * 1939 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1940 */ 1941 virtual void PutAccountSettingDefaultAsync(const Model::PutAccountSettingDefaultRequest& request, const PutAccountSettingDefaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1942 1943 /** 1944 * <p>Create or update an attribute on an Amazon ECS resource. If the attribute 1945 * does not exist, it is created. If the attribute exists, its value is replaced 1946 * with the specified value. To delete an attribute, use <a>DeleteAttributes</a>. 1947 * For more information, see <a 1948 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes">Attributes</a> 1949 * in the <i>Amazon Elastic Container Service Developer Guide</i>.</p><p><h3>See 1950 * Also:</h3> <a 1951 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAttributes">AWS 1952 * API Reference</a></p> 1953 */ 1954 virtual Model::PutAttributesOutcome PutAttributes(const Model::PutAttributesRequest& request) const; 1955 1956 /** 1957 * <p>Create or update an attribute on an Amazon ECS resource. If the attribute 1958 * does not exist, it is created. If the attribute exists, its value is replaced 1959 * with the specified value. To delete an attribute, use <a>DeleteAttributes</a>. 1960 * For more information, see <a 1961 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes">Attributes</a> 1962 * in the <i>Amazon Elastic Container Service Developer Guide</i>.</p><p><h3>See 1963 * Also:</h3> <a 1964 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAttributes">AWS 1965 * API Reference</a></p> 1966 * 1967 * returns a future to the operation so that it can be executed in parallel to other requests. 1968 */ 1969 virtual Model::PutAttributesOutcomeCallable PutAttributesCallable(const Model::PutAttributesRequest& request) const; 1970 1971 /** 1972 * <p>Create or update an attribute on an Amazon ECS resource. If the attribute 1973 * does not exist, it is created. If the attribute exists, its value is replaced 1974 * with the specified value. To delete an attribute, use <a>DeleteAttributes</a>. 1975 * For more information, see <a 1976 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes">Attributes</a> 1977 * in the <i>Amazon Elastic Container Service Developer Guide</i>.</p><p><h3>See 1978 * Also:</h3> <a 1979 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAttributes">AWS 1980 * API Reference</a></p> 1981 * 1982 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1983 */ 1984 virtual void PutAttributesAsync(const Model::PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1985 1986 /** 1987 * <p>Modifies the available capacity providers and the default capacity provider 1988 * strategy for a cluster.</p> <p>You must specify both the available capacity 1989 * providers and a default capacity provider strategy for the cluster. If the 1990 * specified cluster has existing capacity providers associated with it, you must 1991 * specify all existing capacity providers in addition to any new ones you want to 1992 * add. Any existing capacity providers associated with a cluster that are omitted 1993 * from a <a>PutClusterCapacityProviders</a> API call will be disassociated with 1994 * the cluster. You can only disassociate an existing capacity provider from a 1995 * cluster if it's not being used by any existing tasks.</p> <p>When creating a 1996 * service or running a task on a cluster, if no capacity provider or launch type 1997 * is specified, then the cluster's default capacity provider strategy is used. It 1998 * is recommended to define a default capacity provider strategy for your cluster, 1999 * however you may specify an empty array (<code>[]</code>) to bypass defining a 2000 * default strategy.</p><p><h3>See Also:</h3> <a 2001 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutClusterCapacityProviders">AWS 2002 * API Reference</a></p> 2003 */ 2004 virtual Model::PutClusterCapacityProvidersOutcome PutClusterCapacityProviders(const Model::PutClusterCapacityProvidersRequest& request) const; 2005 2006 /** 2007 * <p>Modifies the available capacity providers and the default capacity provider 2008 * strategy for a cluster.</p> <p>You must specify both the available capacity 2009 * providers and a default capacity provider strategy for the cluster. If the 2010 * specified cluster has existing capacity providers associated with it, you must 2011 * specify all existing capacity providers in addition to any new ones you want to 2012 * add. Any existing capacity providers associated with a cluster that are omitted 2013 * from a <a>PutClusterCapacityProviders</a> API call will be disassociated with 2014 * the cluster. You can only disassociate an existing capacity provider from a 2015 * cluster if it's not being used by any existing tasks.</p> <p>When creating a 2016 * service or running a task on a cluster, if no capacity provider or launch type 2017 * is specified, then the cluster's default capacity provider strategy is used. It 2018 * is recommended to define a default capacity provider strategy for your cluster, 2019 * however you may specify an empty array (<code>[]</code>) to bypass defining a 2020 * default strategy.</p><p><h3>See Also:</h3> <a 2021 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutClusterCapacityProviders">AWS 2022 * API Reference</a></p> 2023 * 2024 * returns a future to the operation so that it can be executed in parallel to other requests. 2025 */ 2026 virtual Model::PutClusterCapacityProvidersOutcomeCallable PutClusterCapacityProvidersCallable(const Model::PutClusterCapacityProvidersRequest& request) const; 2027 2028 /** 2029 * <p>Modifies the available capacity providers and the default capacity provider 2030 * strategy for a cluster.</p> <p>You must specify both the available capacity 2031 * providers and a default capacity provider strategy for the cluster. If the 2032 * specified cluster has existing capacity providers associated with it, you must 2033 * specify all existing capacity providers in addition to any new ones you want to 2034 * add. Any existing capacity providers associated with a cluster that are omitted 2035 * from a <a>PutClusterCapacityProviders</a> API call will be disassociated with 2036 * the cluster. You can only disassociate an existing capacity provider from a 2037 * cluster if it's not being used by any existing tasks.</p> <p>When creating a 2038 * service or running a task on a cluster, if no capacity provider or launch type 2039 * is specified, then the cluster's default capacity provider strategy is used. It 2040 * is recommended to define a default capacity provider strategy for your cluster, 2041 * however you may specify an empty array (<code>[]</code>) to bypass defining a 2042 * default strategy.</p><p><h3>See Also:</h3> <a 2043 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutClusterCapacityProviders">AWS 2044 * API Reference</a></p> 2045 * 2046 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2047 */ 2048 virtual void PutClusterCapacityProvidersAsync(const Model::PutClusterCapacityProvidersRequest& request, const PutClusterCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2049 2050 /** 2051 * <p>This action is only used by the Amazon ECS agent, and it is not 2052 * intended for use outside of the agent.</p> <p>Registers an EC2 instance 2053 * into the specified cluster. This instance becomes available to place containers 2054 * on.</p><p><h3>See Also:</h3> <a 2055 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterContainerInstance">AWS 2056 * API Reference</a></p> 2057 */ 2058 virtual Model::RegisterContainerInstanceOutcome RegisterContainerInstance(const Model::RegisterContainerInstanceRequest& request) const; 2059 2060 /** 2061 * <p>This action is only used by the Amazon ECS agent, and it is not 2062 * intended for use outside of the agent.</p> <p>Registers an EC2 instance 2063 * into the specified cluster. This instance becomes available to place containers 2064 * on.</p><p><h3>See Also:</h3> <a 2065 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterContainerInstance">AWS 2066 * API Reference</a></p> 2067 * 2068 * returns a future to the operation so that it can be executed in parallel to other requests. 2069 */ 2070 virtual Model::RegisterContainerInstanceOutcomeCallable RegisterContainerInstanceCallable(const Model::RegisterContainerInstanceRequest& request) const; 2071 2072 /** 2073 * <p>This action is only used by the Amazon ECS agent, and it is not 2074 * intended for use outside of the agent.</p> <p>Registers an EC2 instance 2075 * into the specified cluster. This instance becomes available to place containers 2076 * on.</p><p><h3>See Also:</h3> <a 2077 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterContainerInstance">AWS 2078 * API Reference</a></p> 2079 * 2080 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2081 */ 2082 virtual void RegisterContainerInstanceAsync(const Model::RegisterContainerInstanceRequest& request, const RegisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2083 2084 /** 2085 * <p>Registers a new task definition from the supplied <code>family</code> and 2086 * <code>containerDefinitions</code>. Optionally, you can add data volumes to your 2087 * containers with the <code>volumes</code> parameter. For more information about 2088 * task definition parameters and defaults, see <a 2089 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon 2090 * ECS Task Definitions</a> in the <i>Amazon Elastic Container Service Developer 2091 * Guide</i>.</p> <p>You can specify an IAM role for your task with the 2092 * <code>taskRoleArn</code> parameter. When you specify an IAM role for a task, its 2093 * containers can then use the latest versions of the CLI or SDKs to make API 2094 * requests to the Amazon Web Services services that are specified in the IAM 2095 * policy associated with the role. For more information, see <a 2096 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 2097 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 2098 * Guide</i>.</p> <p>You can specify a Docker networking mode for the containers in 2099 * your task definition with the <code>networkMode</code> parameter. The available 2100 * network modes correspond to those described in <a 2101 * href="https://docs.docker.com/engine/reference/run/#/network-settings">Network 2102 * settings</a> in the Docker run reference. If you specify the <code>awsvpc</code> 2103 * network mode, the task is allocated an elastic network interface, and you must 2104 * specify a <a>NetworkConfiguration</a> when you create a service or run a task 2105 * with the task definition. For more information, see <a 2106 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 2107 * Networking</a> in the <i>Amazon Elastic Container Service Developer 2108 * Guide</i>.</p><p><h3>See Also:</h3> <a 2109 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterTaskDefinition">AWS 2110 * API Reference</a></p> 2111 */ 2112 virtual Model::RegisterTaskDefinitionOutcome RegisterTaskDefinition(const Model::RegisterTaskDefinitionRequest& request) const; 2113 2114 /** 2115 * <p>Registers a new task definition from the supplied <code>family</code> and 2116 * <code>containerDefinitions</code>. Optionally, you can add data volumes to your 2117 * containers with the <code>volumes</code> parameter. For more information about 2118 * task definition parameters and defaults, see <a 2119 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon 2120 * ECS Task Definitions</a> in the <i>Amazon Elastic Container Service Developer 2121 * Guide</i>.</p> <p>You can specify an IAM role for your task with the 2122 * <code>taskRoleArn</code> parameter. When you specify an IAM role for a task, its 2123 * containers can then use the latest versions of the CLI or SDKs to make API 2124 * requests to the Amazon Web Services services that are specified in the IAM 2125 * policy associated with the role. For more information, see <a 2126 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 2127 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 2128 * Guide</i>.</p> <p>You can specify a Docker networking mode for the containers in 2129 * your task definition with the <code>networkMode</code> parameter. The available 2130 * network modes correspond to those described in <a 2131 * href="https://docs.docker.com/engine/reference/run/#/network-settings">Network 2132 * settings</a> in the Docker run reference. If you specify the <code>awsvpc</code> 2133 * network mode, the task is allocated an elastic network interface, and you must 2134 * specify a <a>NetworkConfiguration</a> when you create a service or run a task 2135 * with the task definition. For more information, see <a 2136 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 2137 * Networking</a> in the <i>Amazon Elastic Container Service Developer 2138 * Guide</i>.</p><p><h3>See Also:</h3> <a 2139 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterTaskDefinition">AWS 2140 * API Reference</a></p> 2141 * 2142 * returns a future to the operation so that it can be executed in parallel to other requests. 2143 */ 2144 virtual Model::RegisterTaskDefinitionOutcomeCallable RegisterTaskDefinitionCallable(const Model::RegisterTaskDefinitionRequest& request) const; 2145 2146 /** 2147 * <p>Registers a new task definition from the supplied <code>family</code> and 2148 * <code>containerDefinitions</code>. Optionally, you can add data volumes to your 2149 * containers with the <code>volumes</code> parameter. For more information about 2150 * task definition parameters and defaults, see <a 2151 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon 2152 * ECS Task Definitions</a> in the <i>Amazon Elastic Container Service Developer 2153 * Guide</i>.</p> <p>You can specify an IAM role for your task with the 2154 * <code>taskRoleArn</code> parameter. When you specify an IAM role for a task, its 2155 * containers can then use the latest versions of the CLI or SDKs to make API 2156 * requests to the Amazon Web Services services that are specified in the IAM 2157 * policy associated with the role. For more information, see <a 2158 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM 2159 * Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer 2160 * Guide</i>.</p> <p>You can specify a Docker networking mode for the containers in 2161 * your task definition with the <code>networkMode</code> parameter. The available 2162 * network modes correspond to those described in <a 2163 * href="https://docs.docker.com/engine/reference/run/#/network-settings">Network 2164 * settings</a> in the Docker run reference. If you specify the <code>awsvpc</code> 2165 * network mode, the task is allocated an elastic network interface, and you must 2166 * specify a <a>NetworkConfiguration</a> when you create a service or run a task 2167 * with the task definition. For more information, see <a 2168 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task 2169 * Networking</a> in the <i>Amazon Elastic Container Service Developer 2170 * Guide</i>.</p><p><h3>See Also:</h3> <a 2171 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterTaskDefinition">AWS 2172 * API Reference</a></p> 2173 * 2174 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2175 */ 2176 virtual void RegisterTaskDefinitionAsync(const Model::RegisterTaskDefinitionRequest& request, const RegisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2177 2178 /** 2179 * <p>Starts a new task using the specified task definition.</p> <p>You can allow 2180 * Amazon ECS to place tasks for you, or you can customize how Amazon ECS places 2181 * tasks using placement constraints and placement strategies. For more 2182 * information, see <a 2183 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2184 * Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 2185 * <p>Alternatively, you can use <a>StartTask</a> to use your own scheduler or 2186 * place tasks manually on specific container instances.</p> <p>The Amazon ECS API 2187 * follows an eventual consistency model, due to the distributed nature of the 2188 * system supporting the API. This means that the result of an API command you run 2189 * that affects your Amazon ECS resources might not be immediately visible to all 2190 * subsequent commands you run. Keep this in mind when you carry out an API command 2191 * that immediately follows a previous API command.</p> <p>To manage eventual 2192 * consistency, you can do the following:</p> <ul> <li> <p>Confirm the state of the 2193 * resource before you run a command to modify it. Run the DescribeTasks command 2194 * using an exponential backoff algorithm to ensure that you allow enough time for 2195 * the previous command to propagate through the system. To do this, run the 2196 * DescribeTasks command repeatedly, starting with a couple of seconds of wait time 2197 * and increasing gradually up to five minutes of wait time.</p> </li> <li> <p>Add 2198 * wait time between subsequent commands, even if the DescribeTasks command returns 2199 * an accurate response. Apply an exponential backoff algorithm starting with a 2200 * couple of seconds of wait time, and increase gradually up to about five minutes 2201 * of wait time.</p> </li> </ul><p><h3>See Also:</h3> <a 2202 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RunTask">AWS API 2203 * Reference</a></p> 2204 */ 2205 virtual Model::RunTaskOutcome RunTask(const Model::RunTaskRequest& request) const; 2206 2207 /** 2208 * <p>Starts a new task using the specified task definition.</p> <p>You can allow 2209 * Amazon ECS to place tasks for you, or you can customize how Amazon ECS places 2210 * tasks using placement constraints and placement strategies. For more 2211 * information, see <a 2212 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2213 * Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 2214 * <p>Alternatively, you can use <a>StartTask</a> to use your own scheduler or 2215 * place tasks manually on specific container instances.</p> <p>The Amazon ECS API 2216 * follows an eventual consistency model, due to the distributed nature of the 2217 * system supporting the API. This means that the result of an API command you run 2218 * that affects your Amazon ECS resources might not be immediately visible to all 2219 * subsequent commands you run. Keep this in mind when you carry out an API command 2220 * that immediately follows a previous API command.</p> <p>To manage eventual 2221 * consistency, you can do the following:</p> <ul> <li> <p>Confirm the state of the 2222 * resource before you run a command to modify it. Run the DescribeTasks command 2223 * using an exponential backoff algorithm to ensure that you allow enough time for 2224 * the previous command to propagate through the system. To do this, run the 2225 * DescribeTasks command repeatedly, starting with a couple of seconds of wait time 2226 * and increasing gradually up to five minutes of wait time.</p> </li> <li> <p>Add 2227 * wait time between subsequent commands, even if the DescribeTasks command returns 2228 * an accurate response. Apply an exponential backoff algorithm starting with a 2229 * couple of seconds of wait time, and increase gradually up to about five minutes 2230 * of wait time.</p> </li> </ul><p><h3>See Also:</h3> <a 2231 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RunTask">AWS API 2232 * Reference</a></p> 2233 * 2234 * returns a future to the operation so that it can be executed in parallel to other requests. 2235 */ 2236 virtual Model::RunTaskOutcomeCallable RunTaskCallable(const Model::RunTaskRequest& request) const; 2237 2238 /** 2239 * <p>Starts a new task using the specified task definition.</p> <p>You can allow 2240 * Amazon ECS to place tasks for you, or you can customize how Amazon ECS places 2241 * tasks using placement constraints and placement strategies. For more 2242 * information, see <a 2243 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2244 * Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p> 2245 * <p>Alternatively, you can use <a>StartTask</a> to use your own scheduler or 2246 * place tasks manually on specific container instances.</p> <p>The Amazon ECS API 2247 * follows an eventual consistency model, due to the distributed nature of the 2248 * system supporting the API. This means that the result of an API command you run 2249 * that affects your Amazon ECS resources might not be immediately visible to all 2250 * subsequent commands you run. Keep this in mind when you carry out an API command 2251 * that immediately follows a previous API command.</p> <p>To manage eventual 2252 * consistency, you can do the following:</p> <ul> <li> <p>Confirm the state of the 2253 * resource before you run a command to modify it. Run the DescribeTasks command 2254 * using an exponential backoff algorithm to ensure that you allow enough time for 2255 * the previous command to propagate through the system. To do this, run the 2256 * DescribeTasks command repeatedly, starting with a couple of seconds of wait time 2257 * and increasing gradually up to five minutes of wait time.</p> </li> <li> <p>Add 2258 * wait time between subsequent commands, even if the DescribeTasks command returns 2259 * an accurate response. Apply an exponential backoff algorithm starting with a 2260 * couple of seconds of wait time, and increase gradually up to about five minutes 2261 * of wait time.</p> </li> </ul><p><h3>See Also:</h3> <a 2262 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RunTask">AWS API 2263 * Reference</a></p> 2264 * 2265 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2266 */ 2267 virtual void RunTaskAsync(const Model::RunTaskRequest& request, const RunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2268 2269 /** 2270 * <p>Starts a new task from the specified task definition on the specified 2271 * container instance or instances.</p> <p>Alternatively, you can use 2272 * <a>RunTask</a> to place tasks for you. For more information, see <a 2273 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2274 * Tasks</a> in the <i>Amazon Elastic Container Service Developer 2275 * Guide</i>.</p><p><h3>See Also:</h3> <a 2276 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StartTask">AWS API 2277 * Reference</a></p> 2278 */ 2279 virtual Model::StartTaskOutcome StartTask(const Model::StartTaskRequest& request) const; 2280 2281 /** 2282 * <p>Starts a new task from the specified task definition on the specified 2283 * container instance or instances.</p> <p>Alternatively, you can use 2284 * <a>RunTask</a> to place tasks for you. For more information, see <a 2285 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2286 * Tasks</a> in the <i>Amazon Elastic Container Service Developer 2287 * Guide</i>.</p><p><h3>See Also:</h3> <a 2288 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StartTask">AWS API 2289 * Reference</a></p> 2290 * 2291 * returns a future to the operation so that it can be executed in parallel to other requests. 2292 */ 2293 virtual Model::StartTaskOutcomeCallable StartTaskCallable(const Model::StartTaskRequest& request) const; 2294 2295 /** 2296 * <p>Starts a new task from the specified task definition on the specified 2297 * container instance or instances.</p> <p>Alternatively, you can use 2298 * <a>RunTask</a> to place tasks for you. For more information, see <a 2299 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling 2300 * Tasks</a> in the <i>Amazon Elastic Container Service Developer 2301 * Guide</i>.</p><p><h3>See Also:</h3> <a 2302 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StartTask">AWS API 2303 * Reference</a></p> 2304 * 2305 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2306 */ 2307 virtual void StartTaskAsync(const Model::StartTaskRequest& request, const StartTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2308 2309 /** 2310 * <p>Stops a running task. Any tags associated with the task will be deleted.</p> 2311 * <p>When <a>StopTask</a> is called on a task, the equivalent of <code>docker 2312 * stop</code> is issued to the containers running in the task. This results in a 2313 * <code>SIGTERM</code> value and a default 30-second timeout, after which the 2314 * <code>SIGKILL</code> value is sent and the containers are forcibly stopped. If 2315 * the container handles the <code>SIGTERM</code> value gracefully and exits within 2316 * 30 seconds from receiving it, no <code>SIGKILL</code> value is sent.</p> 2317 * <p>The default 30-second timeout can be configured on the Amazon ECS container 2318 * agent with the <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more 2319 * information, see <a 2320 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon 2321 * ECS Container Agent Configuration</a> in the <i>Amazon Elastic Container Service 2322 * Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 2323 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StopTask">AWS API 2324 * Reference</a></p> 2325 */ 2326 virtual Model::StopTaskOutcome StopTask(const Model::StopTaskRequest& request) const; 2327 2328 /** 2329 * <p>Stops a running task. Any tags associated with the task will be deleted.</p> 2330 * <p>When <a>StopTask</a> is called on a task, the equivalent of <code>docker 2331 * stop</code> is issued to the containers running in the task. This results in a 2332 * <code>SIGTERM</code> value and a default 30-second timeout, after which the 2333 * <code>SIGKILL</code> value is sent and the containers are forcibly stopped. If 2334 * the container handles the <code>SIGTERM</code> value gracefully and exits within 2335 * 30 seconds from receiving it, no <code>SIGKILL</code> value is sent.</p> 2336 * <p>The default 30-second timeout can be configured on the Amazon ECS container 2337 * agent with the <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more 2338 * information, see <a 2339 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon 2340 * ECS Container Agent Configuration</a> in the <i>Amazon Elastic Container Service 2341 * Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 2342 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StopTask">AWS API 2343 * Reference</a></p> 2344 * 2345 * returns a future to the operation so that it can be executed in parallel to other requests. 2346 */ 2347 virtual Model::StopTaskOutcomeCallable StopTaskCallable(const Model::StopTaskRequest& request) const; 2348 2349 /** 2350 * <p>Stops a running task. Any tags associated with the task will be deleted.</p> 2351 * <p>When <a>StopTask</a> is called on a task, the equivalent of <code>docker 2352 * stop</code> is issued to the containers running in the task. This results in a 2353 * <code>SIGTERM</code> value and a default 30-second timeout, after which the 2354 * <code>SIGKILL</code> value is sent and the containers are forcibly stopped. If 2355 * the container handles the <code>SIGTERM</code> value gracefully and exits within 2356 * 30 seconds from receiving it, no <code>SIGKILL</code> value is sent.</p> 2357 * <p>The default 30-second timeout can be configured on the Amazon ECS container 2358 * agent with the <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more 2359 * information, see <a 2360 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon 2361 * ECS Container Agent Configuration</a> in the <i>Amazon Elastic Container Service 2362 * Developer Guide</i>.</p> <p><h3>See Also:</h3> <a 2363 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StopTask">AWS API 2364 * Reference</a></p> 2365 * 2366 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2367 */ 2368 virtual void StopTaskAsync(const Model::StopTaskRequest& request, const StopTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2369 2370 /** 2371 * <p>This action is only used by the Amazon ECS agent, and it is not 2372 * intended for use outside of the agent.</p> <p>Sent to acknowledge that 2373 * an attachment changed states.</p><p><h3>See Also:</h3> <a 2374 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitAttachmentStateChanges">AWS 2375 * API Reference</a></p> 2376 */ 2377 virtual Model::SubmitAttachmentStateChangesOutcome SubmitAttachmentStateChanges(const Model::SubmitAttachmentStateChangesRequest& request) const; 2378 2379 /** 2380 * <p>This action is only used by the Amazon ECS agent, and it is not 2381 * intended for use outside of the agent.</p> <p>Sent to acknowledge that 2382 * an attachment changed states.</p><p><h3>See Also:</h3> <a 2383 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitAttachmentStateChanges">AWS 2384 * API Reference</a></p> 2385 * 2386 * returns a future to the operation so that it can be executed in parallel to other requests. 2387 */ 2388 virtual Model::SubmitAttachmentStateChangesOutcomeCallable SubmitAttachmentStateChangesCallable(const Model::SubmitAttachmentStateChangesRequest& request) const; 2389 2390 /** 2391 * <p>This action is only used by the Amazon ECS agent, and it is not 2392 * intended for use outside of the agent.</p> <p>Sent to acknowledge that 2393 * an attachment changed states.</p><p><h3>See Also:</h3> <a 2394 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitAttachmentStateChanges">AWS 2395 * API Reference</a></p> 2396 * 2397 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2398 */ 2399 virtual void SubmitAttachmentStateChangesAsync(const Model::SubmitAttachmentStateChangesRequest& request, const SubmitAttachmentStateChangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2400 2401 /** 2402 * <p>This action is only used by the Amazon ECS agent, and it is not 2403 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2404 * container changed states.</p><p><h3>See Also:</h3> <a 2405 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitContainerStateChange">AWS 2406 * API Reference</a></p> 2407 */ 2408 virtual Model::SubmitContainerStateChangeOutcome SubmitContainerStateChange(const Model::SubmitContainerStateChangeRequest& request) const; 2409 2410 /** 2411 * <p>This action is only used by the Amazon ECS agent, and it is not 2412 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2413 * container changed states.</p><p><h3>See Also:</h3> <a 2414 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitContainerStateChange">AWS 2415 * API Reference</a></p> 2416 * 2417 * returns a future to the operation so that it can be executed in parallel to other requests. 2418 */ 2419 virtual Model::SubmitContainerStateChangeOutcomeCallable SubmitContainerStateChangeCallable(const Model::SubmitContainerStateChangeRequest& request) const; 2420 2421 /** 2422 * <p>This action is only used by the Amazon ECS agent, and it is not 2423 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2424 * container changed states.</p><p><h3>See Also:</h3> <a 2425 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitContainerStateChange">AWS 2426 * API Reference</a></p> 2427 * 2428 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2429 */ 2430 virtual void SubmitContainerStateChangeAsync(const Model::SubmitContainerStateChangeRequest& request, const SubmitContainerStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2431 2432 /** 2433 * <p>This action is only used by the Amazon ECS agent, and it is not 2434 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2435 * task changed states.</p><p><h3>See Also:</h3> <a 2436 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitTaskStateChange">AWS 2437 * API Reference</a></p> 2438 */ 2439 virtual Model::SubmitTaskStateChangeOutcome SubmitTaskStateChange(const Model::SubmitTaskStateChangeRequest& request) const; 2440 2441 /** 2442 * <p>This action is only used by the Amazon ECS agent, and it is not 2443 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2444 * task changed states.</p><p><h3>See Also:</h3> <a 2445 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitTaskStateChange">AWS 2446 * API Reference</a></p> 2447 * 2448 * returns a future to the operation so that it can be executed in parallel to other requests. 2449 */ 2450 virtual Model::SubmitTaskStateChangeOutcomeCallable SubmitTaskStateChangeCallable(const Model::SubmitTaskStateChangeRequest& request) const; 2451 2452 /** 2453 * <p>This action is only used by the Amazon ECS agent, and it is not 2454 * intended for use outside of the agent.</p> <p>Sent to acknowledge that a 2455 * task changed states.</p><p><h3>See Also:</h3> <a 2456 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitTaskStateChange">AWS 2457 * API Reference</a></p> 2458 * 2459 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2460 */ 2461 virtual void SubmitTaskStateChangeAsync(const Model::SubmitTaskStateChangeRequest& request, const SubmitTaskStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2462 2463 /** 2464 * <p>Associates the specified tags to a resource with the specified 2465 * <code>resourceArn</code>. If existing tags on a resource are not specified in 2466 * the request parameters, they are not changed. When a resource is deleted, the 2467 * tags associated with that resource are deleted as well.</p><p><h3>See Also:</h3> 2468 * <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/TagResource">AWS 2469 * API Reference</a></p> 2470 */ 2471 virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; 2472 2473 /** 2474 * <p>Associates the specified tags to a resource with the specified 2475 * <code>resourceArn</code>. If existing tags on a resource are not specified in 2476 * the request parameters, they are not changed. When a resource is deleted, the 2477 * tags associated with that resource are deleted as well.</p><p><h3>See Also:</h3> 2478 * <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/TagResource">AWS 2479 * API Reference</a></p> 2480 * 2481 * returns a future to the operation so that it can be executed in parallel to other requests. 2482 */ 2483 virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const; 2484 2485 /** 2486 * <p>Associates the specified tags to a resource with the specified 2487 * <code>resourceArn</code>. If existing tags on a resource are not specified in 2488 * the request parameters, they are not changed. When a resource is deleted, the 2489 * tags associated with that resource are deleted as well.</p><p><h3>See Also:</h3> 2490 * <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/TagResource">AWS 2491 * API Reference</a></p> 2492 * 2493 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2494 */ 2495 virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2496 2497 /** 2498 * <p>Deletes specified tags from a resource.</p><p><h3>See Also:</h3> <a 2499 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UntagResource">AWS 2500 * API Reference</a></p> 2501 */ 2502 virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; 2503 2504 /** 2505 * <p>Deletes specified tags from a resource.</p><p><h3>See Also:</h3> <a 2506 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UntagResource">AWS 2507 * API Reference</a></p> 2508 * 2509 * returns a future to the operation so that it can be executed in parallel to other requests. 2510 */ 2511 virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const; 2512 2513 /** 2514 * <p>Deletes specified tags from a resource.</p><p><h3>See Also:</h3> <a 2515 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UntagResource">AWS 2516 * API Reference</a></p> 2517 * 2518 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2519 */ 2520 virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2521 2522 /** 2523 * <p>Modifies the parameters for a capacity provider.</p><p><h3>See Also:</h3> 2524 * <a 2525 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCapacityProvider">AWS 2526 * API Reference</a></p> 2527 */ 2528 virtual Model::UpdateCapacityProviderOutcome UpdateCapacityProvider(const Model::UpdateCapacityProviderRequest& request) const; 2529 2530 /** 2531 * <p>Modifies the parameters for a capacity provider.</p><p><h3>See Also:</h3> 2532 * <a 2533 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCapacityProvider">AWS 2534 * API Reference</a></p> 2535 * 2536 * returns a future to the operation so that it can be executed in parallel to other requests. 2537 */ 2538 virtual Model::UpdateCapacityProviderOutcomeCallable UpdateCapacityProviderCallable(const Model::UpdateCapacityProviderRequest& request) const; 2539 2540 /** 2541 * <p>Modifies the parameters for a capacity provider.</p><p><h3>See Also:</h3> 2542 * <a 2543 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCapacityProvider">AWS 2544 * API Reference</a></p> 2545 * 2546 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2547 */ 2548 virtual void UpdateCapacityProviderAsync(const Model::UpdateCapacityProviderRequest& request, const UpdateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2549 2550 /** 2551 * <p>Updates the cluster.</p><p><h3>See Also:</h3> <a 2552 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCluster">AWS 2553 * API Reference</a></p> 2554 */ 2555 virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const; 2556 2557 /** 2558 * <p>Updates the cluster.</p><p><h3>See Also:</h3> <a 2559 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCluster">AWS 2560 * API Reference</a></p> 2561 * 2562 * returns a future to the operation so that it can be executed in parallel to other requests. 2563 */ 2564 virtual Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const Model::UpdateClusterRequest& request) const; 2565 2566 /** 2567 * <p>Updates the cluster.</p><p><h3>See Also:</h3> <a 2568 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateCluster">AWS 2569 * API Reference</a></p> 2570 * 2571 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2572 */ 2573 virtual void UpdateClusterAsync(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2574 2575 /** 2576 * <p>Modifies the settings to use for a cluster.</p><p><h3>See Also:</h3> <a 2577 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateClusterSettings">AWS 2578 * API Reference</a></p> 2579 */ 2580 virtual Model::UpdateClusterSettingsOutcome UpdateClusterSettings(const Model::UpdateClusterSettingsRequest& request) const; 2581 2582 /** 2583 * <p>Modifies the settings to use for a cluster.</p><p><h3>See Also:</h3> <a 2584 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateClusterSettings">AWS 2585 * API Reference</a></p> 2586 * 2587 * returns a future to the operation so that it can be executed in parallel to other requests. 2588 */ 2589 virtual Model::UpdateClusterSettingsOutcomeCallable UpdateClusterSettingsCallable(const Model::UpdateClusterSettingsRequest& request) const; 2590 2591 /** 2592 * <p>Modifies the settings to use for a cluster.</p><p><h3>See Also:</h3> <a 2593 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateClusterSettings">AWS 2594 * API Reference</a></p> 2595 * 2596 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2597 */ 2598 virtual void UpdateClusterSettingsAsync(const Model::UpdateClusterSettingsRequest& request, const UpdateClusterSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2599 2600 /** 2601 * <p>Updates the Amazon ECS container agent on a specified container instance. 2602 * Updating the Amazon ECS container agent does not interrupt running tasks or 2603 * services on the container instance. The process for updating the agent differs 2604 * depending on whether your container instance was launched with the Amazon 2605 * ECS-optimized AMI or another operating system.</p> <p>The 2606 * <code>UpdateContainerAgent</code> API isn't supported for container instances 2607 * using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update the 2608 * container agent, you can update the <code>ecs-init</code> package which will 2609 * update the agent. For more information, see <a 2610 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html">Updating 2611 * the Amazon ECS container agent</a> in the <i>Amazon Elastic Container Service 2612 * Developer Guide</i>.</p> <p>The <code>UpdateContainerAgent</code> API 2613 * requires an Amazon ECS-optimized AMI or Amazon Linux AMI with the 2614 * <code>ecs-init</code> service installed and running. For help updating the 2615 * Amazon ECS container agent on other operating systems, see <a 2616 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent">Manually 2617 * updating the Amazon ECS container agent</a> in the <i>Amazon Elastic Container 2618 * Service Developer Guide</i>.</p><p><h3>See Also:</h3> <a 2619 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerAgent">AWS 2620 * API Reference</a></p> 2621 */ 2622 virtual Model::UpdateContainerAgentOutcome UpdateContainerAgent(const Model::UpdateContainerAgentRequest& request) const; 2623 2624 /** 2625 * <p>Updates the Amazon ECS container agent on a specified container instance. 2626 * Updating the Amazon ECS container agent does not interrupt running tasks or 2627 * services on the container instance. The process for updating the agent differs 2628 * depending on whether your container instance was launched with the Amazon 2629 * ECS-optimized AMI or another operating system.</p> <p>The 2630 * <code>UpdateContainerAgent</code> API isn't supported for container instances 2631 * using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update the 2632 * container agent, you can update the <code>ecs-init</code> package which will 2633 * update the agent. For more information, see <a 2634 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html">Updating 2635 * the Amazon ECS container agent</a> in the <i>Amazon Elastic Container Service 2636 * Developer Guide</i>.</p> <p>The <code>UpdateContainerAgent</code> API 2637 * requires an Amazon ECS-optimized AMI or Amazon Linux AMI with the 2638 * <code>ecs-init</code> service installed and running. For help updating the 2639 * Amazon ECS container agent on other operating systems, see <a 2640 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent">Manually 2641 * updating the Amazon ECS container agent</a> in the <i>Amazon Elastic Container 2642 * Service Developer Guide</i>.</p><p><h3>See Also:</h3> <a 2643 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerAgent">AWS 2644 * API Reference</a></p> 2645 * 2646 * returns a future to the operation so that it can be executed in parallel to other requests. 2647 */ 2648 virtual Model::UpdateContainerAgentOutcomeCallable UpdateContainerAgentCallable(const Model::UpdateContainerAgentRequest& request) const; 2649 2650 /** 2651 * <p>Updates the Amazon ECS container agent on a specified container instance. 2652 * Updating the Amazon ECS container agent does not interrupt running tasks or 2653 * services on the container instance. The process for updating the agent differs 2654 * depending on whether your container instance was launched with the Amazon 2655 * ECS-optimized AMI or another operating system.</p> <p>The 2656 * <code>UpdateContainerAgent</code> API isn't supported for container instances 2657 * using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update the 2658 * container agent, you can update the <code>ecs-init</code> package which will 2659 * update the agent. For more information, see <a 2660 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html">Updating 2661 * the Amazon ECS container agent</a> in the <i>Amazon Elastic Container Service 2662 * Developer Guide</i>.</p> <p>The <code>UpdateContainerAgent</code> API 2663 * requires an Amazon ECS-optimized AMI or Amazon Linux AMI with the 2664 * <code>ecs-init</code> service installed and running. For help updating the 2665 * Amazon ECS container agent on other operating systems, see <a 2666 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent">Manually 2667 * updating the Amazon ECS container agent</a> in the <i>Amazon Elastic Container 2668 * Service Developer Guide</i>.</p><p><h3>See Also:</h3> <a 2669 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerAgent">AWS 2670 * API Reference</a></p> 2671 * 2672 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2673 */ 2674 virtual void UpdateContainerAgentAsync(const Model::UpdateContainerAgentRequest& request, const UpdateContainerAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2675 2676 /** 2677 * <p>Modifies the status of an Amazon ECS container instance.</p> <p>Once a 2678 * container instance has reached an <code>ACTIVE</code> state, you can change the 2679 * status of a container instance to <code>DRAINING</code> to manually remove an 2680 * instance from a cluster, for example to perform system updates, update the 2681 * Docker daemon, or scale down the cluster size.</p> <p>A container 2682 * instance cannot be changed to <code>DRAINING</code> until it has reached an 2683 * <code>ACTIVE</code> status. If the instance is in any other status, an error 2684 * will be received.</p> <p>When you set a container instance to 2685 * <code>DRAINING</code>, Amazon ECS prevents new tasks from being scheduled for 2686 * placement on the container instance and replacement service tasks are started on 2687 * other container instances in the cluster if the resources are available. Service 2688 * tasks on the container instance that are in the <code>PENDING</code> state are 2689 * stopped immediately.</p> <p>Service tasks on the container instance that are in 2690 * the <code>RUNNING</code> state are stopped and replaced according to the 2691 * service's deployment configuration parameters, 2692 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>. You can 2693 * change the deployment configuration of your service using 2694 * <a>UpdateService</a>.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> is 2695 * below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 2696 * during task replacement. For example, <code>desiredCount</code> is four tasks, a 2697 * minimum of 50% allows the scheduler to stop two existing tasks before starting 2698 * two new tasks. If the minimum is 100%, the service scheduler can't remove 2699 * existing tasks until the replacement tasks are considered healthy. Tasks for 2700 * services that do not use a load balancer are considered healthy if they are in 2701 * the <code>RUNNING</code> state. Tasks for services that use a load balancer are 2702 * considered healthy if they are in the <code>RUNNING</code> state and the 2703 * container instance they are hosted on is reported as healthy by the load 2704 * balancer.</p> </li> <li> <p>The <code>maximumPercent</code> parameter represents 2705 * an upper limit on the number of running tasks during task replacement, which 2706 * enables you to define the replacement batch size. For example, if 2707 * <code>desiredCount</code> is four tasks, a maximum of 200% starts four new tasks 2708 * before stopping the four tasks to be drained, provided that the cluster 2709 * resources required to do this are available. If the maximum is 100%, then 2710 * replacement tasks can't start until the draining tasks have stopped.</p> </li> 2711 * </ul> <p>Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not 2712 * belong to a service are not affected. You must wait for them to finish or stop 2713 * them manually.</p> <p>A container instance has completed draining when it has no 2714 * more <code>RUNNING</code> tasks. You can verify this using <a>ListTasks</a>.</p> 2715 * <p>When a container instance has been drained, you can set a container instance 2716 * to <code>ACTIVE</code> status and once it has reached that status the Amazon ECS 2717 * scheduler can begin scheduling tasks on the instance again.</p><p><h3>See 2718 * Also:</h3> <a 2719 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerInstancesState">AWS 2720 * API Reference</a></p> 2721 */ 2722 virtual Model::UpdateContainerInstancesStateOutcome UpdateContainerInstancesState(const Model::UpdateContainerInstancesStateRequest& request) const; 2723 2724 /** 2725 * <p>Modifies the status of an Amazon ECS container instance.</p> <p>Once a 2726 * container instance has reached an <code>ACTIVE</code> state, you can change the 2727 * status of a container instance to <code>DRAINING</code> to manually remove an 2728 * instance from a cluster, for example to perform system updates, update the 2729 * Docker daemon, or scale down the cluster size.</p> <p>A container 2730 * instance cannot be changed to <code>DRAINING</code> until it has reached an 2731 * <code>ACTIVE</code> status. If the instance is in any other status, an error 2732 * will be received.</p> <p>When you set a container instance to 2733 * <code>DRAINING</code>, Amazon ECS prevents new tasks from being scheduled for 2734 * placement on the container instance and replacement service tasks are started on 2735 * other container instances in the cluster if the resources are available. Service 2736 * tasks on the container instance that are in the <code>PENDING</code> state are 2737 * stopped immediately.</p> <p>Service tasks on the container instance that are in 2738 * the <code>RUNNING</code> state are stopped and replaced according to the 2739 * service's deployment configuration parameters, 2740 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>. You can 2741 * change the deployment configuration of your service using 2742 * <a>UpdateService</a>.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> is 2743 * below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 2744 * during task replacement. For example, <code>desiredCount</code> is four tasks, a 2745 * minimum of 50% allows the scheduler to stop two existing tasks before starting 2746 * two new tasks. If the minimum is 100%, the service scheduler can't remove 2747 * existing tasks until the replacement tasks are considered healthy. Tasks for 2748 * services that do not use a load balancer are considered healthy if they are in 2749 * the <code>RUNNING</code> state. Tasks for services that use a load balancer are 2750 * considered healthy if they are in the <code>RUNNING</code> state and the 2751 * container instance they are hosted on is reported as healthy by the load 2752 * balancer.</p> </li> <li> <p>The <code>maximumPercent</code> parameter represents 2753 * an upper limit on the number of running tasks during task replacement, which 2754 * enables you to define the replacement batch size. For example, if 2755 * <code>desiredCount</code> is four tasks, a maximum of 200% starts four new tasks 2756 * before stopping the four tasks to be drained, provided that the cluster 2757 * resources required to do this are available. If the maximum is 100%, then 2758 * replacement tasks can't start until the draining tasks have stopped.</p> </li> 2759 * </ul> <p>Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not 2760 * belong to a service are not affected. You must wait for them to finish or stop 2761 * them manually.</p> <p>A container instance has completed draining when it has no 2762 * more <code>RUNNING</code> tasks. You can verify this using <a>ListTasks</a>.</p> 2763 * <p>When a container instance has been drained, you can set a container instance 2764 * to <code>ACTIVE</code> status and once it has reached that status the Amazon ECS 2765 * scheduler can begin scheduling tasks on the instance again.</p><p><h3>See 2766 * Also:</h3> <a 2767 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerInstancesState">AWS 2768 * API Reference</a></p> 2769 * 2770 * returns a future to the operation so that it can be executed in parallel to other requests. 2771 */ 2772 virtual Model::UpdateContainerInstancesStateOutcomeCallable UpdateContainerInstancesStateCallable(const Model::UpdateContainerInstancesStateRequest& request) const; 2773 2774 /** 2775 * <p>Modifies the status of an Amazon ECS container instance.</p> <p>Once a 2776 * container instance has reached an <code>ACTIVE</code> state, you can change the 2777 * status of a container instance to <code>DRAINING</code> to manually remove an 2778 * instance from a cluster, for example to perform system updates, update the 2779 * Docker daemon, or scale down the cluster size.</p> <p>A container 2780 * instance cannot be changed to <code>DRAINING</code> until it has reached an 2781 * <code>ACTIVE</code> status. If the instance is in any other status, an error 2782 * will be received.</p> <p>When you set a container instance to 2783 * <code>DRAINING</code>, Amazon ECS prevents new tasks from being scheduled for 2784 * placement on the container instance and replacement service tasks are started on 2785 * other container instances in the cluster if the resources are available. Service 2786 * tasks on the container instance that are in the <code>PENDING</code> state are 2787 * stopped immediately.</p> <p>Service tasks on the container instance that are in 2788 * the <code>RUNNING</code> state are stopped and replaced according to the 2789 * service's deployment configuration parameters, 2790 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>. You can 2791 * change the deployment configuration of your service using 2792 * <a>UpdateService</a>.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> is 2793 * below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 2794 * during task replacement. For example, <code>desiredCount</code> is four tasks, a 2795 * minimum of 50% allows the scheduler to stop two existing tasks before starting 2796 * two new tasks. If the minimum is 100%, the service scheduler can't remove 2797 * existing tasks until the replacement tasks are considered healthy. Tasks for 2798 * services that do not use a load balancer are considered healthy if they are in 2799 * the <code>RUNNING</code> state. Tasks for services that use a load balancer are 2800 * considered healthy if they are in the <code>RUNNING</code> state and the 2801 * container instance they are hosted on is reported as healthy by the load 2802 * balancer.</p> </li> <li> <p>The <code>maximumPercent</code> parameter represents 2803 * an upper limit on the number of running tasks during task replacement, which 2804 * enables you to define the replacement batch size. For example, if 2805 * <code>desiredCount</code> is four tasks, a maximum of 200% starts four new tasks 2806 * before stopping the four tasks to be drained, provided that the cluster 2807 * resources required to do this are available. If the maximum is 100%, then 2808 * replacement tasks can't start until the draining tasks have stopped.</p> </li> 2809 * </ul> <p>Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not 2810 * belong to a service are not affected. You must wait for them to finish or stop 2811 * them manually.</p> <p>A container instance has completed draining when it has no 2812 * more <code>RUNNING</code> tasks. You can verify this using <a>ListTasks</a>.</p> 2813 * <p>When a container instance has been drained, you can set a container instance 2814 * to <code>ACTIVE</code> status and once it has reached that status the Amazon ECS 2815 * scheduler can begin scheduling tasks on the instance again.</p><p><h3>See 2816 * Also:</h3> <a 2817 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerInstancesState">AWS 2818 * API Reference</a></p> 2819 * 2820 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2821 */ 2822 virtual void UpdateContainerInstancesStateAsync(const Model::UpdateContainerInstancesStateRequest& request, const UpdateContainerInstancesStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2823 2824 /** 2825 * <p>Updating the task placement strategies and constraints on an 2826 * Amazon ECS service remains in preview and is a Beta Service as defined by and 2827 * subject to the Beta Service Participation Service Terms located at <a 2828 * href="https://aws.amazon.com/service-terms">https://aws.amazon.com/service-terms</a> 2829 * ("Beta Terms"). These Beta Terms apply to your participation in this 2830 * preview.</p> <p>Modifies the parameters of a service.</p> <p>For 2831 * services using the rolling update (<code>ECS</code>) deployment controller, the 2832 * desired count, deployment configuration, network configuration, task placement 2833 * constraints and strategies, or task definition used can be updated.</p> <p>For 2834 * services using the blue/green (<code>CODE_DEPLOY</code>) deployment controller, 2835 * only the desired count, deployment configuration, task placement constraints and 2836 * strategies, and health check grace period can be updated using this API. If the 2837 * network configuration, platform version, or task definition need to be updated, 2838 * a new CodeDeploy deployment should be created. For more information, see <a 2839 * href="https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html">CreateDeployment</a> 2840 * in the <i>CodeDeploy API Reference</i>.</p> <p>For services using an external 2841 * deployment controller, you can update only the desired count, task placement 2842 * constraints and strategies, and health check grace period using this API. If the 2843 * launch type, load balancer, network configuration, platform version, or task 2844 * definition need to be updated, you should create a new task set. For more 2845 * information, see <a>CreateTaskSet</a>.</p> <p>You can add to or subtract from 2846 * the number of instantiations of a task definition in a service by specifying the 2847 * cluster that the service is running in and a new <code>desiredCount</code> 2848 * parameter.</p> <p>If you have updated the Docker image of your application, you 2849 * can create a new task definition with that image and deploy it to your service. 2850 * The service scheduler uses the minimum healthy percent and maximum percent 2851 * parameters (in the service's deployment configuration) to determine the 2852 * deployment strategy.</p> <p>If your updated Docker image uses the same 2853 * tag as what is in the existing task definition for your service (for example, 2854 * <code>my_image:latest</code>), you do not need to create a new revision of your 2855 * task definition. You can update the service using the 2856 * <code>forceNewDeployment</code> option. The new tasks launched by the deployment 2857 * pull the current image/tag combination from your repository when they start.</p> 2858 * <p>You can also update the deployment configuration of a service. When a 2859 * deployment is triggered by updating the task definition of a service, the 2860 * service scheduler uses the deployment configuration parameters, 2861 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>, to determine 2862 * the deployment strategy.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> 2863 * is below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 2864 * during a deployment. For example, if <code>desiredCount</code> is four tasks, a 2865 * minimum of 50% allows the scheduler to stop two existing tasks before starting 2866 * two new tasks. Tasks for services that do not use a load balancer are considered 2867 * healthy if they are in the <code>RUNNING</code> state. Tasks for services that 2868 * use a load balancer are considered healthy if they are in the 2869 * <code>RUNNING</code> state and the container instance they are hosted on is 2870 * reported as healthy by the load balancer.</p> </li> <li> <p>The 2871 * <code>maximumPercent</code> parameter represents an upper limit on the number of 2872 * running tasks during a deployment, which enables you to define the deployment 2873 * batch size. For example, if <code>desiredCount</code> is four tasks, a maximum 2874 * of 200% starts four new tasks before stopping the four older tasks (provided 2875 * that the cluster resources required to do this are available).</p> </li> </ul> 2876 * <p>When <a>UpdateService</a> stops a task during a deployment, the equivalent of 2877 * <code>docker stop</code> is issued to the containers running in the task. This 2878 * results in a <code>SIGTERM</code> and a 30-second timeout, after which 2879 * <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the 2880 * container handles the <code>SIGTERM</code> gracefully and exits within 30 2881 * seconds from receiving it, no <code>SIGKILL</code> is sent.</p> <p>When the 2882 * service scheduler launches new tasks, it determines task placement in your 2883 * cluster with the following logic:</p> <ul> <li> <p>Determine which of the 2884 * container instances in your cluster can support your service's task definition 2885 * (for example, they have the required CPU, memory, ports, and container instance 2886 * attributes).</p> </li> <li> <p>By default, the service scheduler attempts to 2887 * balance tasks across Availability Zones in this manner (although you can choose 2888 * a different placement strategy):</p> <ul> <li> <p>Sort the valid container 2889 * instances by the fewest number of running tasks for this service in the same 2890 * Availability Zone as the instance. For example, if zone A has one running 2891 * service task and zones B and C each have zero, valid container instances in 2892 * either zone B or C are considered optimal for placement.</p> </li> <li> <p>Place 2893 * the new service task on a valid container instance in an optimal Availability 2894 * Zone (based on the previous steps), favoring container instances with the fewest 2895 * number of running tasks for this service.</p> </li> </ul> </li> </ul> <p>When 2896 * the service scheduler stops running tasks, it attempts to maintain balance 2897 * across the Availability Zones in your cluster using the following logic: </p> 2898 * <ul> <li> <p>Sort the container instances by the largest number of running tasks 2899 * for this service in the same Availability Zone as the instance. For example, if 2900 * zone A has one running service task and zones B and C each have two, container 2901 * instances in either zone B or C are considered optimal for termination.</p> 2902 * </li> <li> <p>Stop the task on a container instance in an optimal Availability 2903 * Zone (based on the previous steps), favoring container instances with the 2904 * largest number of running tasks for this service.</p> </li> </ul><p><h3>See 2905 * Also:</h3> <a 2906 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateService">AWS 2907 * API Reference</a></p> 2908 */ 2909 virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const; 2910 2911 /** 2912 * <p>Updating the task placement strategies and constraints on an 2913 * Amazon ECS service remains in preview and is a Beta Service as defined by and 2914 * subject to the Beta Service Participation Service Terms located at <a 2915 * href="https://aws.amazon.com/service-terms">https://aws.amazon.com/service-terms</a> 2916 * ("Beta Terms"). These Beta Terms apply to your participation in this 2917 * preview.</p> <p>Modifies the parameters of a service.</p> <p>For 2918 * services using the rolling update (<code>ECS</code>) deployment controller, the 2919 * desired count, deployment configuration, network configuration, task placement 2920 * constraints and strategies, or task definition used can be updated.</p> <p>For 2921 * services using the blue/green (<code>CODE_DEPLOY</code>) deployment controller, 2922 * only the desired count, deployment configuration, task placement constraints and 2923 * strategies, and health check grace period can be updated using this API. If the 2924 * network configuration, platform version, or task definition need to be updated, 2925 * a new CodeDeploy deployment should be created. For more information, see <a 2926 * href="https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html">CreateDeployment</a> 2927 * in the <i>CodeDeploy API Reference</i>.</p> <p>For services using an external 2928 * deployment controller, you can update only the desired count, task placement 2929 * constraints and strategies, and health check grace period using this API. If the 2930 * launch type, load balancer, network configuration, platform version, or task 2931 * definition need to be updated, you should create a new task set. For more 2932 * information, see <a>CreateTaskSet</a>.</p> <p>You can add to or subtract from 2933 * the number of instantiations of a task definition in a service by specifying the 2934 * cluster that the service is running in and a new <code>desiredCount</code> 2935 * parameter.</p> <p>If you have updated the Docker image of your application, you 2936 * can create a new task definition with that image and deploy it to your service. 2937 * The service scheduler uses the minimum healthy percent and maximum percent 2938 * parameters (in the service's deployment configuration) to determine the 2939 * deployment strategy.</p> <p>If your updated Docker image uses the same 2940 * tag as what is in the existing task definition for your service (for example, 2941 * <code>my_image:latest</code>), you do not need to create a new revision of your 2942 * task definition. You can update the service using the 2943 * <code>forceNewDeployment</code> option. The new tasks launched by the deployment 2944 * pull the current image/tag combination from your repository when they start.</p> 2945 * <p>You can also update the deployment configuration of a service. When a 2946 * deployment is triggered by updating the task definition of a service, the 2947 * service scheduler uses the deployment configuration parameters, 2948 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>, to determine 2949 * the deployment strategy.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> 2950 * is below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 2951 * during a deployment. For example, if <code>desiredCount</code> is four tasks, a 2952 * minimum of 50% allows the scheduler to stop two existing tasks before starting 2953 * two new tasks. Tasks for services that do not use a load balancer are considered 2954 * healthy if they are in the <code>RUNNING</code> state. Tasks for services that 2955 * use a load balancer are considered healthy if they are in the 2956 * <code>RUNNING</code> state and the container instance they are hosted on is 2957 * reported as healthy by the load balancer.</p> </li> <li> <p>The 2958 * <code>maximumPercent</code> parameter represents an upper limit on the number of 2959 * running tasks during a deployment, which enables you to define the deployment 2960 * batch size. For example, if <code>desiredCount</code> is four tasks, a maximum 2961 * of 200% starts four new tasks before stopping the four older tasks (provided 2962 * that the cluster resources required to do this are available).</p> </li> </ul> 2963 * <p>When <a>UpdateService</a> stops a task during a deployment, the equivalent of 2964 * <code>docker stop</code> is issued to the containers running in the task. This 2965 * results in a <code>SIGTERM</code> and a 30-second timeout, after which 2966 * <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the 2967 * container handles the <code>SIGTERM</code> gracefully and exits within 30 2968 * seconds from receiving it, no <code>SIGKILL</code> is sent.</p> <p>When the 2969 * service scheduler launches new tasks, it determines task placement in your 2970 * cluster with the following logic:</p> <ul> <li> <p>Determine which of the 2971 * container instances in your cluster can support your service's task definition 2972 * (for example, they have the required CPU, memory, ports, and container instance 2973 * attributes).</p> </li> <li> <p>By default, the service scheduler attempts to 2974 * balance tasks across Availability Zones in this manner (although you can choose 2975 * a different placement strategy):</p> <ul> <li> <p>Sort the valid container 2976 * instances by the fewest number of running tasks for this service in the same 2977 * Availability Zone as the instance. For example, if zone A has one running 2978 * service task and zones B and C each have zero, valid container instances in 2979 * either zone B or C are considered optimal for placement.</p> </li> <li> <p>Place 2980 * the new service task on a valid container instance in an optimal Availability 2981 * Zone (based on the previous steps), favoring container instances with the fewest 2982 * number of running tasks for this service.</p> </li> </ul> </li> </ul> <p>When 2983 * the service scheduler stops running tasks, it attempts to maintain balance 2984 * across the Availability Zones in your cluster using the following logic: </p> 2985 * <ul> <li> <p>Sort the container instances by the largest number of running tasks 2986 * for this service in the same Availability Zone as the instance. For example, if 2987 * zone A has one running service task and zones B and C each have two, container 2988 * instances in either zone B or C are considered optimal for termination.</p> 2989 * </li> <li> <p>Stop the task on a container instance in an optimal Availability 2990 * Zone (based on the previous steps), favoring container instances with the 2991 * largest number of running tasks for this service.</p> </li> </ul><p><h3>See 2992 * Also:</h3> <a 2993 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateService">AWS 2994 * API Reference</a></p> 2995 * 2996 * returns a future to the operation so that it can be executed in parallel to other requests. 2997 */ 2998 virtual Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const Model::UpdateServiceRequest& request) const; 2999 3000 /** 3001 * <p>Updating the task placement strategies and constraints on an 3002 * Amazon ECS service remains in preview and is a Beta Service as defined by and 3003 * subject to the Beta Service Participation Service Terms located at <a 3004 * href="https://aws.amazon.com/service-terms">https://aws.amazon.com/service-terms</a> 3005 * ("Beta Terms"). These Beta Terms apply to your participation in this 3006 * preview.</p> <p>Modifies the parameters of a service.</p> <p>For 3007 * services using the rolling update (<code>ECS</code>) deployment controller, the 3008 * desired count, deployment configuration, network configuration, task placement 3009 * constraints and strategies, or task definition used can be updated.</p> <p>For 3010 * services using the blue/green (<code>CODE_DEPLOY</code>) deployment controller, 3011 * only the desired count, deployment configuration, task placement constraints and 3012 * strategies, and health check grace period can be updated using this API. If the 3013 * network configuration, platform version, or task definition need to be updated, 3014 * a new CodeDeploy deployment should be created. For more information, see <a 3015 * href="https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html">CreateDeployment</a> 3016 * in the <i>CodeDeploy API Reference</i>.</p> <p>For services using an external 3017 * deployment controller, you can update only the desired count, task placement 3018 * constraints and strategies, and health check grace period using this API. If the 3019 * launch type, load balancer, network configuration, platform version, or task 3020 * definition need to be updated, you should create a new task set. For more 3021 * information, see <a>CreateTaskSet</a>.</p> <p>You can add to or subtract from 3022 * the number of instantiations of a task definition in a service by specifying the 3023 * cluster that the service is running in and a new <code>desiredCount</code> 3024 * parameter.</p> <p>If you have updated the Docker image of your application, you 3025 * can create a new task definition with that image and deploy it to your service. 3026 * The service scheduler uses the minimum healthy percent and maximum percent 3027 * parameters (in the service's deployment configuration) to determine the 3028 * deployment strategy.</p> <p>If your updated Docker image uses the same 3029 * tag as what is in the existing task definition for your service (for example, 3030 * <code>my_image:latest</code>), you do not need to create a new revision of your 3031 * task definition. You can update the service using the 3032 * <code>forceNewDeployment</code> option. The new tasks launched by the deployment 3033 * pull the current image/tag combination from your repository when they start.</p> 3034 * <p>You can also update the deployment configuration of a service. When a 3035 * deployment is triggered by updating the task definition of a service, the 3036 * service scheduler uses the deployment configuration parameters, 3037 * <code>minimumHealthyPercent</code> and <code>maximumPercent</code>, to determine 3038 * the deployment strategy.</p> <ul> <li> <p>If <code>minimumHealthyPercent</code> 3039 * is below 100%, the scheduler can ignore <code>desiredCount</code> temporarily 3040 * during a deployment. For example, if <code>desiredCount</code> is four tasks, a 3041 * minimum of 50% allows the scheduler to stop two existing tasks before starting 3042 * two new tasks. Tasks for services that do not use a load balancer are considered 3043 * healthy if they are in the <code>RUNNING</code> state. Tasks for services that 3044 * use a load balancer are considered healthy if they are in the 3045 * <code>RUNNING</code> state and the container instance they are hosted on is 3046 * reported as healthy by the load balancer.</p> </li> <li> <p>The 3047 * <code>maximumPercent</code> parameter represents an upper limit on the number of 3048 * running tasks during a deployment, which enables you to define the deployment 3049 * batch size. For example, if <code>desiredCount</code> is four tasks, a maximum 3050 * of 200% starts four new tasks before stopping the four older tasks (provided 3051 * that the cluster resources required to do this are available).</p> </li> </ul> 3052 * <p>When <a>UpdateService</a> stops a task during a deployment, the equivalent of 3053 * <code>docker stop</code> is issued to the containers running in the task. This 3054 * results in a <code>SIGTERM</code> and a 30-second timeout, after which 3055 * <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the 3056 * container handles the <code>SIGTERM</code> gracefully and exits within 30 3057 * seconds from receiving it, no <code>SIGKILL</code> is sent.</p> <p>When the 3058 * service scheduler launches new tasks, it determines task placement in your 3059 * cluster with the following logic:</p> <ul> <li> <p>Determine which of the 3060 * container instances in your cluster can support your service's task definition 3061 * (for example, they have the required CPU, memory, ports, and container instance 3062 * attributes).</p> </li> <li> <p>By default, the service scheduler attempts to 3063 * balance tasks across Availability Zones in this manner (although you can choose 3064 * a different placement strategy):</p> <ul> <li> <p>Sort the valid container 3065 * instances by the fewest number of running tasks for this service in the same 3066 * Availability Zone as the instance. For example, if zone A has one running 3067 * service task and zones B and C each have zero, valid container instances in 3068 * either zone B or C are considered optimal for placement.</p> </li> <li> <p>Place 3069 * the new service task on a valid container instance in an optimal Availability 3070 * Zone (based on the previous steps), favoring container instances with the fewest 3071 * number of running tasks for this service.</p> </li> </ul> </li> </ul> <p>When 3072 * the service scheduler stops running tasks, it attempts to maintain balance 3073 * across the Availability Zones in your cluster using the following logic: </p> 3074 * <ul> <li> <p>Sort the container instances by the largest number of running tasks 3075 * for this service in the same Availability Zone as the instance. For example, if 3076 * zone A has one running service task and zones B and C each have two, container 3077 * instances in either zone B or C are considered optimal for termination.</p> 3078 * </li> <li> <p>Stop the task on a container instance in an optimal Availability 3079 * Zone (based on the previous steps), favoring container instances with the 3080 * largest number of running tasks for this service.</p> </li> </ul><p><h3>See 3081 * Also:</h3> <a 3082 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateService">AWS 3083 * API Reference</a></p> 3084 * 3085 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3086 */ 3087 virtual void UpdateServiceAsync(const Model::UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3088 3089 /** 3090 * <p>Modifies which task set in a service is the primary task set. Any parameters 3091 * that are updated on the primary task set in a service will transition to the 3092 * service. This is used when a service uses the <code>EXTERNAL</code> deployment 3093 * controller type. For more information, see <a 3094 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3095 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3096 * Guide</i>.</p><p><h3>See Also:</h3> <a 3097 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateServicePrimaryTaskSet">AWS 3098 * API Reference</a></p> 3099 */ 3100 virtual Model::UpdateServicePrimaryTaskSetOutcome UpdateServicePrimaryTaskSet(const Model::UpdateServicePrimaryTaskSetRequest& request) const; 3101 3102 /** 3103 * <p>Modifies which task set in a service is the primary task set. Any parameters 3104 * that are updated on the primary task set in a service will transition to the 3105 * service. This is used when a service uses the <code>EXTERNAL</code> deployment 3106 * controller type. For more information, see <a 3107 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3108 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3109 * Guide</i>.</p><p><h3>See Also:</h3> <a 3110 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateServicePrimaryTaskSet">AWS 3111 * API Reference</a></p> 3112 * 3113 * returns a future to the operation so that it can be executed in parallel to other requests. 3114 */ 3115 virtual Model::UpdateServicePrimaryTaskSetOutcomeCallable UpdateServicePrimaryTaskSetCallable(const Model::UpdateServicePrimaryTaskSetRequest& request) const; 3116 3117 /** 3118 * <p>Modifies which task set in a service is the primary task set. Any parameters 3119 * that are updated on the primary task set in a service will transition to the 3120 * service. This is used when a service uses the <code>EXTERNAL</code> deployment 3121 * controller type. For more information, see <a 3122 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3123 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3124 * Guide</i>.</p><p><h3>See Also:</h3> <a 3125 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateServicePrimaryTaskSet">AWS 3126 * API Reference</a></p> 3127 * 3128 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3129 */ 3130 virtual void UpdateServicePrimaryTaskSetAsync(const Model::UpdateServicePrimaryTaskSetRequest& request, const UpdateServicePrimaryTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3131 3132 /** 3133 * <p>Modifies a task set. This is used when a service uses the 3134 * <code>EXTERNAL</code> deployment controller type. For more information, see <a 3135 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3136 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3137 * Guide</i>.</p><p><h3>See Also:</h3> <a 3138 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateTaskSet">AWS 3139 * API Reference</a></p> 3140 */ 3141 virtual Model::UpdateTaskSetOutcome UpdateTaskSet(const Model::UpdateTaskSetRequest& request) const; 3142 3143 /** 3144 * <p>Modifies a task set. This is used when a service uses the 3145 * <code>EXTERNAL</code> deployment controller type. For more information, see <a 3146 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3147 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3148 * Guide</i>.</p><p><h3>See Also:</h3> <a 3149 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateTaskSet">AWS 3150 * API Reference</a></p> 3151 * 3152 * returns a future to the operation so that it can be executed in parallel to other requests. 3153 */ 3154 virtual Model::UpdateTaskSetOutcomeCallable UpdateTaskSetCallable(const Model::UpdateTaskSetRequest& request) const; 3155 3156 /** 3157 * <p>Modifies a task set. This is used when a service uses the 3158 * <code>EXTERNAL</code> deployment controller type. For more information, see <a 3159 * href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon 3160 * ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer 3161 * Guide</i>.</p><p><h3>See Also:</h3> <a 3162 * href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateTaskSet">AWS 3163 * API Reference</a></p> 3164 * 3165 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3166 */ 3167 virtual void UpdateTaskSetAsync(const Model::UpdateTaskSetRequest& request, const UpdateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3168 3169 3170 void OverrideEndpoint(const Aws::String& endpoint); 3171 private: 3172 void init(const Aws::Client::ClientConfiguration& clientConfiguration); 3173 void CreateCapacityProviderAsyncHelper(const Model::CreateCapacityProviderRequest& request, const CreateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3174 void CreateClusterAsyncHelper(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3175 void CreateServiceAsyncHelper(const Model::CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3176 void CreateTaskSetAsyncHelper(const Model::CreateTaskSetRequest& request, const CreateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3177 void DeleteAccountSettingAsyncHelper(const Model::DeleteAccountSettingRequest& request, const DeleteAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3178 void DeleteAttributesAsyncHelper(const Model::DeleteAttributesRequest& request, const DeleteAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3179 void DeleteCapacityProviderAsyncHelper(const Model::DeleteCapacityProviderRequest& request, const DeleteCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3180 void DeleteClusterAsyncHelper(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3181 void DeleteServiceAsyncHelper(const Model::DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3182 void DeleteTaskSetAsyncHelper(const Model::DeleteTaskSetRequest& request, const DeleteTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3183 void DeregisterContainerInstanceAsyncHelper(const Model::DeregisterContainerInstanceRequest& request, const DeregisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3184 void DeregisterTaskDefinitionAsyncHelper(const Model::DeregisterTaskDefinitionRequest& request, const DeregisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3185 void DescribeCapacityProvidersAsyncHelper(const Model::DescribeCapacityProvidersRequest& request, const DescribeCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3186 void DescribeClustersAsyncHelper(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3187 void DescribeContainerInstancesAsyncHelper(const Model::DescribeContainerInstancesRequest& request, const DescribeContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3188 void DescribeServicesAsyncHelper(const Model::DescribeServicesRequest& request, const DescribeServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3189 void DescribeTaskDefinitionAsyncHelper(const Model::DescribeTaskDefinitionRequest& request, const DescribeTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3190 void DescribeTaskSetsAsyncHelper(const Model::DescribeTaskSetsRequest& request, const DescribeTaskSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3191 void DescribeTasksAsyncHelper(const Model::DescribeTasksRequest& request, const DescribeTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3192 void DiscoverPollEndpointAsyncHelper(const Model::DiscoverPollEndpointRequest& request, const DiscoverPollEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3193 void ExecuteCommandAsyncHelper(const Model::ExecuteCommandRequest& request, const ExecuteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3194 void ListAccountSettingsAsyncHelper(const Model::ListAccountSettingsRequest& request, const ListAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3195 void ListAttributesAsyncHelper(const Model::ListAttributesRequest& request, const ListAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3196 void ListClustersAsyncHelper(const Model::ListClustersRequest& request, const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3197 void ListContainerInstancesAsyncHelper(const Model::ListContainerInstancesRequest& request, const ListContainerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3198 void ListServicesAsyncHelper(const Model::ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3199 void ListTagsForResourceAsyncHelper(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3200 void ListTaskDefinitionFamiliesAsyncHelper(const Model::ListTaskDefinitionFamiliesRequest& request, const ListTaskDefinitionFamiliesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3201 void ListTaskDefinitionsAsyncHelper(const Model::ListTaskDefinitionsRequest& request, const ListTaskDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3202 void ListTasksAsyncHelper(const Model::ListTasksRequest& request, const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3203 void PutAccountSettingAsyncHelper(const Model::PutAccountSettingRequest& request, const PutAccountSettingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3204 void PutAccountSettingDefaultAsyncHelper(const Model::PutAccountSettingDefaultRequest& request, const PutAccountSettingDefaultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3205 void PutAttributesAsyncHelper(const Model::PutAttributesRequest& request, const PutAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3206 void PutClusterCapacityProvidersAsyncHelper(const Model::PutClusterCapacityProvidersRequest& request, const PutClusterCapacityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3207 void RegisterContainerInstanceAsyncHelper(const Model::RegisterContainerInstanceRequest& request, const RegisterContainerInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3208 void RegisterTaskDefinitionAsyncHelper(const Model::RegisterTaskDefinitionRequest& request, const RegisterTaskDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3209 void RunTaskAsyncHelper(const Model::RunTaskRequest& request, const RunTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3210 void StartTaskAsyncHelper(const Model::StartTaskRequest& request, const StartTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3211 void StopTaskAsyncHelper(const Model::StopTaskRequest& request, const StopTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3212 void SubmitAttachmentStateChangesAsyncHelper(const Model::SubmitAttachmentStateChangesRequest& request, const SubmitAttachmentStateChangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3213 void SubmitContainerStateChangeAsyncHelper(const Model::SubmitContainerStateChangeRequest& request, const SubmitContainerStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3214 void SubmitTaskStateChangeAsyncHelper(const Model::SubmitTaskStateChangeRequest& request, const SubmitTaskStateChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3215 void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3216 void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3217 void UpdateCapacityProviderAsyncHelper(const Model::UpdateCapacityProviderRequest& request, const UpdateCapacityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3218 void UpdateClusterAsyncHelper(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3219 void UpdateClusterSettingsAsyncHelper(const Model::UpdateClusterSettingsRequest& request, const UpdateClusterSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3220 void UpdateContainerAgentAsyncHelper(const Model::UpdateContainerAgentRequest& request, const UpdateContainerAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3221 void UpdateContainerInstancesStateAsyncHelper(const Model::UpdateContainerInstancesStateRequest& request, const UpdateContainerInstancesStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3222 void UpdateServiceAsyncHelper(const Model::UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3223 void UpdateServicePrimaryTaskSetAsyncHelper(const Model::UpdateServicePrimaryTaskSetRequest& request, const UpdateServicePrimaryTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3224 void UpdateTaskSetAsyncHelper(const Model::UpdateTaskSetRequest& request, const UpdateTaskSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3225 3226 Aws::String m_uri; 3227 Aws::String m_configScheme; 3228 std::shared_ptr<Aws::Utils::Threading::Executor> m_executor; 3229 }; 3230 3231 } // namespace ECS 3232 } // namespace Aws 3233