blib/lib/Paws/ECS.pm untested

filter: Statementstmt 0.0% 0 / 331 Branchbran 0.0% 0 / 32 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 67 Podpod 0.0% 0 / 66 totaltotal 0.0% 0 / 496 CC 17 SCAR 15.9
CC
17
Cov
0%
ListAllAccountSettings
12.0
ListAllAttributes
12.0
ListAllClusters
12.0
CRAP 4.9
1 package Paws::ECS;
2 use Moose;
3 sub service { 'ecs' }
4 sub signing_name { 'ecs' }
5 sub version { '2014-11-13' }
6 sub target_prefix { 'AmazonEC2ContainerServiceV20141113' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub CreateCapacityProvider {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::ECS::CreateCapacityProvider', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CreateCluster {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::ECS::CreateCluster', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateService {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::ECS::CreateService', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateTaskSet {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::ECS::CreateTaskSet', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub DeleteAccountSetting {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteAccountSetting', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DeleteAttributes {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteAttributes', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DeleteCapacityProvider {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteCapacityProvider', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteCluster {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteCluster', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeleteService {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteService', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DeleteTaskSet {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::ECS::DeleteTaskSet', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DeregisterContainerInstance {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::ECS::DeregisterContainerInstance', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DeregisterTaskDefinition {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::ECS::DeregisterTaskDefinition', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DescribeCapacityProviders {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeCapacityProviders', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub DescribeClusters {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeClusters', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub DescribeContainerInstances {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeContainerInstances', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub DescribeServices {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeServices', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub DescribeTaskDefinition {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeTaskDefinition', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub DescribeTasks {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeTasks', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub DescribeTaskSets {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::ECS::DescribeTaskSets', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub DiscoverPollEndpoint {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::ECS::DiscoverPollEndpoint', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub ExecuteCommand {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::ECS::ExecuteCommand', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub ListAccountSettings {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::ECS::ListAccountSettings', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub ListAttributes {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::ECS::ListAttributes', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub ListClusters {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::ECS::ListClusters', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub ListContainerInstances {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::ECS::ListContainerInstances', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub ListServices {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::ECS::ListServices', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub ListTagsForResource {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::ECS::ListTagsForResource', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub ListTaskDefinitionFamilies {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::ECS::ListTaskDefinitionFamilies', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub ListTaskDefinitions {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::ECS::ListTaskDefinitions', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub ListTasks {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::ECS::ListTasks', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub PutAccountSetting {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::ECS::PutAccountSetting', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub PutAccountSettingDefault {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::ECS::PutAccountSettingDefault', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub PutAttributes {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::ECS::PutAttributes', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub PutClusterCapacityProviders {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::ECS::PutClusterCapacityProviders', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub RegisterContainerInstance {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::ECS::RegisterContainerInstance', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub RegisterTaskDefinition {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::ECS::RegisterTaskDefinition', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub RunTask {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::ECS::RunTask', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub StartTask {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::ECS::StartTask', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub StopTask {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::ECS::StopTask', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub SubmitAttachmentStateChanges {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::ECS::SubmitAttachmentStateChanges', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub SubmitContainerStateChange {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::ECS::SubmitContainerStateChange', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub SubmitTaskStateChange {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::ECS::SubmitTaskStateChange', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub TagResource {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::ECS::TagResource', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub UntagResource {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::ECS::UntagResource', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub UpdateCapacityProvider {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateCapacityProvider', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub UpdateCluster {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateCluster', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub UpdateClusterSettings {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateClusterSettings', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub UpdateContainerAgent {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateContainerAgent', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub UpdateContainerInstancesState {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateContainerInstancesState', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub UpdateService {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateService', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub UpdateServicePrimaryTaskSet {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateServicePrimaryTaskSet', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub UpdateTaskSet {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::ECS::UpdateTaskSet', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278
279 sub ListAllAccountSettings {
280 my $self = shift;
281  
282 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
283 my $result = $self->ListAccountSettings(@_);
284 my $next_result = $result;
285  
286 if (not defined $callback) {
287 while ($next_result->nextToken) {
288 $next_result = $self->ListAccountSettings(@_, nextToken => $next_result->nextToken);
289 push @{ $result->settings }, @{ $next_result->settings };
290 }
291 return $result;
292 } else {
293 while ($result->nextToken) {
294 $callback->($_ => 'settings') foreach (@{ $result->settings });
295 $result = $self->ListAccountSettings(@_, nextToken => $result->nextToken);
296 }
297 $callback->($_ => 'settings') foreach (@{ $result->settings });
298 }
299  
300 return undef
301 }
302 sub ListAllAttributes {
303 my $self = shift;
304  
305 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
306 my $result = $self->ListAttributes(@_);
307 my $next_result = $result;
308  
309 if (not defined $callback) {
310 while ($next_result->nextToken) {
311 $next_result = $self->ListAttributes(@_, nextToken => $next_result->nextToken);
312 push @{ $result->attributes }, @{ $next_result->attributes };
313 }
314 return $result;
315 } else {
316 while ($result->nextToken) {
317 $callback->($_ => 'attributes') foreach (@{ $result->attributes });
318 $result = $self->ListAttributes(@_, nextToken => $result->nextToken);
319 }
320 $callback->($_ => 'attributes') foreach (@{ $result->attributes });
321 }
322  
323 return undef
324 }
325 sub ListAllClusters {
326 my $self = shift;
327  
328 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
329 my $result = $self->ListClusters(@_);
330 my $next_result = $result;
331  
332 if (not defined $callback) {
333 while ($next_result->nextToken) {
334 $next_result = $self->ListClusters(@_, nextToken => $next_result->nextToken);
335 push @{ $result->clusterArns }, @{ $next_result->clusterArns };
336 }
337 return $result;
338 } else {
339 while ($result->nextToken) {
340 $callback->($_ => 'clusterArns') foreach (@{ $result->clusterArns });
341 $result = $self->ListClusters(@_, nextToken => $result->nextToken);
342 }
343 $callback->($_ => 'clusterArns') foreach (@{ $result->clusterArns });
344 }
345  
346 return undef
347 }
348 sub ListAllContainerInstances {
349 my $self = shift;
350  
351 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
352 my $result = $self->ListContainerInstances(@_);
353 my $next_result = $result;
354  
355 if (not defined $callback) {
356 while ($next_result->nextToken) {
357 $next_result = $self->ListContainerInstances(@_, nextToken => $next_result->nextToken);
358 push @{ $result->containerInstanceArns }, @{ $next_result->containerInstanceArns };
359 }
360 return $result;
361 } else {
362 while ($result->nextToken) {
363 $callback->($_ => 'containerInstanceArns') foreach (@{ $result->containerInstanceArns });
364 $result = $self->ListContainerInstances(@_, nextToken => $result->nextToken);
365 }
366 $callback->($_ => 'containerInstanceArns') foreach (@{ $result->containerInstanceArns });
367 }
368  
369 return undef
370 }
371 sub ListAllServices {
372 my $self = shift;
373  
374 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
375 my $result = $self->ListServices(@_);
376 my $next_result = $result;
377  
378 if (not defined $callback) {
379 while ($next_result->nextToken) {
380 $next_result = $self->ListServices(@_, nextToken => $next_result->nextToken);
381 push @{ $result->serviceArns }, @{ $next_result->serviceArns };
382 }
383 return $result;
384 } else {
385 while ($result->nextToken) {
386 $callback->($_ => 'serviceArns') foreach (@{ $result->serviceArns });
387 $result = $self->ListServices(@_, nextToken => $result->nextToken);
388 }
389 $callback->($_ => 'serviceArns') foreach (@{ $result->serviceArns });
390 }
391  
392 return undef
393 }
394 sub ListAllTaskDefinitionFamilies {
395 my $self = shift;
396  
397 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
398 my $result = $self->ListTaskDefinitionFamilies(@_);
399 my $next_result = $result;
400  
401 if (not defined $callback) {
402 while ($next_result->nextToken) {
403 $next_result = $self->ListTaskDefinitionFamilies(@_, nextToken => $next_result->nextToken);
404 push @{ $result->families }, @{ $next_result->families };
405 }
406 return $result;
407 } else {
408 while ($result->nextToken) {
409 $callback->($_ => 'families') foreach (@{ $result->families });
410 $result = $self->ListTaskDefinitionFamilies(@_, nextToken => $result->nextToken);
411 }
412 $callback->($_ => 'families') foreach (@{ $result->families });
413 }
414  
415 return undef
416 }
417 sub ListAllTaskDefinitions {
418 my $self = shift;
419  
420 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
421 my $result = $self->ListTaskDefinitions(@_);
422 my $next_result = $result;
423  
424 if (not defined $callback) {
425 while ($next_result->nextToken) {
426 $next_result = $self->ListTaskDefinitions(@_, nextToken => $next_result->nextToken);
427 push @{ $result->taskDefinitionArns }, @{ $next_result->taskDefinitionArns };
428 }
429 return $result;
430 } else {
431 while ($result->nextToken) {
432 $callback->($_ => 'taskDefinitionArns') foreach (@{ $result->taskDefinitionArns });
433 $result = $self->ListTaskDefinitions(@_, nextToken => $result->nextToken);
434 }
435 $callback->($_ => 'taskDefinitionArns') foreach (@{ $result->taskDefinitionArns });
436 }
437  
438 return undef
439 }
440 sub ListAllTasks {
441 my $self = shift;
442  
443 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
444 my $result = $self->ListTasks(@_);
445 my $next_result = $result;
446  
447 if (not defined $callback) {
448 while ($next_result->nextToken) {
449 $next_result = $self->ListTasks(@_, nextToken => $next_result->nextToken);
450 push @{ $result->taskArns }, @{ $next_result->taskArns };
451 }
452 return $result;
453 } else {
454 while ($result->nextToken) {
455 $callback->($_ => 'taskArns') foreach (@{ $result->taskArns });
456 $result = $self->ListTasks(@_, nextToken => $result->nextToken);
457 }
458 $callback->($_ => 'taskArns') foreach (@{ $result->taskArns });
459 }
460  
461 return undef
462 }
463  
464  
465 sub operations { qw/CreateCapacityProvider CreateCluster CreateService CreateTaskSet DeleteAccountSetting DeleteAttributes DeleteCapacityProvider DeleteCluster DeleteService DeleteTaskSet DeregisterContainerInstance DeregisterTaskDefinition DescribeCapacityProviders DescribeClusters DescribeContainerInstances DescribeServices DescribeTaskDefinition DescribeTasks DescribeTaskSets DiscoverPollEndpoint ExecuteCommand ListAccountSettings ListAttributes ListClusters ListContainerInstances ListServices ListTagsForResource ListTaskDefinitionFamilies ListTaskDefinitions ListTasks PutAccountSetting PutAccountSettingDefault PutAttributes PutClusterCapacityProviders RegisterContainerInstance RegisterTaskDefinition RunTask StartTask StopTask SubmitAttachmentStateChanges SubmitContainerStateChange SubmitTaskStateChange TagResource UntagResource UpdateCapacityProvider UpdateCluster UpdateClusterSettings UpdateContainerAgent UpdateContainerInstancesState UpdateService UpdateServicePrimaryTaskSet UpdateTaskSet / }
466  
467 1;
468  
469 ### main pod documentation begin ###
470  
471 =head1 NAME
472  
473 Paws::ECS - Perl Interface to AWS Amazon EC2 Container Service
474  
475 =head1 SYNOPSIS
476  
477 use Paws;
478  
479 my $obj = Paws->service('ECS');
480 my $res = $obj->Method(
481 Arg1 => $val1,
482 Arg2 => [ 'V1', 'V2' ],
483 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
484 # of the arguments type
485 Arg3 => { Att1 => 'Val1' },
486 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
487 # the constructor of the arguments type
488 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
489 );
490  
491 =head1 DESCRIPTION
492  
493 Amazon Elastic Container Service
494  
495 Amazon Elastic Container Service (Amazon ECS) is a highly scalable,
496 fast, container management service that makes it easy to run, stop, and
497 manage Docker containers on a cluster. You can host your cluster on a
498 serverless infrastructure that is managed by Amazon ECS by launching
499 your services or tasks on AWS Fargate. For more control, you can host
500 your tasks on a cluster of Amazon Elastic Compute Cloud (Amazon EC2)
501 instances that you manage.
502  
503 Amazon ECS makes it easy to launch and stop container-based
504 applications with simple API calls, allows you to get the state of your
505 cluster from a centralized service, and gives you access to many
506 familiar Amazon EC2 features.
507  
508 You can use Amazon ECS to schedule the placement of containers across
509 your cluster based on your resource needs, isolation policies, and
510 availability requirements. Amazon ECS eliminates the need for you to
511 operate your own cluster management and configuration management
512 systems or worry about scaling your management infrastructure.
513  
514 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13>
515  
516  
517 =head1 METHODS
518  
519 =head2 CreateCapacityProvider
520  
521 =over
522  
523 =item AutoScalingGroupProvider => L<Paws::ECS::AutoScalingGroupProvider>
524  
525 =item Name => Str
526  
527 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
528  
529  
530 =back
531  
532 Each argument is described in detail in: L<Paws::ECS::CreateCapacityProvider>
533  
534 Returns: a L<Paws::ECS::CreateCapacityProviderResponse> instance
535  
536 Creates a new capacity provider. Capacity providers are associated with
537 an Amazon ECS cluster and are used in capacity provider strategies to
538 facilitate cluster auto scaling.
539  
540 Only capacity providers using an Auto Scaling group can be created.
541 Amazon ECS tasks on AWS Fargate use the C<FARGATE> and C<FARGATE_SPOT>
542 capacity providers which are already created and available to all
543 accounts in Regions supported by AWS Fargate.
544  
545  
546 =head2 CreateCluster
547  
548 =over
549  
550 =item [CapacityProviders => ArrayRef[Str|Undef]]
551  
552 =item [ClusterName => Str]
553  
554 =item [Configuration => L<Paws::ECS::ClusterConfiguration>]
555  
556 =item [DefaultCapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]]
557  
558 =item [Settings => ArrayRef[L<Paws::ECS::ClusterSetting>]]
559  
560 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
561  
562  
563 =back
564  
565 Each argument is described in detail in: L<Paws::ECS::CreateCluster>
566  
567 Returns: a L<Paws::ECS::CreateClusterResponse> instance
568  
569 Creates a new Amazon ECS cluster. By default, your account receives a
570 C<default> cluster when you launch your first container instance.
571 However, you can create your own cluster with a unique name with the
572 C<CreateCluster> action.
573  
574 When you call the CreateCluster API operation, Amazon ECS attempts to
575 create the Amazon ECS service-linked role for your account so that
576 required resources in other AWS services can be managed on your behalf.
577 However, if the IAM user that makes the call does not have permissions
578 to create the service-linked role, it is not created. For more
579 information, see Using Service-Linked Roles for Amazon ECS
580 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html)
581 in the I<Amazon Elastic Container Service Developer Guide>.
582  
583  
584 =head2 CreateService
585  
586 =over
587  
588 =item ServiceName => Str
589  
590 =item [CapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]]
591  
592 =item [ClientToken => Str]
593  
594 =item [Cluster => Str]
595  
596 =item [DeploymentConfiguration => L<Paws::ECS::DeploymentConfiguration>]
597  
598 =item [DeploymentController => L<Paws::ECS::DeploymentController>]
599  
600 =item [DesiredCount => Int]
601  
602 =item [EnableECSManagedTags => Bool]
603  
604 =item [EnableExecuteCommand => Bool]
605  
606 =item [HealthCheckGracePeriodSeconds => Int]
607  
608 =item [LaunchType => Str]
609  
610 =item [LoadBalancers => ArrayRef[L<Paws::ECS::LoadBalancer>]]
611  
612 =item [NetworkConfiguration => L<Paws::ECS::NetworkConfiguration>]
613  
614 =item [PlacementConstraints => ArrayRef[L<Paws::ECS::PlacementConstraint>]]
615  
616 =item [PlacementStrategy => ArrayRef[L<Paws::ECS::PlacementStrategy>]]
617  
618 =item [PlatformVersion => Str]
619  
620 =item [PropagateTags => Str]
621  
622 =item [Role => Str]
623  
624 =item [SchedulingStrategy => Str]
625  
626 =item [ServiceRegistries => ArrayRef[L<Paws::ECS::ServiceRegistry>]]
627  
628 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
629  
630 =item [TaskDefinition => Str]
631  
632  
633 =back
634  
635 Each argument is described in detail in: L<Paws::ECS::CreateService>
636  
637 Returns: a L<Paws::ECS::CreateServiceResponse> instance
638  
639 Runs and maintains a desired number of tasks from a specified task
640 definition. If the number of tasks running in a service drops below the
641 C<desiredCount>, Amazon ECS runs another copy of the task in the
642 specified cluster. To update an existing service, see the UpdateService
643 action.
644  
645 In addition to maintaining the desired count of tasks in your service,
646 you can optionally run your service behind one or more load balancers.
647 The load balancers distribute traffic across the tasks that are
648 associated with the service. For more information, see Service Load
649 Balancing
650 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html)
651 in the I<Amazon Elastic Container Service Developer Guide>.
652  
653 Tasks for services that I<do not> use a load balancer are considered
654 healthy if they're in the C<RUNNING> state. Tasks for services that
655 I<do> use a load balancer are considered healthy if they're in the
656 C<RUNNING> state and the container instance that they're hosted on is
657 reported as healthy by the load balancer.
658  
659 There are two service scheduler strategies available:
660  
661 =over
662  
663 =item *
664  
665 C<REPLICA> - The replica scheduling strategy places and maintains the
666 desired number of tasks across your cluster. By default, the service
667 scheduler spreads tasks across Availability Zones. You can use task
668 placement strategies and constraints to customize task placement
669 decisions. For more information, see Service Scheduler Concepts
670 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)
671 in the I<Amazon Elastic Container Service Developer Guide>.
672  
673 =item *
674  
675 C<DAEMON> - The daemon scheduling strategy deploys exactly one task on
676 each active container instance that meets all of the task placement
677 constraints that you specify in your cluster. The service scheduler
678 also evaluates the task placement constraints for running tasks and
679 will stop tasks that do not meet the placement constraints. When using
680 this strategy, you don't need to specify a desired number of tasks, a
681 task placement strategy, or use Service Auto Scaling policies. For more
682 information, see Service Scheduler Concepts
683 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)
684 in the I<Amazon Elastic Container Service Developer Guide>.
685  
686 =back
687  
688 You can optionally specify a deployment configuration for your service.
689 The deployment is triggered by changing properties, such as the task
690 definition or the desired count of a service, with an UpdateService
691 operation. The default value for a replica service for
692 C<minimumHealthyPercent> is 100%. The default value for a daemon
693 service for C<minimumHealthyPercent> is 0%.
694  
695 If a service is using the C<ECS> deployment controller, the minimum
696 healthy percent represents a lower limit on the number of tasks in a
697 service that must remain in the C<RUNNING> state during a deployment,
698 as a percentage of the desired number of tasks (rounded up to the
699 nearest integer), and while any container instances are in the
700 C<DRAINING> state if the service contains tasks using the EC2 launch
701 type. This parameter enables you to deploy without using additional
702 cluster capacity. For example, if your service has a desired number of
703 four tasks and a minimum healthy percent of 50%, the scheduler might
704 stop two existing tasks to free up cluster capacity before starting two
705 new tasks. Tasks for services that I<do not> use a load balancer are
706 considered healthy if they're in the C<RUNNING> state. Tasks for
707 services that I<do> use a load balancer are considered healthy if
708 they're in the C<RUNNING> state and they're reported as healthy by the
709 load balancer. The default value for minimum healthy percent is 100%.
710  
711 If a service is using the C<ECS> deployment controller, the B<maximum
712 percent> parameter represents an upper limit on the number of tasks in
713 a service that are allowed in the C<RUNNING> or C<PENDING> state during
714 a deployment, as a percentage of the desired number of tasks (rounded
715 down to the nearest integer), and while any container instances are in
716 the C<DRAINING> state if the service contains tasks using the EC2
717 launch type. This parameter enables you to define the deployment batch
718 size. For example, if your service has a desired number of four tasks
719 and a maximum percent value of 200%, the scheduler may start four new
720 tasks before stopping the four older tasks (provided that the cluster
721 resources required to do this are available). The default value for
722 maximum percent is 200%.
723  
724 If a service is using either the C<CODE_DEPLOY> or C<EXTERNAL>
725 deployment controller types and tasks that use the EC2 launch type, the
726 B<minimum healthy percent> and B<maximum percent> values are used only
727 to define the lower and upper limit on the number of the tasks in the
728 service that remain in the C<RUNNING> state while the container
729 instances are in the C<DRAINING> state. If the tasks in the service use
730 the Fargate launch type, the minimum healthy percent and maximum
731 percent values aren't used, although they're currently visible when
732 describing your service.
733  
734 When creating a service that uses the C<EXTERNAL> deployment
735 controller, you can specify only parameters that aren't controlled at
736 the task set level. The only required parameter is the service name.
737 You control your services using the CreateTaskSet operation. For more
738 information, see Amazon ECS Deployment Types
739 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
740 in the I<Amazon Elastic Container Service Developer Guide>.
741  
742 When the service scheduler launches new tasks, it determines task
743 placement in your cluster using the following logic:
744  
745 =over
746  
747 =item *
748  
749 Determine which of the container instances in your cluster can support
750 your service's task definition (for example, they have the required
751 CPU, memory, ports, and container instance attributes).
752  
753 =item *
754  
755 By default, the service scheduler attempts to balance tasks across
756 Availability Zones in this manner (although you can choose a different
757 placement strategy) with the C<placementStrategy> parameter):
758  
759 =over
760  
761 =item *
762  
763 Sort the valid container instances, giving priority to instances that
764 have the fewest number of running tasks for this service in their
765 respective Availability Zone. For example, if zone A has one running
766 service task and zones B and C each have zero, valid container
767 instances in either zone B or C are considered optimal for placement.
768  
769 =item *
770  
771 Place the new service task on a valid container instance in an optimal
772 Availability Zone (based on the previous steps), favoring container
773 instances with the fewest number of running tasks for this service.
774  
775 =back
776  
777 =back
778  
779  
780  
781 =head2 CreateTaskSet
782  
783 =over
784  
785 =item Cluster => Str
786  
787 =item Service => Str
788  
789 =item TaskDefinition => Str
790  
791 =item [CapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]]
792  
793 =item [ClientToken => Str]
794  
795 =item [ExternalId => Str]
796  
797 =item [LaunchType => Str]
798  
799 =item [LoadBalancers => ArrayRef[L<Paws::ECS::LoadBalancer>]]
800  
801 =item [NetworkConfiguration => L<Paws::ECS::NetworkConfiguration>]
802  
803 =item [PlatformVersion => Str]
804  
805 =item [Scale => L<Paws::ECS::Scale>]
806  
807 =item [ServiceRegistries => ArrayRef[L<Paws::ECS::ServiceRegistry>]]
808  
809 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
810  
811  
812 =back
813  
814 Each argument is described in detail in: L<Paws::ECS::CreateTaskSet>
815  
816 Returns: a L<Paws::ECS::CreateTaskSetResponse> instance
817  
818 Create a task set in the specified cluster and service. This is used
819 when a service uses the C<EXTERNAL> deployment controller type. For
820 more information, see Amazon ECS Deployment Types
821 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
822 in the I<Amazon Elastic Container Service Developer Guide>.
823  
824  
825 =head2 DeleteAccountSetting
826  
827 =over
828  
829 =item Name => Str
830  
831 =item [PrincipalArn => Str]
832  
833  
834 =back
835  
836 Each argument is described in detail in: L<Paws::ECS::DeleteAccountSetting>
837  
838 Returns: a L<Paws::ECS::DeleteAccountSettingResponse> instance
839  
840 Disables an account setting for a specified IAM user, IAM role, or the
841 root user for an account.
842  
843  
844 =head2 DeleteAttributes
845  
846 =over
847  
848 =item Attributes => ArrayRef[L<Paws::ECS::Attribute>]
849  
850 =item [Cluster => Str]
851  
852  
853 =back
854  
855 Each argument is described in detail in: L<Paws::ECS::DeleteAttributes>
856  
857 Returns: a L<Paws::ECS::DeleteAttributesResponse> instance
858  
859 Deletes one or more custom attributes from an Amazon ECS resource.
860  
861  
862 =head2 DeleteCapacityProvider
863  
864 =over
865  
866 =item CapacityProvider => Str
867  
868  
869 =back
870  
871 Each argument is described in detail in: L<Paws::ECS::DeleteCapacityProvider>
872  
873 Returns: a L<Paws::ECS::DeleteCapacityProviderResponse> instance
874  
875 Deletes the specified capacity provider.
876  
877 The C<FARGATE> and C<FARGATE_SPOT> capacity providers are reserved and
878 cannot be deleted. You can disassociate them from a cluster using
879 either the PutClusterCapacityProviders API or by deleting the cluster.
880  
881 Prior to a capacity provider being deleted, the capacity provider must
882 be removed from the capacity provider strategy from all services. The
883 UpdateService API can be used to remove a capacity provider from a
884 service's capacity provider strategy. When updating a service, the
885 C<forceNewDeployment> option can be used to ensure that any tasks using
886 the Amazon EC2 instance capacity provided by the capacity provider are
887 transitioned to use the capacity from the remaining capacity providers.
888 Only capacity providers that are not associated with a cluster can be
889 deleted. To remove a capacity provider from a cluster, you can either
890 use PutClusterCapacityProviders or delete the cluster.
891  
892  
893 =head2 DeleteCluster
894  
895 =over
896  
897 =item Cluster => Str
898  
899  
900 =back
901  
902 Each argument is described in detail in: L<Paws::ECS::DeleteCluster>
903  
904 Returns: a L<Paws::ECS::DeleteClusterResponse> instance
905  
906 Deletes the specified cluster. The cluster will transition to the
907 C<INACTIVE> state. Clusters with an C<INACTIVE> status may remain
908 discoverable in your account for a period of time. However, this
909 behavior is subject to change in the future, so you should not rely on
910 C<INACTIVE> clusters persisting.
911  
912 You must deregister all container instances from this cluster before
913 you may delete it. You can list the container instances in a cluster
914 with ListContainerInstances and deregister them with
915 DeregisterContainerInstance.
916  
917  
918 =head2 DeleteService
919  
920 =over
921  
922 =item Service => Str
923  
924 =item [Cluster => Str]
925  
926 =item [Force => Bool]
927  
928  
929 =back
930  
931 Each argument is described in detail in: L<Paws::ECS::DeleteService>
932  
933 Returns: a L<Paws::ECS::DeleteServiceResponse> instance
934  
935 Deletes a specified service within a cluster. You can delete a service
936 if you have no running tasks in it and the desired task count is zero.
937 If the service is actively maintaining tasks, you cannot delete it, and
938 you must update the service to a desired task count of zero. For more
939 information, see UpdateService.
940  
941 When you delete a service, if there are still running tasks that
942 require cleanup, the service status moves from C<ACTIVE> to
943 C<DRAINING>, and the service is no longer visible in the console or in
944 the ListServices API operation. After all tasks have transitioned to
945 either C<STOPPING> or C<STOPPED> status, the service status moves from
946 C<DRAINING> to C<INACTIVE>. Services in the C<DRAINING> or C<INACTIVE>
947 status can still be viewed with the DescribeServices API operation.
948 However, in the future, C<INACTIVE> services may be cleaned up and
949 purged from Amazon ECS record keeping, and DescribeServices calls on
950 those services return a C<ServiceNotFoundException> error.
951  
952 If you attempt to create a new service with the same name as an
953 existing service in either C<ACTIVE> or C<DRAINING> status, you receive
954 an error.
955  
956  
957 =head2 DeleteTaskSet
958  
959 =over
960  
961 =item Cluster => Str
962  
963 =item Service => Str
964  
965 =item TaskSet => Str
966  
967 =item [Force => Bool]
968  
969  
970 =back
971  
972 Each argument is described in detail in: L<Paws::ECS::DeleteTaskSet>
973  
974 Returns: a L<Paws::ECS::DeleteTaskSetResponse> instance
975  
976 Deletes a specified task set within a service. This is used when a
977 service uses the C<EXTERNAL> deployment controller type. For more
978 information, see Amazon ECS Deployment Types
979 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
980 in the I<Amazon Elastic Container Service Developer Guide>.
981  
982  
983 =head2 DeregisterContainerInstance
984  
985 =over
986  
987 =item ContainerInstance => Str
988  
989 =item [Cluster => Str]
990  
991 =item [Force => Bool]
992  
993  
994 =back
995  
996 Each argument is described in detail in: L<Paws::ECS::DeregisterContainerInstance>
997  
998 Returns: a L<Paws::ECS::DeregisterContainerInstanceResponse> instance
999  
1000 Deregisters an Amazon ECS container instance from the specified
1001 cluster. This instance is no longer available to run tasks.
1002  
1003 If you intend to use the container instance for some other purpose
1004 after deregistration, you should stop all of the tasks running on the
1005 container instance before deregistration. That prevents any orphaned
1006 tasks from consuming resources.
1007  
1008 Deregistering a container instance removes the instance from a cluster,
1009 but it does not terminate the EC2 instance. If you are finished using
1010 the instance, be sure to terminate it in the Amazon EC2 console to stop
1011 billing.
1012  
1013 If you terminate a running container instance, Amazon ECS automatically
1014 deregisters the instance from your cluster (stopped container instances
1015 or instances with disconnected agents are not automatically
1016 deregistered when terminated).
1017  
1018  
1019 =head2 DeregisterTaskDefinition
1020  
1021 =over
1022  
1023 =item TaskDefinition => Str
1024  
1025  
1026 =back
1027  
1028 Each argument is described in detail in: L<Paws::ECS::DeregisterTaskDefinition>
1029  
1030 Returns: a L<Paws::ECS::DeregisterTaskDefinitionResponse> instance
1031  
1032 Deregisters the specified task definition by family and revision. Upon
1033 deregistration, the task definition is marked as C<INACTIVE>. Existing
1034 tasks and services that reference an C<INACTIVE> task definition
1035 continue to run without disruption. Existing services that reference an
1036 C<INACTIVE> task definition can still scale up or down by modifying the
1037 service's desired count.
1038  
1039 You cannot use an C<INACTIVE> task definition to run new tasks or
1040 create new services, and you cannot update an existing service to
1041 reference an C<INACTIVE> task definition. However, there may be up to a
1042 10-minute window following deregistration where these restrictions have
1043 not yet taken effect.
1044  
1045 At this time, C<INACTIVE> task definitions remain discoverable in your
1046 account indefinitely. However, this behavior is subject to change in
1047 the future, so you should not rely on C<INACTIVE> task definitions
1048 persisting beyond the lifecycle of any associated tasks and services.
1049  
1050  
1051 =head2 DescribeCapacityProviders
1052  
1053 =over
1054  
1055 =item [CapacityProviders => ArrayRef[Str|Undef]]
1056  
1057 =item [Include => ArrayRef[Str|Undef]]
1058  
1059 =item [MaxResults => Int]
1060  
1061 =item [NextToken => Str]
1062  
1063  
1064 =back
1065  
1066 Each argument is described in detail in: L<Paws::ECS::DescribeCapacityProviders>
1067  
1068 Returns: a L<Paws::ECS::DescribeCapacityProvidersResponse> instance
1069  
1070 Describes one or more of your capacity providers.
1071  
1072  
1073 =head2 DescribeClusters
1074  
1075 =over
1076  
1077 =item [Clusters => ArrayRef[Str|Undef]]
1078  
1079 =item [Include => ArrayRef[Str|Undef]]
1080  
1081  
1082 =back
1083  
1084 Each argument is described in detail in: L<Paws::ECS::DescribeClusters>
1085  
1086 Returns: a L<Paws::ECS::DescribeClustersResponse> instance
1087  
1088 Describes one or more of your clusters.
1089  
1090  
1091 =head2 DescribeContainerInstances
1092  
1093 =over
1094  
1095 =item ContainerInstances => ArrayRef[Str|Undef]
1096  
1097 =item [Cluster => Str]
1098  
1099 =item [Include => ArrayRef[Str|Undef]]
1100  
1101  
1102 =back
1103  
1104 Each argument is described in detail in: L<Paws::ECS::DescribeContainerInstances>
1105  
1106 Returns: a L<Paws::ECS::DescribeContainerInstancesResponse> instance
1107  
1108 Describes one or more container instances. Returns metadata about each
1109 container instance requested.
1110  
1111  
1112 =head2 DescribeServices
1113  
1114 =over
1115  
1116 =item Services => ArrayRef[Str|Undef]
1117  
1118 =item [Cluster => Str]
1119  
1120 =item [Include => ArrayRef[Str|Undef]]
1121  
1122  
1123 =back
1124  
1125 Each argument is described in detail in: L<Paws::ECS::DescribeServices>
1126  
1127 Returns: a L<Paws::ECS::DescribeServicesResponse> instance
1128  
1129 Describes the specified services running in your cluster.
1130  
1131  
1132 =head2 DescribeTaskDefinition
1133  
1134 =over
1135  
1136 =item TaskDefinition => Str
1137  
1138 =item [Include => ArrayRef[Str|Undef]]
1139  
1140  
1141 =back
1142  
1143 Each argument is described in detail in: L<Paws::ECS::DescribeTaskDefinition>
1144  
1145 Returns: a L<Paws::ECS::DescribeTaskDefinitionResponse> instance
1146  
1147 Describes a task definition. You can specify a C<family> and
1148 C<revision> to find information about a specific task definition, or
1149 you can simply specify the family to find the latest C<ACTIVE> revision
1150 in that family.
1151  
1152 You can only describe C<INACTIVE> task definitions while an active task
1153 or service references them.
1154  
1155  
1156 =head2 DescribeTasks
1157  
1158 =over
1159  
1160 =item Tasks => ArrayRef[Str|Undef]
1161  
1162 =item [Cluster => Str]
1163  
1164 =item [Include => ArrayRef[Str|Undef]]
1165  
1166  
1167 =back
1168  
1169 Each argument is described in detail in: L<Paws::ECS::DescribeTasks>
1170  
1171 Returns: a L<Paws::ECS::DescribeTasksResponse> instance
1172  
1173 Describes a specified task or tasks.
1174  
1175  
1176 =head2 DescribeTaskSets
1177  
1178 =over
1179  
1180 =item Cluster => Str
1181  
1182 =item Service => Str
1183  
1184 =item [Include => ArrayRef[Str|Undef]]
1185  
1186 =item [TaskSets => ArrayRef[Str|Undef]]
1187  
1188  
1189 =back
1190  
1191 Each argument is described in detail in: L<Paws::ECS::DescribeTaskSets>
1192  
1193 Returns: a L<Paws::ECS::DescribeTaskSetsResponse> instance
1194  
1195 Describes the task sets in the specified cluster and service. This is
1196 used when a service uses the C<EXTERNAL> deployment controller type.
1197 For more information, see Amazon ECS Deployment Types
1198 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
1199 in the I<Amazon Elastic Container Service Developer Guide>.
1200  
1201  
1202 =head2 DiscoverPollEndpoint
1203  
1204 =over
1205  
1206 =item [Cluster => Str]
1207  
1208 =item [ContainerInstance => Str]
1209  
1210  
1211 =back
1212  
1213 Each argument is described in detail in: L<Paws::ECS::DiscoverPollEndpoint>
1214  
1215 Returns: a L<Paws::ECS::DiscoverPollEndpointResponse> instance
1216  
1217 This action is only used by the Amazon ECS agent, and it is not
1218 intended for use outside of the agent.
1219  
1220 Returns an endpoint for the Amazon ECS agent to poll for updates.
1221  
1222  
1223 =head2 ExecuteCommand
1224  
1225 =over
1226  
1227 =item Command => Str
1228  
1229 =item Interactive => Bool
1230  
1231 =item Task => Str
1232  
1233 =item [Cluster => Str]
1234  
1235 =item [Container => Str]
1236  
1237  
1238 =back
1239  
1240 Each argument is described in detail in: L<Paws::ECS::ExecuteCommand>
1241  
1242 Returns: a L<Paws::ECS::ExecuteCommandResponse> instance
1243  
1244 Runs a command remotely on a container within a task.
1245  
1246  
1247 =head2 ListAccountSettings
1248  
1249 =over
1250  
1251 =item [EffectiveSettings => Bool]
1252  
1253 =item [MaxResults => Int]
1254  
1255 =item [Name => Str]
1256  
1257 =item [NextToken => Str]
1258  
1259 =item [PrincipalArn => Str]
1260  
1261 =item [Value => Str]
1262  
1263  
1264 =back
1265  
1266 Each argument is described in detail in: L<Paws::ECS::ListAccountSettings>
1267  
1268 Returns: a L<Paws::ECS::ListAccountSettingsResponse> instance
1269  
1270 Lists the account settings for a specified principal.
1271  
1272  
1273 =head2 ListAttributes
1274  
1275 =over
1276  
1277 =item TargetType => Str
1278  
1279 =item [AttributeName => Str]
1280  
1281 =item [AttributeValue => Str]
1282  
1283 =item [Cluster => Str]
1284  
1285 =item [MaxResults => Int]
1286  
1287 =item [NextToken => Str]
1288  
1289  
1290 =back
1291  
1292 Each argument is described in detail in: L<Paws::ECS::ListAttributes>
1293  
1294 Returns: a L<Paws::ECS::ListAttributesResponse> instance
1295  
1296 Lists the attributes for Amazon ECS resources within a specified target
1297 type and cluster. When you specify a target type and cluster,
1298 C<ListAttributes> returns a list of attribute objects, one for each
1299 attribute on each resource. You can filter the list of results to a
1300 single attribute name to only return results that have that name. You
1301 can also filter the results by attribute name and value, for example,
1302 to see which container instances in a cluster are running a Linux AMI
1303 (C<ecs.os-type=linux>).
1304  
1305  
1306 =head2 ListClusters
1307  
1308 =over
1309  
1310 =item [MaxResults => Int]
1311  
1312 =item [NextToken => Str]
1313  
1314  
1315 =back
1316  
1317 Each argument is described in detail in: L<Paws::ECS::ListClusters>
1318  
1319 Returns: a L<Paws::ECS::ListClustersResponse> instance
1320  
1321 Returns a list of existing clusters.
1322  
1323  
1324 =head2 ListContainerInstances
1325  
1326 =over
1327  
1328 =item [Cluster => Str]
1329  
1330 =item [Filter => Str]
1331  
1332 =item [MaxResults => Int]
1333  
1334 =item [NextToken => Str]
1335  
1336 =item [Status => Str]
1337  
1338  
1339 =back
1340  
1341 Each argument is described in detail in: L<Paws::ECS::ListContainerInstances>
1342  
1343 Returns: a L<Paws::ECS::ListContainerInstancesResponse> instance
1344  
1345 Returns a list of container instances in a specified cluster. You can
1346 filter the results of a C<ListContainerInstances> operation with
1347 cluster query language statements inside the C<filter> parameter. For
1348 more information, see Cluster Query Language
1349 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html)
1350 in the I<Amazon Elastic Container Service Developer Guide>.
1351  
1352  
1353 =head2 ListServices
1354  
1355 =over
1356  
1357 =item [Cluster => Str]
1358  
1359 =item [LaunchType => Str]
1360  
1361 =item [MaxResults => Int]
1362  
1363 =item [NextToken => Str]
1364  
1365 =item [SchedulingStrategy => Str]
1366  
1367  
1368 =back
1369  
1370 Each argument is described in detail in: L<Paws::ECS::ListServices>
1371  
1372 Returns: a L<Paws::ECS::ListServicesResponse> instance
1373  
1374 Returns a list of services. You can filter the results by cluster,
1375 launch type, and scheduling strategy.
1376  
1377  
1378 =head2 ListTagsForResource
1379  
1380 =over
1381  
1382 =item ResourceArn => Str
1383  
1384  
1385 =back
1386  
1387 Each argument is described in detail in: L<Paws::ECS::ListTagsForResource>
1388  
1389 Returns: a L<Paws::ECS::ListTagsForResourceResponse> instance
1390  
1391 List the tags for an Amazon ECS resource.
1392  
1393  
1394 =head2 ListTaskDefinitionFamilies
1395  
1396 =over
1397  
1398 =item [FamilyPrefix => Str]
1399  
1400 =item [MaxResults => Int]
1401  
1402 =item [NextToken => Str]
1403  
1404 =item [Status => Str]
1405  
1406  
1407 =back
1408  
1409 Each argument is described in detail in: L<Paws::ECS::ListTaskDefinitionFamilies>
1410  
1411 Returns: a L<Paws::ECS::ListTaskDefinitionFamiliesResponse> instance
1412  
1413 Returns a list of task definition families that are registered to your
1414 account (which may include task definition families that no longer have
1415 any C<ACTIVE> task definition revisions).
1416  
1417 You can filter out task definition families that do not contain any
1418 C<ACTIVE> task definition revisions by setting the C<status> parameter
1419 to C<ACTIVE>. You can also filter the results with the C<familyPrefix>
1420 parameter.
1421  
1422  
1423 =head2 ListTaskDefinitions
1424  
1425 =over
1426  
1427 =item [FamilyPrefix => Str]
1428  
1429 =item [MaxResults => Int]
1430  
1431 =item [NextToken => Str]
1432  
1433 =item [Sort => Str]
1434  
1435 =item [Status => Str]
1436  
1437  
1438 =back
1439  
1440 Each argument is described in detail in: L<Paws::ECS::ListTaskDefinitions>
1441  
1442 Returns: a L<Paws::ECS::ListTaskDefinitionsResponse> instance
1443  
1444 Returns a list of task definitions that are registered to your account.
1445 You can filter the results by family name with the C<familyPrefix>
1446 parameter or by status with the C<status> parameter.
1447  
1448  
1449 =head2 ListTasks
1450  
1451 =over
1452  
1453 =item [Cluster => Str]
1454  
1455 =item [ContainerInstance => Str]
1456  
1457 =item [DesiredStatus => Str]
1458  
1459 =item [Family => Str]
1460  
1461 =item [LaunchType => Str]
1462  
1463 =item [MaxResults => Int]
1464  
1465 =item [NextToken => Str]
1466  
1467 =item [ServiceName => Str]
1468  
1469 =item [StartedBy => Str]
1470  
1471  
1472 =back
1473  
1474 Each argument is described in detail in: L<Paws::ECS::ListTasks>
1475  
1476 Returns: a L<Paws::ECS::ListTasksResponse> instance
1477  
1478 Returns a list of tasks. You can filter the results by cluster, task
1479 definition family, container instance, launch type, what IAM principal
1480 started the task, or by the desired status of the task.
1481  
1482 Recently stopped tasks might appear in the returned results. Currently,
1483 stopped tasks appear in the returned results for at least one hour.
1484  
1485  
1486 =head2 PutAccountSetting
1487  
1488 =over
1489  
1490 =item Name => Str
1491  
1492 =item Value => Str
1493  
1494 =item [PrincipalArn => Str]
1495  
1496  
1497 =back
1498  
1499 Each argument is described in detail in: L<Paws::ECS::PutAccountSetting>
1500  
1501 Returns: a L<Paws::ECS::PutAccountSettingResponse> instance
1502  
1503 Modifies an account setting. Account settings are set on a per-Region
1504 basis.
1505  
1506 If you change the account setting for the root user, the default
1507 settings for all of the IAM users and roles for which no individual
1508 account setting has been specified are reset. For more information, see
1509 Account Settings
1510 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html)
1511 in the I<Amazon Elastic Container Service Developer Guide>.
1512  
1513 When C<serviceLongArnFormat>, C<taskLongArnFormat>, or
1514 C<containerInstanceLongArnFormat> are specified, the Amazon Resource
1515 Name (ARN) and resource ID format of the resource type for a specified
1516 IAM user, IAM role, or the root user for an account is affected. The
1517 opt-in and opt-out account setting must be set for each Amazon ECS
1518 resource separately. The ARN and resource ID format of a resource will
1519 be defined by the opt-in status of the IAM user or role that created
1520 the resource. You must enable this setting to use Amazon ECS features
1521 such as resource tagging.
1522  
1523 When C<awsvpcTrunking> is specified, the elastic network interface
1524 (ENI) limit for any new container instances that support the feature is
1525 changed. If C<awsvpcTrunking> is enabled, any new container instances
1526 that support the feature are launched have the increased ENI limits
1527 available to them. For more information, see Elastic Network Interface
1528 Trunking
1529 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html)
1530 in the I<Amazon Elastic Container Service Developer Guide>.
1531  
1532 When C<containerInsights> is specified, the default setting indicating
1533 whether CloudWatch Container Insights is enabled for your clusters is
1534 changed. If C<containerInsights> is enabled, any new clusters that are
1535 created will have Container Insights enabled unless you disable it
1536 during cluster creation. For more information, see CloudWatch Container
1537 Insights
1538 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html)
1539 in the I<Amazon Elastic Container Service Developer Guide>.
1540  
1541  
1542 =head2 PutAccountSettingDefault
1543  
1544 =over
1545  
1546 =item Name => Str
1547  
1548 =item Value => Str
1549  
1550  
1551 =back
1552  
1553 Each argument is described in detail in: L<Paws::ECS::PutAccountSettingDefault>
1554  
1555 Returns: a L<Paws::ECS::PutAccountSettingDefaultResponse> instance
1556  
1557 Modifies an account setting for all IAM users on an account for whom no
1558 individual account setting has been specified. Account settings are set
1559 on a per-Region basis.
1560  
1561  
1562 =head2 PutAttributes
1563  
1564 =over
1565  
1566 =item Attributes => ArrayRef[L<Paws::ECS::Attribute>]
1567  
1568 =item [Cluster => Str]
1569  
1570  
1571 =back
1572  
1573 Each argument is described in detail in: L<Paws::ECS::PutAttributes>
1574  
1575 Returns: a L<Paws::ECS::PutAttributesResponse> instance
1576  
1577 Create or update an attribute on an Amazon ECS resource. If the
1578 attribute does not exist, it is created. If the attribute exists, its
1579 value is replaced with the specified value. To delete an attribute, use
1580 DeleteAttributes. For more information, see Attributes
1581 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes)
1582 in the I<Amazon Elastic Container Service Developer Guide>.
1583  
1584  
1585 =head2 PutClusterCapacityProviders
1586  
1587 =over
1588  
1589 =item CapacityProviders => ArrayRef[Str|Undef]
1590  
1591 =item Cluster => Str
1592  
1593 =item DefaultCapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]
1594  
1595  
1596 =back
1597  
1598 Each argument is described in detail in: L<Paws::ECS::PutClusterCapacityProviders>
1599  
1600 Returns: a L<Paws::ECS::PutClusterCapacityProvidersResponse> instance
1601  
1602 Modifies the available capacity providers and the default capacity
1603 provider strategy for a cluster.
1604  
1605 You must specify both the available capacity providers and a default
1606 capacity provider strategy for the cluster. If the specified cluster
1607 has existing capacity providers associated with it, you must specify
1608 all existing capacity providers in addition to any new ones you want to
1609 add. Any existing capacity providers associated with a cluster that are
1610 omitted from a PutClusterCapacityProviders API call will be
1611 disassociated with the cluster. You can only disassociate an existing
1612 capacity provider from a cluster if it's not being used by any existing
1613 tasks.
1614  
1615 When creating a service or running a task on a cluster, if no capacity
1616 provider or launch type is specified, then the cluster's default
1617 capacity provider strategy is used. It is recommended to define a
1618 default capacity provider strategy for your cluster, however you may
1619 specify an empty array (C<[]>) to bypass defining a default strategy.
1620  
1621  
1622 =head2 RegisterContainerInstance
1623  
1624 =over
1625  
1626 =item [Attributes => ArrayRef[L<Paws::ECS::Attribute>]]
1627  
1628 =item [Cluster => Str]
1629  
1630 =item [ContainerInstanceArn => Str]
1631  
1632 =item [InstanceIdentityDocument => Str]
1633  
1634 =item [InstanceIdentityDocumentSignature => Str]
1635  
1636 =item [PlatformDevices => ArrayRef[L<Paws::ECS::PlatformDevice>]]
1637  
1638 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
1639  
1640 =item [TotalResources => ArrayRef[L<Paws::ECS::Resource>]]
1641  
1642 =item [VersionInfo => L<Paws::ECS::VersionInfo>]
1643  
1644  
1645 =back
1646  
1647 Each argument is described in detail in: L<Paws::ECS::RegisterContainerInstance>
1648  
1649 Returns: a L<Paws::ECS::RegisterContainerInstanceResponse> instance
1650  
1651 This action is only used by the Amazon ECS agent, and it is not
1652 intended for use outside of the agent.
1653  
1654 Registers an EC2 instance into the specified cluster. This instance
1655 becomes available to place containers on.
1656  
1657  
1658 =head2 RegisterTaskDefinition
1659  
1660 =over
1661  
1662 =item ContainerDefinitions => ArrayRef[L<Paws::ECS::ContainerDefinition>]
1663  
1664 =item Family => Str
1665  
1666 =item [Cpu => Str]
1667  
1668 =item [EphemeralStorage => L<Paws::ECS::EphemeralStorage>]
1669  
1670 =item [ExecutionRoleArn => Str]
1671  
1672 =item [InferenceAccelerators => ArrayRef[L<Paws::ECS::InferenceAccelerator>]]
1673  
1674 =item [IpcMode => Str]
1675  
1676 =item [Memory => Str]
1677  
1678 =item [NetworkMode => Str]
1679  
1680 =item [PidMode => Str]
1681  
1682 =item [PlacementConstraints => ArrayRef[L<Paws::ECS::TaskDefinitionPlacementConstraint>]]
1683  
1684 =item [ProxyConfiguration => L<Paws::ECS::ProxyConfiguration>]
1685  
1686 =item [RequiresCompatibilities => ArrayRef[Str|Undef]]
1687  
1688 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
1689  
1690 =item [TaskRoleArn => Str]
1691  
1692 =item [Volumes => ArrayRef[L<Paws::ECS::Volume>]]
1693  
1694  
1695 =back
1696  
1697 Each argument is described in detail in: L<Paws::ECS::RegisterTaskDefinition>
1698  
1699 Returns: a L<Paws::ECS::RegisterTaskDefinitionResponse> instance
1700  
1701 Registers a new task definition from the supplied C<family> and
1702 C<containerDefinitions>. Optionally, you can add data volumes to your
1703 containers with the C<volumes> parameter. For more information about
1704 task definition parameters and defaults, see Amazon ECS Task
1705 Definitions
1706 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html)
1707 in the I<Amazon Elastic Container Service Developer Guide>.
1708  
1709 You can specify an IAM role for your task with the C<taskRoleArn>
1710 parameter. When you specify an IAM role for a task, its containers can
1711 then use the latest versions of the AWS CLI or SDKs to make API
1712 requests to the AWS services that are specified in the IAM policy
1713 associated with the role. For more information, see IAM Roles for Tasks
1714 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
1715 in the I<Amazon Elastic Container Service Developer Guide>.
1716  
1717 You can specify a Docker networking mode for the containers in your
1718 task definition with the C<networkMode> parameter. The available
1719 network modes correspond to those described in Network settings
1720 (https://docs.docker.com/engine/reference/run/#/network-settings) in
1721 the Docker run reference. If you specify the C<awsvpc> network mode,
1722 the task is allocated an elastic network interface, and you must
1723 specify a NetworkConfiguration when you create a service or run a task
1724 with the task definition. For more information, see Task Networking
1725 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html)
1726 in the I<Amazon Elastic Container Service Developer Guide>.
1727  
1728  
1729 =head2 RunTask
1730  
1731 =over
1732  
1733 =item TaskDefinition => Str
1734  
1735 =item [CapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]]
1736  
1737 =item [Cluster => Str]
1738  
1739 =item [Count => Int]
1740  
1741 =item [EnableECSManagedTags => Bool]
1742  
1743 =item [EnableExecuteCommand => Bool]
1744  
1745 =item [Group => Str]
1746  
1747 =item [LaunchType => Str]
1748  
1749 =item [NetworkConfiguration => L<Paws::ECS::NetworkConfiguration>]
1750  
1751 =item [Overrides => L<Paws::ECS::TaskOverride>]
1752  
1753 =item [PlacementConstraints => ArrayRef[L<Paws::ECS::PlacementConstraint>]]
1754  
1755 =item [PlacementStrategy => ArrayRef[L<Paws::ECS::PlacementStrategy>]]
1756  
1757 =item [PlatformVersion => Str]
1758  
1759 =item [PropagateTags => Str]
1760  
1761 =item [ReferenceId => Str]
1762  
1763 =item [StartedBy => Str]
1764  
1765 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
1766  
1767  
1768 =back
1769  
1770 Each argument is described in detail in: L<Paws::ECS::RunTask>
1771  
1772 Returns: a L<Paws::ECS::RunTaskResponse> instance
1773  
1774 Starts a new task using the specified task definition.
1775  
1776 You can allow Amazon ECS to place tasks for you, or you can customize
1777 how Amazon ECS places tasks using placement constraints and placement
1778 strategies. For more information, see Scheduling Tasks
1779 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html)
1780 in the I<Amazon Elastic Container Service Developer Guide>.
1781  
1782 Alternatively, you can use StartTask to use your own scheduler or place
1783 tasks manually on specific container instances.
1784  
1785 The Amazon ECS API follows an eventual consistency model, due to the
1786 distributed nature of the system supporting the API. This means that
1787 the result of an API command you run that affects your Amazon ECS
1788 resources might not be immediately visible to all subsequent commands
1789 you run. Keep this in mind when you carry out an API command that
1790 immediately follows a previous API command.
1791  
1792 To manage eventual consistency, you can do the following:
1793  
1794 =over
1795  
1796 =item *
1797  
1798 Confirm the state of the resource before you run a command to modify
1799 it. Run the DescribeTasks command using an exponential backoff
1800 algorithm to ensure that you allow enough time for the previous command
1801 to propagate through the system. To do this, run the DescribeTasks
1802 command repeatedly, starting with a couple of seconds of wait time and
1803 increasing gradually up to five minutes of wait time.
1804  
1805 =item *
1806  
1807 Add wait time between subsequent commands, even if the DescribeTasks
1808 command returns an accurate response. Apply an exponential backoff
1809 algorithm starting with a couple of seconds of wait time, and increase
1810 gradually up to about five minutes of wait time.
1811  
1812 =back
1813  
1814  
1815  
1816 =head2 StartTask
1817  
1818 =over
1819  
1820 =item ContainerInstances => ArrayRef[Str|Undef]
1821  
1822 =item TaskDefinition => Str
1823  
1824 =item [Cluster => Str]
1825  
1826 =item [EnableECSManagedTags => Bool]
1827  
1828 =item [EnableExecuteCommand => Bool]
1829  
1830 =item [Group => Str]
1831  
1832 =item [NetworkConfiguration => L<Paws::ECS::NetworkConfiguration>]
1833  
1834 =item [Overrides => L<Paws::ECS::TaskOverride>]
1835  
1836 =item [PropagateTags => Str]
1837  
1838 =item [ReferenceId => Str]
1839  
1840 =item [StartedBy => Str]
1841  
1842 =item [Tags => ArrayRef[L<Paws::ECS::Tag>]]
1843  
1844  
1845 =back
1846  
1847 Each argument is described in detail in: L<Paws::ECS::StartTask>
1848  
1849 Returns: a L<Paws::ECS::StartTaskResponse> instance
1850  
1851 Starts a new task from the specified task definition on the specified
1852 container instance or instances.
1853  
1854 Alternatively, you can use RunTask to place tasks for you. For more
1855 information, see Scheduling Tasks
1856 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html)
1857 in the I<Amazon Elastic Container Service Developer Guide>.
1858  
1859  
1860 =head2 StopTask
1861  
1862 =over
1863  
1864 =item Task => Str
1865  
1866 =item [Cluster => Str]
1867  
1868 =item [Reason => Str]
1869  
1870  
1871 =back
1872  
1873 Each argument is described in detail in: L<Paws::ECS::StopTask>
1874  
1875 Returns: a L<Paws::ECS::StopTaskResponse> instance
1876  
1877 Stops a running task. Any tags associated with the task will be
1878 deleted.
1879  
1880 When StopTask is called on a task, the equivalent of C<docker stop> is
1881 issued to the containers running in the task. This results in a
1882 C<SIGTERM> value and a default 30-second timeout, after which the
1883 C<SIGKILL> value is sent and the containers are forcibly stopped. If
1884 the container handles the C<SIGTERM> value gracefully and exits within
1885 30 seconds from receiving it, no C<SIGKILL> value is sent.
1886  
1887 The default 30-second timeout can be configured on the Amazon ECS
1888 container agent with the C<ECS_CONTAINER_STOP_TIMEOUT> variable. For
1889 more information, see Amazon ECS Container Agent Configuration
1890 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
1891 in the I<Amazon Elastic Container Service Developer Guide>.
1892  
1893  
1894 =head2 SubmitAttachmentStateChanges
1895  
1896 =over
1897  
1898 =item Attachments => ArrayRef[L<Paws::ECS::AttachmentStateChange>]
1899  
1900 =item [Cluster => Str]
1901  
1902  
1903 =back
1904  
1905 Each argument is described in detail in: L<Paws::ECS::SubmitAttachmentStateChanges>
1906  
1907 Returns: a L<Paws::ECS::SubmitAttachmentStateChangesResponse> instance
1908  
1909 This action is only used by the Amazon ECS agent, and it is not
1910 intended for use outside of the agent.
1911  
1912 Sent to acknowledge that an attachment changed states.
1913  
1914  
1915 =head2 SubmitContainerStateChange
1916  
1917 =over
1918  
1919 =item [Cluster => Str]
1920  
1921 =item [ContainerName => Str]
1922  
1923 =item [ExitCode => Int]
1924  
1925 =item [NetworkBindings => ArrayRef[L<Paws::ECS::NetworkBinding>]]
1926  
1927 =item [Reason => Str]
1928  
1929 =item [RuntimeId => Str]
1930  
1931 =item [Status => Str]
1932  
1933 =item [Task => Str]
1934  
1935  
1936 =back
1937  
1938 Each argument is described in detail in: L<Paws::ECS::SubmitContainerStateChange>
1939  
1940 Returns: a L<Paws::ECS::SubmitContainerStateChangeResponse> instance
1941  
1942 This action is only used by the Amazon ECS agent, and it is not
1943 intended for use outside of the agent.
1944  
1945 Sent to acknowledge that a container changed states.
1946  
1947  
1948 =head2 SubmitTaskStateChange
1949  
1950 =over
1951  
1952 =item [Attachments => ArrayRef[L<Paws::ECS::AttachmentStateChange>]]
1953  
1954 =item [Cluster => Str]
1955  
1956 =item [Containers => ArrayRef[L<Paws::ECS::ContainerStateChange>]]
1957  
1958 =item [ExecutionStoppedAt => Str]
1959  
1960 =item [ManagedAgents => ArrayRef[L<Paws::ECS::ManagedAgentStateChange>]]
1961  
1962 =item [PullStartedAt => Str]
1963  
1964 =item [PullStoppedAt => Str]
1965  
1966 =item [Reason => Str]
1967  
1968 =item [Status => Str]
1969  
1970 =item [Task => Str]
1971  
1972  
1973 =back
1974  
1975 Each argument is described in detail in: L<Paws::ECS::SubmitTaskStateChange>
1976  
1977 Returns: a L<Paws::ECS::SubmitTaskStateChangeResponse> instance
1978  
1979 This action is only used by the Amazon ECS agent, and it is not
1980 intended for use outside of the agent.
1981  
1982 Sent to acknowledge that a task changed states.
1983  
1984  
1985 =head2 TagResource
1986  
1987 =over
1988  
1989 =item ResourceArn => Str
1990  
1991 =item Tags => ArrayRef[L<Paws::ECS::Tag>]
1992  
1993  
1994 =back
1995  
1996 Each argument is described in detail in: L<Paws::ECS::TagResource>
1997  
1998 Returns: a L<Paws::ECS::TagResourceResponse> instance
1999  
2000 Associates the specified tags to a resource with the specified
2001 C<resourceArn>. If existing tags on a resource are not specified in the
2002 request parameters, they are not changed. When a resource is deleted,
2003 the tags associated with that resource are deleted as well.
2004  
2005  
2006 =head2 UntagResource
2007  
2008 =over
2009  
2010 =item ResourceArn => Str
2011  
2012 =item TagKeys => ArrayRef[Str|Undef]
2013  
2014  
2015 =back
2016  
2017 Each argument is described in detail in: L<Paws::ECS::UntagResource>
2018  
2019 Returns: a L<Paws::ECS::UntagResourceResponse> instance
2020  
2021 Deletes specified tags from a resource.
2022  
2023  
2024 =head2 UpdateCapacityProvider
2025  
2026 =over
2027  
2028 =item AutoScalingGroupProvider => L<Paws::ECS::AutoScalingGroupProviderUpdate>
2029  
2030 =item Name => Str
2031  
2032  
2033 =back
2034  
2035 Each argument is described in detail in: L<Paws::ECS::UpdateCapacityProvider>
2036  
2037 Returns: a L<Paws::ECS::UpdateCapacityProviderResponse> instance
2038  
2039 Modifies the parameters for a capacity provider.
2040  
2041  
2042 =head2 UpdateCluster
2043  
2044 =over
2045  
2046 =item Cluster => Str
2047  
2048 =item [Configuration => L<Paws::ECS::ClusterConfiguration>]
2049  
2050 =item [Settings => ArrayRef[L<Paws::ECS::ClusterSetting>]]
2051  
2052  
2053 =back
2054  
2055 Each argument is described in detail in: L<Paws::ECS::UpdateCluster>
2056  
2057 Returns: a L<Paws::ECS::UpdateClusterResponse> instance
2058  
2059 Updates the cluster.
2060  
2061  
2062 =head2 UpdateClusterSettings
2063  
2064 =over
2065  
2066 =item Cluster => Str
2067  
2068 =item Settings => ArrayRef[L<Paws::ECS::ClusterSetting>]
2069  
2070  
2071 =back
2072  
2073 Each argument is described in detail in: L<Paws::ECS::UpdateClusterSettings>
2074  
2075 Returns: a L<Paws::ECS::UpdateClusterSettingsResponse> instance
2076  
2077 Modifies the settings to use for a cluster.
2078  
2079  
2080 =head2 UpdateContainerAgent
2081  
2082 =over
2083  
2084 =item ContainerInstance => Str
2085  
2086 =item [Cluster => Str]
2087  
2088  
2089 =back
2090  
2091 Each argument is described in detail in: L<Paws::ECS::UpdateContainerAgent>
2092  
2093 Returns: a L<Paws::ECS::UpdateContainerAgentResponse> instance
2094  
2095 Updates the Amazon ECS container agent on a specified container
2096 instance. Updating the Amazon ECS container agent does not interrupt
2097 running tasks or services on the container instance. The process for
2098 updating the agent differs depending on whether your container instance
2099 was launched with the Amazon ECS-optimized AMI or another operating
2100 system.
2101  
2102 The C<UpdateContainerAgent> API isn't supported for container instances
2103 using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update
2104 the container agent, you can update the C<ecs-init> package which will
2105 update the agent. For more information, see Updating the Amazon ECS
2106 container agent
2107 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html)
2108 in the I<Amazon Elastic Container Service Developer Guide>.
2109  
2110 The C<UpdateContainerAgent> API requires an Amazon ECS-optimized AMI or
2111 Amazon Linux AMI with the C<ecs-init> service installed and running.
2112 For help updating the Amazon ECS container agent on other operating
2113 systems, see Manually updating the Amazon ECS container agent
2114 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent)
2115 in the I<Amazon Elastic Container Service Developer Guide>.
2116  
2117  
2118 =head2 UpdateContainerInstancesState
2119  
2120 =over
2121  
2122 =item ContainerInstances => ArrayRef[Str|Undef]
2123  
2124 =item Status => Str
2125  
2126 =item [Cluster => Str]
2127  
2128  
2129 =back
2130  
2131 Each argument is described in detail in: L<Paws::ECS::UpdateContainerInstancesState>
2132  
2133 Returns: a L<Paws::ECS::UpdateContainerInstancesStateResponse> instance
2134  
2135 Modifies the status of an Amazon ECS container instance.
2136  
2137 Once a container instance has reached an C<ACTIVE> state, you can
2138 change the status of a container instance to C<DRAINING> to manually
2139 remove an instance from a cluster, for example to perform system
2140 updates, update the Docker daemon, or scale down the cluster size.
2141  
2142 A container instance cannot be changed to C<DRAINING> until it has
2143 reached an C<ACTIVE> status. If the instance is in any other status, an
2144 error will be received.
2145  
2146 When you set a container instance to C<DRAINING>, Amazon ECS prevents
2147 new tasks from being scheduled for placement on the container instance
2148 and replacement service tasks are started on other container instances
2149 in the cluster if the resources are available. Service tasks on the
2150 container instance that are in the C<PENDING> state are stopped
2151 immediately.
2152  
2153 Service tasks on the container instance that are in the C<RUNNING>
2154 state are stopped and replaced according to the service's deployment
2155 configuration parameters, C<minimumHealthyPercent> and
2156 C<maximumPercent>. You can change the deployment configuration of your
2157 service using UpdateService.
2158  
2159 =over
2160  
2161 =item *
2162  
2163 If C<minimumHealthyPercent> is below 100%, the scheduler can ignore
2164 C<desiredCount> temporarily during task replacement. For example,
2165 C<desiredCount> is four tasks, a minimum of 50% allows the scheduler to
2166 stop two existing tasks before starting two new tasks. If the minimum
2167 is 100%, the service scheduler can't remove existing tasks until the
2168 replacement tasks are considered healthy. Tasks for services that do
2169 not use a load balancer are considered healthy if they are in the
2170 C<RUNNING> state. Tasks for services that use a load balancer are
2171 considered healthy if they are in the C<RUNNING> state and the
2172 container instance they are hosted on is reported as healthy by the
2173 load balancer.
2174  
2175 =item *
2176  
2177 The C<maximumPercent> parameter represents an upper limit on the number
2178 of running tasks during task replacement, which enables you to define
2179 the replacement batch size. For example, if C<desiredCount> is four
2180 tasks, a maximum of 200% starts four new tasks before stopping the four
2181 tasks to be drained, provided that the cluster resources required to do
2182 this are available. If the maximum is 100%, then replacement tasks
2183 can't start until the draining tasks have stopped.
2184  
2185 =back
2186  
2187 Any C<PENDING> or C<RUNNING> tasks that do not belong to a service are
2188 not affected. You must wait for them to finish or stop them manually.
2189  
2190 A container instance has completed draining when it has no more
2191 C<RUNNING> tasks. You can verify this using ListTasks.
2192  
2193 When a container instance has been drained, you can set a container
2194 instance to C<ACTIVE> status and once it has reached that status the
2195 Amazon ECS scheduler can begin scheduling tasks on the instance again.
2196  
2197  
2198 =head2 UpdateService
2199  
2200 =over
2201  
2202 =item Service => Str
2203  
2204 =item [CapacityProviderStrategy => ArrayRef[L<Paws::ECS::CapacityProviderStrategyItem>]]
2205  
2206 =item [Cluster => Str]
2207  
2208 =item [DeploymentConfiguration => L<Paws::ECS::DeploymentConfiguration>]
2209  
2210 =item [DesiredCount => Int]
2211  
2212 =item [EnableExecuteCommand => Bool]
2213  
2214 =item [ForceNewDeployment => Bool]
2215  
2216 =item [HealthCheckGracePeriodSeconds => Int]
2217  
2218 =item [NetworkConfiguration => L<Paws::ECS::NetworkConfiguration>]
2219  
2220 =item [PlacementConstraints => ArrayRef[L<Paws::ECS::PlacementConstraint>]]
2221  
2222 =item [PlacementStrategy => ArrayRef[L<Paws::ECS::PlacementStrategy>]]
2223  
2224 =item [PlatformVersion => Str]
2225  
2226 =item [TaskDefinition => Str]
2227  
2228  
2229 =back
2230  
2231 Each argument is described in detail in: L<Paws::ECS::UpdateService>
2232  
2233 Returns: a L<Paws::ECS::UpdateServiceResponse> instance
2234  
2235 Updating the task placement strategies and constraints on an Amazon ECS
2236 service remains in preview and is a Beta Service as defined by and
2237 subject to the Beta Service Participation Service Terms located at
2238 https://aws.amazon.com/service-terms
2239 (https://aws.amazon.com/service-terms) ("Beta Terms"). These Beta Terms
2240 apply to your participation in this preview.
2241  
2242 Modifies the parameters of a service.
2243  
2244 For services using the rolling update (C<ECS>) deployment controller,
2245 the desired count, deployment configuration, network configuration,
2246 task placement constraints and strategies, or task definition used can
2247 be updated.
2248  
2249 For services using the blue/green (C<CODE_DEPLOY>) deployment
2250 controller, only the desired count, deployment configuration, task
2251 placement constraints and strategies, and health check grace period can
2252 be updated using this API. If the network configuration, platform
2253 version, or task definition need to be updated, a new AWS CodeDeploy
2254 deployment should be created. For more information, see
2255 CreateDeployment
2256 (https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html)
2257 in the I<AWS CodeDeploy API Reference>.
2258  
2259 For services using an external deployment controller, you can update
2260 only the desired count, task placement constraints and strategies, and
2261 health check grace period using this API. If the launch type, load
2262 balancer, network configuration, platform version, or task definition
2263 need to be updated, you should create a new task set. For more
2264 information, see CreateTaskSet.
2265  
2266 You can add to or subtract from the number of instantiations of a task
2267 definition in a service by specifying the cluster that the service is
2268 running in and a new C<desiredCount> parameter.
2269  
2270 If you have updated the Docker image of your application, you can
2271 create a new task definition with that image and deploy it to your
2272 service. The service scheduler uses the minimum healthy percent and
2273 maximum percent parameters (in the service's deployment configuration)
2274 to determine the deployment strategy.
2275  
2276 If your updated Docker image uses the same tag as what is in the
2277 existing task definition for your service (for example,
2278 C<my_image:latest>), you do not need to create a new revision of your
2279 task definition. You can update the service using the
2280 C<forceNewDeployment> option. The new tasks launched by the deployment
2281 pull the current image/tag combination from your repository when they
2282 start.
2283  
2284 You can also update the deployment configuration of a service. When a
2285 deployment is triggered by updating the task definition of a service,
2286 the service scheduler uses the deployment configuration parameters,
2287 C<minimumHealthyPercent> and C<maximumPercent>, to determine the
2288 deployment strategy.
2289  
2290 =over
2291  
2292 =item *
2293  
2294 If C<minimumHealthyPercent> is below 100%, the scheduler can ignore
2295 C<desiredCount> temporarily during a deployment. For example, if
2296 C<desiredCount> is four tasks, a minimum of 50% allows the scheduler to
2297 stop two existing tasks before starting two new tasks. Tasks for
2298 services that do not use a load balancer are considered healthy if they
2299 are in the C<RUNNING> state. Tasks for services that use a load
2300 balancer are considered healthy if they are in the C<RUNNING> state and
2301 the container instance they are hosted on is reported as healthy by the
2302 load balancer.
2303  
2304 =item *
2305  
2306 The C<maximumPercent> parameter represents an upper limit on the number
2307 of running tasks during a deployment, which enables you to define the
2308 deployment batch size. For example, if C<desiredCount> is four tasks, a
2309 maximum of 200% starts four new tasks before stopping the four older
2310 tasks (provided that the cluster resources required to do this are
2311 available).
2312  
2313 =back
2314  
2315 When UpdateService stops a task during a deployment, the equivalent of
2316 C<docker stop> is issued to the containers running in the task. This
2317 results in a C<SIGTERM> and a 30-second timeout, after which C<SIGKILL>
2318 is sent and the containers are forcibly stopped. If the container
2319 handles the C<SIGTERM> gracefully and exits within 30 seconds from
2320 receiving it, no C<SIGKILL> is sent.
2321  
2322 When the service scheduler launches new tasks, it determines task
2323 placement in your cluster with the following logic:
2324  
2325 =over
2326  
2327 =item *
2328  
2329 Determine which of the container instances in your cluster can support
2330 your service's task definition (for example, they have the required
2331 CPU, memory, ports, and container instance attributes).
2332  
2333 =item *
2334  
2335 By default, the service scheduler attempts to balance tasks across
2336 Availability Zones in this manner (although you can choose a different
2337 placement strategy):
2338  
2339 =over
2340  
2341 =item *
2342  
2343 Sort the valid container instances by the fewest number of running
2344 tasks for this service in the same Availability Zone as the instance.
2345 For example, if zone A has one running service task and zones B and C
2346 each have zero, valid container instances in either zone B or C are
2347 considered optimal for placement.
2348  
2349 =item *
2350  
2351 Place the new service task on a valid container instance in an optimal
2352 Availability Zone (based on the previous steps), favoring container
2353 instances with the fewest number of running tasks for this service.
2354  
2355 =back
2356  
2357 =back
2358  
2359 When the service scheduler stops running tasks, it attempts to maintain
2360 balance across the Availability Zones in your cluster using the
2361 following logic:
2362  
2363 =over
2364  
2365 =item *
2366  
2367 Sort the container instances by the largest number of running tasks for
2368 this service in the same Availability Zone as the instance. For
2369 example, if zone A has one running service task and zones B and C each
2370 have two, container instances in either zone B or C are considered
2371 optimal for termination.
2372  
2373 =item *
2374  
2375 Stop the task on a container instance in an optimal Availability Zone
2376 (based on the previous steps), favoring container instances with the
2377 largest number of running tasks for this service.
2378  
2379 =back
2380  
2381  
2382  
2383 =head2 UpdateServicePrimaryTaskSet
2384  
2385 =over
2386  
2387 =item Cluster => Str
2388  
2389 =item PrimaryTaskSet => Str
2390  
2391 =item Service => Str
2392  
2393  
2394 =back
2395  
2396 Each argument is described in detail in: L<Paws::ECS::UpdateServicePrimaryTaskSet>
2397  
2398 Returns: a L<Paws::ECS::UpdateServicePrimaryTaskSetResponse> instance
2399  
2400 Modifies which task set in a service is the primary task set. Any
2401 parameters that are updated on the primary task set in a service will
2402 transition to the service. This is used when a service uses the
2403 C<EXTERNAL> deployment controller type. For more information, see
2404 Amazon ECS Deployment Types
2405 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
2406 in the I<Amazon Elastic Container Service Developer Guide>.
2407  
2408  
2409 =head2 UpdateTaskSet
2410  
2411 =over
2412  
2413 =item Cluster => Str
2414  
2415 =item Scale => L<Paws::ECS::Scale>
2416  
2417 =item Service => Str
2418  
2419 =item TaskSet => Str
2420  
2421  
2422 =back
2423  
2424 Each argument is described in detail in: L<Paws::ECS::UpdateTaskSet>
2425  
2426 Returns: a L<Paws::ECS::UpdateTaskSetResponse> instance
2427  
2428 Modifies a task set. This is used when a service uses the C<EXTERNAL>
2429 deployment controller type. For more information, see Amazon ECS
2430 Deployment Types
2431 (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)
2432 in the I<Amazon Elastic Container Service Developer Guide>.
2433  
2434  
2435  
2436  
2437 =head1 PAGINATORS
2438  
2439 Paginator methods are helpers that repetively call methods that return partial results
2440  
2441 =head2 ListAllAccountSettings(sub { },[EffectiveSettings => Bool, MaxResults => Int, Name => Str, NextToken => Str, PrincipalArn => Str, Value => Str])
2442  
2443 =head2 ListAllAccountSettings([EffectiveSettings => Bool, MaxResults => Int, Name => Str, NextToken => Str, PrincipalArn => Str, Value => Str])
2444  
2445  
2446 If passed a sub as first parameter, it will call the sub for each element found in :
2447  
2448 - settings, passing the object as the first parameter, and the string 'settings' as the second parameter
2449  
2450 If not, it will return a a L<Paws::ECS::ListAccountSettingsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2451  
2452  
2453 =head2 ListAllAttributes(sub { },TargetType => Str, [AttributeName => Str, AttributeValue => Str, Cluster => Str, MaxResults => Int, NextToken => Str])
2454  
2455 =head2 ListAllAttributes(TargetType => Str, [AttributeName => Str, AttributeValue => Str, Cluster => Str, MaxResults => Int, NextToken => Str])
2456  
2457  
2458 If passed a sub as first parameter, it will call the sub for each element found in :
2459  
2460 - attributes, passing the object as the first parameter, and the string 'attributes' as the second parameter
2461  
2462 If not, it will return a a L<Paws::ECS::ListAttributesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2463  
2464  
2465 =head2 ListAllClusters(sub { },[MaxResults => Int, NextToken => Str])
2466  
2467 =head2 ListAllClusters([MaxResults => Int, NextToken => Str])
2468  
2469  
2470 If passed a sub as first parameter, it will call the sub for each element found in :
2471  
2472 - clusterArns, passing the object as the first parameter, and the string 'clusterArns' as the second parameter
2473  
2474 If not, it will return a a L<Paws::ECS::ListClustersResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2475  
2476  
2477 =head2 ListAllContainerInstances(sub { },[Cluster => Str, Filter => Str, MaxResults => Int, NextToken => Str, Status => Str])
2478  
2479 =head2 ListAllContainerInstances([Cluster => Str, Filter => Str, MaxResults => Int, NextToken => Str, Status => Str])
2480  
2481  
2482 If passed a sub as first parameter, it will call the sub for each element found in :
2483  
2484 - containerInstanceArns, passing the object as the first parameter, and the string 'containerInstanceArns' as the second parameter
2485  
2486 If not, it will return a a L<Paws::ECS::ListContainerInstancesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2487  
2488  
2489 =head2 ListAllServices(sub { },[Cluster => Str, LaunchType => Str, MaxResults => Int, NextToken => Str, SchedulingStrategy => Str])
2490  
2491 =head2 ListAllServices([Cluster => Str, LaunchType => Str, MaxResults => Int, NextToken => Str, SchedulingStrategy => Str])
2492  
2493  
2494 If passed a sub as first parameter, it will call the sub for each element found in :
2495  
2496 - serviceArns, passing the object as the first parameter, and the string 'serviceArns' as the second parameter
2497  
2498 If not, it will return a a L<Paws::ECS::ListServicesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2499  
2500  
2501 =head2 ListAllTaskDefinitionFamilies(sub { },[FamilyPrefix => Str, MaxResults => Int, NextToken => Str, Status => Str])
2502  
2503 =head2 ListAllTaskDefinitionFamilies([FamilyPrefix => Str, MaxResults => Int, NextToken => Str, Status => Str])
2504  
2505  
2506 If passed a sub as first parameter, it will call the sub for each element found in :
2507  
2508 - families, passing the object as the first parameter, and the string 'families' as the second parameter
2509  
2510 If not, it will return a a L<Paws::ECS::ListTaskDefinitionFamiliesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2511  
2512  
2513 =head2 ListAllTaskDefinitions(sub { },[FamilyPrefix => Str, MaxResults => Int, NextToken => Str, Sort => Str, Status => Str])
2514  
2515 =head2 ListAllTaskDefinitions([FamilyPrefix => Str, MaxResults => Int, NextToken => Str, Sort => Str, Status => Str])
2516  
2517  
2518 If passed a sub as first parameter, it will call the sub for each element found in :
2519  
2520 - taskDefinitionArns, passing the object as the first parameter, and the string 'taskDefinitionArns' as the second parameter
2521  
2522 If not, it will return a a L<Paws::ECS::ListTaskDefinitionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2523  
2524  
2525 =head2 ListAllTasks(sub { },[Cluster => Str, ContainerInstance => Str, DesiredStatus => Str, Family => Str, LaunchType => Str, MaxResults => Int, NextToken => Str, ServiceName => Str, StartedBy => Str])
2526  
2527 =head2 ListAllTasks([Cluster => Str, ContainerInstance => Str, DesiredStatus => Str, Family => Str, LaunchType => Str, MaxResults => Int, NextToken => Str, ServiceName => Str, StartedBy => Str])
2528  
2529  
2530 If passed a sub as first parameter, it will call the sub for each element found in :
2531  
2532 - taskArns, passing the object as the first parameter, and the string 'taskArns' as the second parameter
2533  
2534 If not, it will return a a L<Paws::ECS::ListTasksResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2535  
2536  
2537  
2538  
2539  
2540 =head1 SEE ALSO
2541  
2542 This service class forms part of L<Paws>
2543  
2544 =head1 BUGS and CONTRIBUTIONS
2545  
2546 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
2547  
2548 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
2549  
2550 =cut
2551