blib/lib/Paws/EKS.pm untested

filter: Statementstmt 0.0% 0 / 249 Branchbran 0.0% 0 / 28 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 45 Podpod 0.0% 0 / 44 totaltotal 0.0% 0 / 366 CC 15 SCAR 17.2
CC
15
Cov
0%
DescribeAllAddonVersions
12.0
ListAllAddons
12.0
ListAllClusters
12.0
CRAP 5.6
1 package Paws::EKS;
2 use Moose;
3 sub service { 'eks' }
4 sub signing_name { 'eks' }
5 sub version { '2017-11-01' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub AssociateEncryptionConfig {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::EKS::AssociateEncryptionConfig', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub AssociateIdentityProviderConfig {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::EKS::AssociateIdentityProviderConfig', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateAddon {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::EKS::CreateAddon', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub CreateCluster {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::EKS::CreateCluster', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub CreateFargateProfile {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::EKS::CreateFargateProfile', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub CreateNodegroup {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::EKS::CreateNodegroup', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DeleteAddon {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::EKS::DeleteAddon', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub DeleteCluster {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::EKS::DeleteCluster', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub DeleteFargateProfile {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::EKS::DeleteFargateProfile', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub DeleteNodegroup {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::EKS::DeleteNodegroup', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub DescribeAddon {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeAddon', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub DescribeAddonVersions {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeAddonVersions', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub DescribeCluster {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeCluster', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub DescribeFargateProfile {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeFargateProfile', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub DescribeIdentityProviderConfig {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeIdentityProviderConfig', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub DescribeNodegroup {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeNodegroup', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub DescribeUpdate {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::EKS::DescribeUpdate', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub DisassociateIdentityProviderConfig {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::EKS::DisassociateIdentityProviderConfig', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub ListAddons {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::EKS::ListAddons', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub ListClusters {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::EKS::ListClusters', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub ListFargateProfiles {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::EKS::ListFargateProfiles', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub ListIdentityProviderConfigs {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::EKS::ListIdentityProviderConfigs', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub ListNodegroups {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::EKS::ListNodegroups', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub ListTagsForResource {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::EKS::ListTagsForResource', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub ListUpdates {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::EKS::ListUpdates', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub TagResource {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::EKS::TagResource', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147 sub UntagResource {
148 my $self = shift;
149 my $call_object = $self->new_with_coercions('Paws::EKS::UntagResource', @_);
150 return $self->caller->do_call($self, $call_object);
151 }
152 sub UpdateAddon {
153 my $self = shift;
154 my $call_object = $self->new_with_coercions('Paws::EKS::UpdateAddon', @_);
155 return $self->caller->do_call($self, $call_object);
156 }
157 sub UpdateClusterConfig {
158 my $self = shift;
159 my $call_object = $self->new_with_coercions('Paws::EKS::UpdateClusterConfig', @_);
160 return $self->caller->do_call($self, $call_object);
161 }
162 sub UpdateClusterVersion {
163 my $self = shift;
164 my $call_object = $self->new_with_coercions('Paws::EKS::UpdateClusterVersion', @_);
165 return $self->caller->do_call($self, $call_object);
166 }
167 sub UpdateNodegroupConfig {
168 my $self = shift;
169 my $call_object = $self->new_with_coercions('Paws::EKS::UpdateNodegroupConfig', @_);
170 return $self->caller->do_call($self, $call_object);
171 }
172 sub UpdateNodegroupVersion {
173 my $self = shift;
174 my $call_object = $self->new_with_coercions('Paws::EKS::UpdateNodegroupVersion', @_);
175 return $self->caller->do_call($self, $call_object);
176 }
177
178 sub DescribeAllAddonVersions {
179 my $self = shift;
180  
181 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
182 my $result = $self->DescribeAddonVersions(@_);
183 my $next_result = $result;
184  
185 if (not defined $callback) {
186 while ($next_result->nextToken) {
187 $next_result = $self->DescribeAddonVersions(@_, nextToken => $next_result->nextToken);
188 push @{ $result->addons }, @{ $next_result->addons };
189 }
190 return $result;
191 } else {
192 while ($result->nextToken) {
193 $callback->($_ => 'addons') foreach (@{ $result->addons });
194 $result = $self->DescribeAddonVersions(@_, nextToken => $result->nextToken);
195 }
196 $callback->($_ => 'addons') foreach (@{ $result->addons });
197 }
198  
199 return undef
200 }
201 sub ListAllAddons {
202 my $self = shift;
203  
204 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
205 my $result = $self->ListAddons(@_);
206 my $next_result = $result;
207  
208 if (not defined $callback) {
209 while ($next_result->nextToken) {
210 $next_result = $self->ListAddons(@_, nextToken => $next_result->nextToken);
211 push @{ $result->addons }, @{ $next_result->addons };
212 }
213 return $result;
214 } else {
215 while ($result->nextToken) {
216 $callback->($_ => 'addons') foreach (@{ $result->addons });
217 $result = $self->ListAddons(@_, nextToken => $result->nextToken);
218 }
219 $callback->($_ => 'addons') foreach (@{ $result->addons });
220 }
221  
222 return undef
223 }
224 sub ListAllClusters {
225 my $self = shift;
226  
227 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
228 my $result = $self->ListClusters(@_);
229 my $next_result = $result;
230  
231 if (not defined $callback) {
232 while ($next_result->nextToken) {
233 $next_result = $self->ListClusters(@_, nextToken => $next_result->nextToken);
234 push @{ $result->clusters }, @{ $next_result->clusters };
235 }
236 return $result;
237 } else {
238 while ($result->nextToken) {
239 $callback->($_ => 'clusters') foreach (@{ $result->clusters });
240 $result = $self->ListClusters(@_, nextToken => $result->nextToken);
241 }
242 $callback->($_ => 'clusters') foreach (@{ $result->clusters });
243 }
244  
245 return undef
246 }
247 sub ListAllFargateProfiles {
248 my $self = shift;
249  
250 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
251 my $result = $self->ListFargateProfiles(@_);
252 my $next_result = $result;
253  
254 if (not defined $callback) {
255 while ($next_result->nextToken) {
256 $next_result = $self->ListFargateProfiles(@_, nextToken => $next_result->nextToken);
257 push @{ $result->fargateProfileNames }, @{ $next_result->fargateProfileNames };
258 }
259 return $result;
260 } else {
261 while ($result->nextToken) {
262 $callback->($_ => 'fargateProfileNames') foreach (@{ $result->fargateProfileNames });
263 $result = $self->ListFargateProfiles(@_, nextToken => $result->nextToken);
264 }
265 $callback->($_ => 'fargateProfileNames') foreach (@{ $result->fargateProfileNames });
266 }
267  
268 return undef
269 }
270 sub ListAllIdentityProviderConfigs {
271 my $self = shift;
272  
273 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
274 my $result = $self->ListIdentityProviderConfigs(@_);
275 my $next_result = $result;
276  
277 if (not defined $callback) {
278 while ($next_result->nextToken) {
279 $next_result = $self->ListIdentityProviderConfigs(@_, nextToken => $next_result->nextToken);
280 push @{ $result->identityProviderConfigs }, @{ $next_result->identityProviderConfigs };
281 }
282 return $result;
283 } else {
284 while ($result->nextToken) {
285 $callback->($_ => 'identityProviderConfigs') foreach (@{ $result->identityProviderConfigs });
286 $result = $self->ListIdentityProviderConfigs(@_, nextToken => $result->nextToken);
287 }
288 $callback->($_ => 'identityProviderConfigs') foreach (@{ $result->identityProviderConfigs });
289 }
290  
291 return undef
292 }
293 sub ListAllNodegroups {
294 my $self = shift;
295  
296 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
297 my $result = $self->ListNodegroups(@_);
298 my $next_result = $result;
299  
300 if (not defined $callback) {
301 while ($next_result->nextToken) {
302 $next_result = $self->ListNodegroups(@_, nextToken => $next_result->nextToken);
303 push @{ $result->nodegroups }, @{ $next_result->nodegroups };
304 }
305 return $result;
306 } else {
307 while ($result->nextToken) {
308 $callback->($_ => 'nodegroups') foreach (@{ $result->nodegroups });
309 $result = $self->ListNodegroups(@_, nextToken => $result->nextToken);
310 }
311 $callback->($_ => 'nodegroups') foreach (@{ $result->nodegroups });
312 }
313  
314 return undef
315 }
316 sub ListAllUpdates {
317 my $self = shift;
318  
319 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
320 my $result = $self->ListUpdates(@_);
321 my $next_result = $result;
322  
323 if (not defined $callback) {
324 while ($next_result->nextToken) {
325 $next_result = $self->ListUpdates(@_, nextToken => $next_result->nextToken);
326 push @{ $result->updateIds }, @{ $next_result->updateIds };
327 }
328 return $result;
329 } else {
330 while ($result->nextToken) {
331 $callback->($_ => 'updateIds') foreach (@{ $result->updateIds });
332 $result = $self->ListUpdates(@_, nextToken => $result->nextToken);
333 }
334 $callback->($_ => 'updateIds') foreach (@{ $result->updateIds });
335 }
336  
337 return undef
338 }
339  
340  
341 sub operations { qw/AssociateEncryptionConfig AssociateIdentityProviderConfig CreateAddon CreateCluster CreateFargateProfile CreateNodegroup DeleteAddon DeleteCluster DeleteFargateProfile DeleteNodegroup DescribeAddon DescribeAddonVersions DescribeCluster DescribeFargateProfile DescribeIdentityProviderConfig DescribeNodegroup DescribeUpdate DisassociateIdentityProviderConfig ListAddons ListClusters ListFargateProfiles ListIdentityProviderConfigs ListNodegroups ListTagsForResource ListUpdates TagResource UntagResource UpdateAddon UpdateClusterConfig UpdateClusterVersion UpdateNodegroupConfig UpdateNodegroupVersion / }
342  
343 1;
344  
345 ### main pod documentation begin ###
346  
347 =head1 NAME
348  
349 Paws::EKS - Perl Interface to AWS Amazon Elastic Kubernetes Service
350  
351 =head1 SYNOPSIS
352  
353 use Paws;
354  
355 my $obj = Paws->service('EKS');
356 my $res = $obj->Method(
357 Arg1 => $val1,
358 Arg2 => [ 'V1', 'V2' ],
359 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
360 # of the arguments type
361 Arg3 => { Att1 => 'Val1' },
362 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
363 # the constructor of the arguments type
364 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
365 );
366  
367 =head1 DESCRIPTION
368  
369 Amazon Elastic Kubernetes Service (Amazon EKS) is a managed service
370 that makes it easy for you to run Kubernetes on AWS without needing to
371 stand up or maintain your own Kubernetes control plane. Kubernetes is
372 an open-source system for automating the deployment, scaling, and
373 management of containerized applications.
374  
375 Amazon EKS runs up-to-date versions of the open-source Kubernetes
376 software, so you can use all the existing plugins and tooling from the
377 Kubernetes community. Applications running on Amazon EKS are fully
378 compatible with applications running on any standard Kubernetes
379 environment, whether running in on-premises data centers or public
380 clouds. This means that you can easily migrate any standard Kubernetes
381 application to Amazon EKS without any code modification required.
382  
383 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/eks-2017-11-01>
384  
385  
386 =head1 METHODS
387  
388 =head2 AssociateEncryptionConfig
389  
390 =over
391  
392 =item ClusterName => Str
393  
394 =item EncryptionConfig => ArrayRef[L<Paws::EKS::EncryptionConfig>]
395  
396 =item [ClientRequestToken => Str]
397  
398  
399 =back
400  
401 Each argument is described in detail in: L<Paws::EKS::AssociateEncryptionConfig>
402  
403 Returns: a L<Paws::EKS::AssociateEncryptionConfigResponse> instance
404  
405 Associate encryption configuration to an existing cluster.
406  
407 You can use this API to enable encryption on existing clusters which do
408 not have encryption already enabled. This allows you to implement a
409 defense-in-depth security strategy without migrating applications to
410 new EKS clusters.
411  
412  
413 =head2 AssociateIdentityProviderConfig
414  
415 =over
416  
417 =item ClusterName => Str
418  
419 =item Oidc => L<Paws::EKS::OidcIdentityProviderConfigRequest>
420  
421 =item [ClientRequestToken => Str]
422  
423 =item [Tags => L<Paws::EKS::TagMap>]
424  
425  
426 =back
427  
428 Each argument is described in detail in: L<Paws::EKS::AssociateIdentityProviderConfig>
429  
430 Returns: a L<Paws::EKS::AssociateIdentityProviderConfigResponse> instance
431  
432 Associate an identity provider configuration to a cluster.
433  
434 If you want to authenticate identities using an identity provider, you
435 can create an identity provider configuration and associate it to your
436 cluster. After configuring authentication to your cluster you can
437 create Kubernetes C<roles> and C<clusterroles> to assign permissions to
438 the roles, and then bind the roles to the identities using Kubernetes
439 C<rolebindings> and C<clusterrolebindings>. For more information see
440 Using RBAC Authorization
441 (https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in the
442 Kubernetes documentation.
443  
444  
445 =head2 CreateAddon
446  
447 =over
448  
449 =item AddonName => Str
450  
451 =item ClusterName => Str
452  
453 =item [AddonVersion => Str]
454  
455 =item [ClientRequestToken => Str]
456  
457 =item [ResolveConflicts => Str]
458  
459 =item [ServiceAccountRoleArn => Str]
460  
461 =item [Tags => L<Paws::EKS::TagMap>]
462  
463  
464 =back
465  
466 Each argument is described in detail in: L<Paws::EKS::CreateAddon>
467  
468 Returns: a L<Paws::EKS::CreateAddonResponse> instance
469  
470 Creates an Amazon EKS add-on.
471  
472 Amazon EKS add-ons help to automate the provisioning and lifecycle
473 management of common operational software for Amazon EKS clusters.
474 Amazon EKS add-ons can only be used with Amazon EKS clusters running
475 version 1.18 with platform version C<eks.3> or later because add-ons
476 rely on the Server-side Apply Kubernetes feature, which is only
477 available in Kubernetes 1.18 and later.
478  
479  
480 =head2 CreateCluster
481  
482 =over
483  
484 =item Name => Str
485  
486 =item ResourcesVpcConfig => L<Paws::EKS::VpcConfigRequest>
487  
488 =item RoleArn => Str
489  
490 =item [ClientRequestToken => Str]
491  
492 =item [EncryptionConfig => ArrayRef[L<Paws::EKS::EncryptionConfig>]]
493  
494 =item [KubernetesNetworkConfig => L<Paws::EKS::KubernetesNetworkConfigRequest>]
495  
496 =item [Logging => L<Paws::EKS::Logging>]
497  
498 =item [Tags => L<Paws::EKS::TagMap>]
499  
500 =item [Version => Str]
501  
502  
503 =back
504  
505 Each argument is described in detail in: L<Paws::EKS::CreateCluster>
506  
507 Returns: a L<Paws::EKS::CreateClusterResponse> instance
508  
509 Creates an Amazon EKS control plane.
510  
511 The Amazon EKS control plane consists of control plane instances that
512 run the Kubernetes software, such as C<etcd> and the API server. The
513 control plane runs in an account managed by AWS, and the Kubernetes API
514 is exposed via the Amazon EKS API server endpoint. Each Amazon EKS
515 cluster control plane is single-tenant and unique and runs on its own
516 set of Amazon EC2 instances.
517  
518 The cluster control plane is provisioned across multiple Availability
519 Zones and fronted by an Elastic Load Balancing Network Load Balancer.
520 Amazon EKS also provisions elastic network interfaces in your VPC
521 subnets to provide connectivity from the control plane instances to the
522 nodes (for example, to support C<kubectl exec>, C<logs>, and C<proxy>
523 data flows).
524  
525 Amazon EKS nodes run in your AWS account and connect to your cluster's
526 control plane via the Kubernetes API server endpoint and a certificate
527 file that is created for your cluster.
528  
529 Cluster creation typically takes several minutes. After you create an
530 Amazon EKS cluster, you must configure your Kubernetes tooling to
531 communicate with the API server and launch nodes into your cluster. For
532 more information, see Managing Cluster Authentication
533 (https://docs.aws.amazon.com/eks/latest/userguide/managing-auth.html)
534 and Launching Amazon EKS nodes
535 (https://docs.aws.amazon.com/eks/latest/userguide/launch-workers.html)
536 in the I<Amazon EKS User Guide>.
537  
538  
539 =head2 CreateFargateProfile
540  
541 =over
542  
543 =item ClusterName => Str
544  
545 =item FargateProfileName => Str
546  
547 =item PodExecutionRoleArn => Str
548  
549 =item [ClientRequestToken => Str]
550  
551 =item [Selectors => ArrayRef[L<Paws::EKS::FargateProfileSelector>]]
552  
553 =item [Subnets => ArrayRef[Str|Undef]]
554  
555 =item [Tags => L<Paws::EKS::TagMap>]
556  
557  
558 =back
559  
560 Each argument is described in detail in: L<Paws::EKS::CreateFargateProfile>
561  
562 Returns: a L<Paws::EKS::CreateFargateProfileResponse> instance
563  
564 Creates an AWS Fargate profile for your Amazon EKS cluster. You must
565 have at least one Fargate profile in a cluster to be able to run pods
566 on Fargate.
567  
568 The Fargate profile allows an administrator to declare which pods run
569 on Fargate and specify which pods run on which Fargate profile. This
570 declaration is done through the profileE<rsquo>s selectors. Each
571 profile can have up to five selectors that contain a namespace and
572 labels. A namespace is required for every selector. The label field
573 consists of multiple optional key-value pairs. Pods that match the
574 selectors are scheduled on Fargate. If a to-be-scheduled pod matches
575 any of the selectors in the Fargate profile, then that pod is run on
576 Fargate.
577  
578 When you create a Fargate profile, you must specify a pod execution
579 role to use with the pods that are scheduled with the profile. This
580 role is added to the cluster's Kubernetes Role Based Access Control
581 (https://kubernetes.io/docs/admin/authorization/rbac/) (RBAC) for
582 authorization so that the C<kubelet> that is running on the Fargate
583 infrastructure can register with your Amazon EKS cluster so that it can
584 appear in your cluster as a node. The pod execution role also provides
585 IAM permissions to the Fargate infrastructure to allow read access to
586 Amazon ECR image repositories. For more information, see Pod Execution
587 Role
588 (https://docs.aws.amazon.com/eks/latest/userguide/pod-execution-role.html)
589 in the I<Amazon EKS User Guide>.
590  
591 Fargate profiles are immutable. However, you can create a new updated
592 profile to replace an existing profile and then delete the original
593 after the updated profile has finished creating.
594  
595 If any Fargate profiles in a cluster are in the C<DELETING> status, you
596 must wait for that Fargate profile to finish deleting before you can
597 create any other profiles in that cluster.
598  
599 For more information, see AWS Fargate Profile
600 (https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html)
601 in the I<Amazon EKS User Guide>.
602  
603  
604 =head2 CreateNodegroup
605  
606 =over
607  
608 =item ClusterName => Str
609  
610 =item NodegroupName => Str
611  
612 =item NodeRole => Str
613  
614 =item Subnets => ArrayRef[Str|Undef]
615  
616 =item [AmiType => Str]
617  
618 =item [CapacityType => Str]
619  
620 =item [ClientRequestToken => Str]
621  
622 =item [DiskSize => Int]
623  
624 =item [InstanceTypes => ArrayRef[Str|Undef]]
625  
626 =item [Labels => L<Paws::EKS::LabelsMap>]
627  
628 =item [LaunchTemplate => L<Paws::EKS::LaunchTemplateSpecification>]
629  
630 =item [ReleaseVersion => Str]
631  
632 =item [RemoteAccess => L<Paws::EKS::RemoteAccessConfig>]
633  
634 =item [ScalingConfig => L<Paws::EKS::NodegroupScalingConfig>]
635  
636 =item [Tags => L<Paws::EKS::TagMap>]
637  
638 =item [Taints => ArrayRef[L<Paws::EKS::Taint>]]
639  
640 =item [UpdateConfig => L<Paws::EKS::NodegroupUpdateConfig>]
641  
642 =item [Version => Str]
643  
644  
645 =back
646  
647 Each argument is described in detail in: L<Paws::EKS::CreateNodegroup>
648  
649 Returns: a L<Paws::EKS::CreateNodegroupResponse> instance
650  
651 Creates a managed node group for an Amazon EKS cluster. You can only
652 create a node group for your cluster that is equal to the current
653 Kubernetes version for the cluster. All node groups are created with
654 the latest AMI release version for the respective minor Kubernetes
655 version of the cluster, unless you deploy a custom AMI using a launch
656 template. For more information about using launch templates, see Launch
657 template support
658 (https://docs.aws.amazon.com/eks/latest/userguide/launch-templates.html).
659  
660 An Amazon EKS managed node group is an Amazon EC2 Auto Scaling group
661 and associated Amazon EC2 instances that are managed by AWS for an
662 Amazon EKS cluster. Each node group uses a version of the Amazon EKS
663 optimized Amazon Linux 2 AMI. For more information, see Managed Node
664 Groups
665 (https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html)
666 in the I<Amazon EKS User Guide>.
667  
668  
669 =head2 DeleteAddon
670  
671 =over
672  
673 =item AddonName => Str
674  
675 =item ClusterName => Str
676  
677  
678 =back
679  
680 Each argument is described in detail in: L<Paws::EKS::DeleteAddon>
681  
682 Returns: a L<Paws::EKS::DeleteAddonResponse> instance
683  
684 Delete an Amazon EKS add-on.
685  
686 When you remove the add-on, it will also be deleted from the cluster.
687 You can always manually start an add-on on the cluster using the
688 Kubernetes API.
689  
690  
691 =head2 DeleteCluster
692  
693 =over
694  
695 =item Name => Str
696  
697  
698 =back
699  
700 Each argument is described in detail in: L<Paws::EKS::DeleteCluster>
701  
702 Returns: a L<Paws::EKS::DeleteClusterResponse> instance
703  
704 Deletes the Amazon EKS cluster control plane.
705  
706 If you have active services in your cluster that are associated with a
707 load balancer, you must delete those services before deleting the
708 cluster so that the load balancers are deleted properly. Otherwise, you
709 can have orphaned resources in your VPC that prevent you from being
710 able to delete the VPC. For more information, see Deleting a Cluster
711 (https://docs.aws.amazon.com/eks/latest/userguide/delete-cluster.html)
712 in the I<Amazon EKS User Guide>.
713  
714 If you have managed node groups or Fargate profiles attached to the
715 cluster, you must delete them first. For more information, see
716 DeleteNodegroup and DeleteFargateProfile.
717  
718  
719 =head2 DeleteFargateProfile
720  
721 =over
722  
723 =item ClusterName => Str
724  
725 =item FargateProfileName => Str
726  
727  
728 =back
729  
730 Each argument is described in detail in: L<Paws::EKS::DeleteFargateProfile>
731  
732 Returns: a L<Paws::EKS::DeleteFargateProfileResponse> instance
733  
734 Deletes an AWS Fargate profile.
735  
736 When you delete a Fargate profile, any pods running on Fargate that
737 were created with the profile are deleted. If those pods match another
738 Fargate profile, then they are scheduled on Fargate with that profile.
739 If they no longer match any Fargate profiles, then they are not
740 scheduled on Fargate and they may remain in a pending state.
741  
742 Only one Fargate profile in a cluster can be in the C<DELETING> status
743 at a time. You must wait for a Fargate profile to finish deleting
744 before you can delete any other profiles in that cluster.
745  
746  
747 =head2 DeleteNodegroup
748  
749 =over
750  
751 =item ClusterName => Str
752  
753 =item NodegroupName => Str
754  
755  
756 =back
757  
758 Each argument is described in detail in: L<Paws::EKS::DeleteNodegroup>
759  
760 Returns: a L<Paws::EKS::DeleteNodegroupResponse> instance
761  
762 Deletes an Amazon EKS node group for a cluster.
763  
764  
765 =head2 DescribeAddon
766  
767 =over
768  
769 =item AddonName => Str
770  
771 =item ClusterName => Str
772  
773  
774 =back
775  
776 Each argument is described in detail in: L<Paws::EKS::DescribeAddon>
777  
778 Returns: a L<Paws::EKS::DescribeAddonResponse> instance
779  
780 Describes an Amazon EKS add-on.
781  
782  
783 =head2 DescribeAddonVersions
784  
785 =over
786  
787 =item [AddonName => Str]
788  
789 =item [KubernetesVersion => Str]
790  
791 =item [MaxResults => Int]
792  
793 =item [NextToken => Str]
794  
795  
796 =back
797  
798 Each argument is described in detail in: L<Paws::EKS::DescribeAddonVersions>
799  
800 Returns: a L<Paws::EKS::DescribeAddonVersionsResponse> instance
801  
802 Describes the Kubernetes versions that the add-on can be used with.
803  
804  
805 =head2 DescribeCluster
806  
807 =over
808  
809 =item Name => Str
810  
811  
812 =back
813  
814 Each argument is described in detail in: L<Paws::EKS::DescribeCluster>
815  
816 Returns: a L<Paws::EKS::DescribeClusterResponse> instance
817  
818 Returns descriptive information about an Amazon EKS cluster.
819  
820 The API server endpoint and certificate authority data returned by this
821 operation are required for C<kubelet> and C<kubectl> to communicate
822 with your Kubernetes API server. For more information, see Create a
823 kubeconfig for Amazon EKS
824 (https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html).
825  
826 The API server endpoint and certificate authority data aren't available
827 until the cluster reaches the C<ACTIVE> state.
828  
829  
830 =head2 DescribeFargateProfile
831  
832 =over
833  
834 =item ClusterName => Str
835  
836 =item FargateProfileName => Str
837  
838  
839 =back
840  
841 Each argument is described in detail in: L<Paws::EKS::DescribeFargateProfile>
842  
843 Returns: a L<Paws::EKS::DescribeFargateProfileResponse> instance
844  
845 Returns descriptive information about an AWS Fargate profile.
846  
847  
848 =head2 DescribeIdentityProviderConfig
849  
850 =over
851  
852 =item ClusterName => Str
853  
854 =item IdentityProviderConfig => L<Paws::EKS::IdentityProviderConfig>
855  
856  
857 =back
858  
859 Each argument is described in detail in: L<Paws::EKS::DescribeIdentityProviderConfig>
860  
861 Returns: a L<Paws::EKS::DescribeIdentityProviderConfigResponse> instance
862  
863 Returns descriptive information about an identity provider
864 configuration.
865  
866  
867 =head2 DescribeNodegroup
868  
869 =over
870  
871 =item ClusterName => Str
872  
873 =item NodegroupName => Str
874  
875  
876 =back
877  
878 Each argument is described in detail in: L<Paws::EKS::DescribeNodegroup>
879  
880 Returns: a L<Paws::EKS::DescribeNodegroupResponse> instance
881  
882 Returns descriptive information about an Amazon EKS node group.
883  
884  
885 =head2 DescribeUpdate
886  
887 =over
888  
889 =item Name => Str
890  
891 =item UpdateId => Str
892  
893 =item [AddonName => Str]
894  
895 =item [NodegroupName => Str]
896  
897  
898 =back
899  
900 Each argument is described in detail in: L<Paws::EKS::DescribeUpdate>
901  
902 Returns: a L<Paws::EKS::DescribeUpdateResponse> instance
903  
904 Returns descriptive information about an update against your Amazon EKS
905 cluster or associated managed node group.
906  
907 When the status of the update is C<Succeeded>, the update is complete.
908 If an update fails, the status is C<Failed>, and an error detail
909 explains the reason for the failure.
910  
911  
912 =head2 DisassociateIdentityProviderConfig
913  
914 =over
915  
916 =item ClusterName => Str
917  
918 =item IdentityProviderConfig => L<Paws::EKS::IdentityProviderConfig>
919  
920 =item [ClientRequestToken => Str]
921  
922  
923 =back
924  
925 Each argument is described in detail in: L<Paws::EKS::DisassociateIdentityProviderConfig>
926  
927 Returns: a L<Paws::EKS::DisassociateIdentityProviderConfigResponse> instance
928  
929 Disassociates an identity provider configuration from a cluster. If you
930 disassociate an identity provider from your cluster, users included in
931 the provider can no longer access the cluster. However, you can still
932 access the cluster with AWS IAM users.
933  
934  
935 =head2 ListAddons
936  
937 =over
938  
939 =item ClusterName => Str
940  
941 =item [MaxResults => Int]
942  
943 =item [NextToken => Str]
944  
945  
946 =back
947  
948 Each argument is described in detail in: L<Paws::EKS::ListAddons>
949  
950 Returns: a L<Paws::EKS::ListAddonsResponse> instance
951  
952 Lists the available add-ons.
953  
954  
955 =head2 ListClusters
956  
957 =over
958  
959 =item [MaxResults => Int]
960  
961 =item [NextToken => Str]
962  
963  
964 =back
965  
966 Each argument is described in detail in: L<Paws::EKS::ListClusters>
967  
968 Returns: a L<Paws::EKS::ListClustersResponse> instance
969  
970 Lists the Amazon EKS clusters in your AWS account in the specified
971 Region.
972  
973  
974 =head2 ListFargateProfiles
975  
976 =over
977  
978 =item ClusterName => Str
979  
980 =item [MaxResults => Int]
981  
982 =item [NextToken => Str]
983  
984  
985 =back
986  
987 Each argument is described in detail in: L<Paws::EKS::ListFargateProfiles>
988  
989 Returns: a L<Paws::EKS::ListFargateProfilesResponse> instance
990  
991 Lists the AWS Fargate profiles associated with the specified cluster in
992 your AWS account in the specified Region.
993  
994  
995 =head2 ListIdentityProviderConfigs
996  
997 =over
998  
999 =item ClusterName => Str
1000  
1001 =item [MaxResults => Int]
1002  
1003 =item [NextToken => Str]
1004  
1005  
1006 =back
1007  
1008 Each argument is described in detail in: L<Paws::EKS::ListIdentityProviderConfigs>
1009  
1010 Returns: a L<Paws::EKS::ListIdentityProviderConfigsResponse> instance
1011  
1012 A list of identity provider configurations.
1013  
1014  
1015 =head2 ListNodegroups
1016  
1017 =over
1018  
1019 =item ClusterName => Str
1020  
1021 =item [MaxResults => Int]
1022  
1023 =item [NextToken => Str]
1024  
1025  
1026 =back
1027  
1028 Each argument is described in detail in: L<Paws::EKS::ListNodegroups>
1029  
1030 Returns: a L<Paws::EKS::ListNodegroupsResponse> instance
1031  
1032 Lists the Amazon EKS managed node groups associated with the specified
1033 cluster in your AWS account in the specified Region. Self-managed node
1034 groups are not listed.
1035  
1036  
1037 =head2 ListTagsForResource
1038  
1039 =over
1040  
1041 =item ResourceArn => Str
1042  
1043  
1044 =back
1045  
1046 Each argument is described in detail in: L<Paws::EKS::ListTagsForResource>
1047  
1048 Returns: a L<Paws::EKS::ListTagsForResourceResponse> instance
1049  
1050 List the tags for an Amazon EKS resource.
1051  
1052  
1053 =head2 ListUpdates
1054  
1055 =over
1056  
1057 =item Name => Str
1058  
1059 =item [AddonName => Str]
1060  
1061 =item [MaxResults => Int]
1062  
1063 =item [NextToken => Str]
1064  
1065 =item [NodegroupName => Str]
1066  
1067  
1068 =back
1069  
1070 Each argument is described in detail in: L<Paws::EKS::ListUpdates>
1071  
1072 Returns: a L<Paws::EKS::ListUpdatesResponse> instance
1073  
1074 Lists the updates associated with an Amazon EKS cluster or managed node
1075 group in your AWS account, in the specified Region.
1076  
1077  
1078 =head2 TagResource
1079  
1080 =over
1081  
1082 =item ResourceArn => Str
1083  
1084 =item Tags => L<Paws::EKS::TagMap>
1085  
1086  
1087 =back
1088  
1089 Each argument is described in detail in: L<Paws::EKS::TagResource>
1090  
1091 Returns: a L<Paws::EKS::TagResourceResponse> instance
1092  
1093 Associates the specified tags to a resource with the specified
1094 C<resourceArn>. If existing tags on a resource are not specified in the
1095 request parameters, they are not changed. When a resource is deleted,
1096 the tags associated with that resource are deleted as well. Tags that
1097 you create for Amazon EKS resources do not propagate to any other
1098 resources associated with the cluster. For example, if you tag a
1099 cluster with this operation, that tag does not automatically propagate
1100 to the subnets and nodes associated with the cluster.
1101  
1102  
1103 =head2 UntagResource
1104  
1105 =over
1106  
1107 =item ResourceArn => Str
1108  
1109 =item TagKeys => ArrayRef[Str|Undef]
1110  
1111  
1112 =back
1113  
1114 Each argument is described in detail in: L<Paws::EKS::UntagResource>
1115  
1116 Returns: a L<Paws::EKS::UntagResourceResponse> instance
1117  
1118 Deletes specified tags from a resource.
1119  
1120  
1121 =head2 UpdateAddon
1122  
1123 =over
1124  
1125 =item AddonName => Str
1126  
1127 =item ClusterName => Str
1128  
1129 =item [AddonVersion => Str]
1130  
1131 =item [ClientRequestToken => Str]
1132  
1133 =item [ResolveConflicts => Str]
1134  
1135 =item [ServiceAccountRoleArn => Str]
1136  
1137  
1138 =back
1139  
1140 Each argument is described in detail in: L<Paws::EKS::UpdateAddon>
1141  
1142 Returns: a L<Paws::EKS::UpdateAddonResponse> instance
1143  
1144 Updates an Amazon EKS add-on.
1145  
1146  
1147 =head2 UpdateClusterConfig
1148  
1149 =over
1150  
1151 =item Name => Str
1152  
1153 =item [ClientRequestToken => Str]
1154  
1155 =item [Logging => L<Paws::EKS::Logging>]
1156  
1157 =item [ResourcesVpcConfig => L<Paws::EKS::VpcConfigRequest>]
1158  
1159  
1160 =back
1161  
1162 Each argument is described in detail in: L<Paws::EKS::UpdateClusterConfig>
1163  
1164 Returns: a L<Paws::EKS::UpdateClusterConfigResponse> instance
1165  
1166 Updates an Amazon EKS cluster configuration. Your cluster continues to
1167 function during the update. The response output includes an update ID
1168 that you can use to track the status of your cluster update with the
1169 DescribeUpdate API operation.
1170  
1171 You can use this API operation to enable or disable exporting the
1172 Kubernetes control plane logs for your cluster to CloudWatch Logs. By
1173 default, cluster control plane logs aren't exported to CloudWatch Logs.
1174 For more information, see Amazon EKS Cluster Control Plane Logs
1175 (https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html)
1176 in the I< I<Amazon EKS User Guide> >.
1177  
1178 CloudWatch Logs ingestion, archive storage, and data scanning rates
1179 apply to exported control plane logs. For more information, see Amazon
1180 CloudWatch Pricing (http://aws.amazon.com/cloudwatch/pricing/).
1181  
1182 You can also use this API operation to enable or disable public and
1183 private access to your cluster's Kubernetes API server endpoint. By
1184 default, public access is enabled, and private access is disabled. For
1185 more information, see Amazon EKS Cluster Endpoint Access Control
1186 (https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html)
1187 in the I< I<Amazon EKS User Guide> >.
1188  
1189 You can't update the subnets or security group IDs for an existing
1190 cluster.
1191  
1192 Cluster updates are asynchronous, and they should finish within a few
1193 minutes. During an update, the cluster status moves to C<UPDATING>
1194 (this status transition is eventually consistent). When the update is
1195 complete (either C<Failed> or C<Successful>), the cluster status moves
1196 to C<Active>.
1197  
1198  
1199 =head2 UpdateClusterVersion
1200  
1201 =over
1202  
1203 =item Name => Str
1204  
1205 =item Version => Str
1206  
1207 =item [ClientRequestToken => Str]
1208  
1209  
1210 =back
1211  
1212 Each argument is described in detail in: L<Paws::EKS::UpdateClusterVersion>
1213  
1214 Returns: a L<Paws::EKS::UpdateClusterVersionResponse> instance
1215  
1216 Updates an Amazon EKS cluster to the specified Kubernetes version. Your
1217 cluster continues to function during the update. The response output
1218 includes an update ID that you can use to track the status of your
1219 cluster update with the DescribeUpdate API operation.
1220  
1221 Cluster updates are asynchronous, and they should finish within a few
1222 minutes. During an update, the cluster status moves to C<UPDATING>
1223 (this status transition is eventually consistent). When the update is
1224 complete (either C<Failed> or C<Successful>), the cluster status moves
1225 to C<Active>.
1226  
1227 If your cluster has managed node groups attached to it, all of your
1228 node groupsE<rsquo> Kubernetes versions must match the clusterE<rsquo>s
1229 Kubernetes version in order to update the cluster to a new Kubernetes
1230 version.
1231  
1232  
1233 =head2 UpdateNodegroupConfig
1234  
1235 =over
1236  
1237 =item ClusterName => Str
1238  
1239 =item NodegroupName => Str
1240  
1241 =item [ClientRequestToken => Str]
1242  
1243 =item [Labels => L<Paws::EKS::UpdateLabelsPayload>]
1244  
1245 =item [ScalingConfig => L<Paws::EKS::NodegroupScalingConfig>]
1246  
1247 =item [Taints => L<Paws::EKS::UpdateTaintsPayload>]
1248  
1249 =item [UpdateConfig => L<Paws::EKS::NodegroupUpdateConfig>]
1250  
1251  
1252 =back
1253  
1254 Each argument is described in detail in: L<Paws::EKS::UpdateNodegroupConfig>
1255  
1256 Returns: a L<Paws::EKS::UpdateNodegroupConfigResponse> instance
1257  
1258 Updates an Amazon EKS managed node group configuration. Your node group
1259 continues to function during the update. The response output includes
1260 an update ID that you can use to track the status of your node group
1261 update with the DescribeUpdate API operation. Currently you can update
1262 the Kubernetes labels for a node group or the scaling configuration.
1263  
1264  
1265 =head2 UpdateNodegroupVersion
1266  
1267 =over
1268  
1269 =item ClusterName => Str
1270  
1271 =item NodegroupName => Str
1272  
1273 =item [ClientRequestToken => Str]
1274  
1275 =item [Force => Bool]
1276  
1277 =item [LaunchTemplate => L<Paws::EKS::LaunchTemplateSpecification>]
1278  
1279 =item [ReleaseVersion => Str]
1280  
1281 =item [Version => Str]
1282  
1283  
1284 =back
1285  
1286 Each argument is described in detail in: L<Paws::EKS::UpdateNodegroupVersion>
1287  
1288 Returns: a L<Paws::EKS::UpdateNodegroupVersionResponse> instance
1289  
1290 Updates the Kubernetes version or AMI version of an Amazon EKS managed
1291 node group.
1292  
1293 You can update a node group using a launch template only if the node
1294 group was originally deployed with a launch template. If you need to
1295 update a custom AMI in a node group that was deployed with a launch
1296 template, then update your custom AMI, specify the new ID in a new
1297 version of the launch template, and then update the node group to the
1298 new version of the launch template.
1299  
1300 If you update without a launch template, then you can update to the
1301 latest available AMI version of a node group's current Kubernetes
1302 version by not specifying a Kubernetes version in the request. You can
1303 update to the latest AMI version of your cluster's current Kubernetes
1304 version by specifying your cluster's Kubernetes version in the request.
1305 For more information, see Amazon EKS optimized Amazon Linux 2 AMI
1306 versions
1307 (https://docs.aws.amazon.com/eks/latest/userguide/eks-linux-ami-versions.html)
1308 in the I<Amazon EKS User Guide>.
1309  
1310 You cannot roll back a node group to an earlier Kubernetes version or
1311 AMI version.
1312  
1313 When a node in a managed node group is terminated due to a scaling
1314 action or update, the pods in that node are drained first. Amazon EKS
1315 attempts to drain the nodes gracefully and will fail if it is unable to
1316 do so. You can C<force> the update if Amazon EKS is unable to drain the
1317 nodes as a result of a pod disruption budget issue.
1318  
1319  
1320  
1321  
1322 =head1 PAGINATORS
1323  
1324 Paginator methods are helpers that repetively call methods that return partial results
1325  
1326 =head2 DescribeAllAddonVersions(sub { },[AddonName => Str, KubernetesVersion => Str, MaxResults => Int, NextToken => Str])
1327  
1328 =head2 DescribeAllAddonVersions([AddonName => Str, KubernetesVersion => Str, MaxResults => Int, NextToken => Str])
1329  
1330  
1331 If passed a sub as first parameter, it will call the sub for each element found in :
1332  
1333 - addons, passing the object as the first parameter, and the string 'addons' as the second parameter
1334  
1335 If not, it will return a a L<Paws::EKS::DescribeAddonVersionsResponse> 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.
1336  
1337  
1338 =head2 ListAllAddons(sub { },ClusterName => Str, [MaxResults => Int, NextToken => Str])
1339  
1340 =head2 ListAllAddons(ClusterName => Str, [MaxResults => Int, NextToken => Str])
1341  
1342  
1343 If passed a sub as first parameter, it will call the sub for each element found in :
1344  
1345 - addons, passing the object as the first parameter, and the string 'addons' as the second parameter
1346  
1347 If not, it will return a a L<Paws::EKS::ListAddonsResponse> 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.
1348  
1349  
1350 =head2 ListAllClusters(sub { },[MaxResults => Int, NextToken => Str])
1351  
1352 =head2 ListAllClusters([MaxResults => Int, NextToken => Str])
1353  
1354  
1355 If passed a sub as first parameter, it will call the sub for each element found in :
1356  
1357 - clusters, passing the object as the first parameter, and the string 'clusters' as the second parameter
1358  
1359 If not, it will return a a L<Paws::EKS::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.
1360  
1361  
1362 =head2 ListAllFargateProfiles(sub { },ClusterName => Str, [MaxResults => Int, NextToken => Str])
1363  
1364 =head2 ListAllFargateProfiles(ClusterName => Str, [MaxResults => Int, NextToken => Str])
1365  
1366  
1367 If passed a sub as first parameter, it will call the sub for each element found in :
1368  
1369 - fargateProfileNames, passing the object as the first parameter, and the string 'fargateProfileNames' as the second parameter
1370  
1371 If not, it will return a a L<Paws::EKS::ListFargateProfilesResponse> 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.
1372  
1373  
1374 =head2 ListAllIdentityProviderConfigs(sub { },ClusterName => Str, [MaxResults => Int, NextToken => Str])
1375  
1376 =head2 ListAllIdentityProviderConfigs(ClusterName => Str, [MaxResults => Int, NextToken => Str])
1377  
1378  
1379 If passed a sub as first parameter, it will call the sub for each element found in :
1380  
1381 - identityProviderConfigs, passing the object as the first parameter, and the string 'identityProviderConfigs' as the second parameter
1382  
1383 If not, it will return a a L<Paws::EKS::ListIdentityProviderConfigsResponse> 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.
1384  
1385  
1386 =head2 ListAllNodegroups(sub { },ClusterName => Str, [MaxResults => Int, NextToken => Str])
1387  
1388 =head2 ListAllNodegroups(ClusterName => Str, [MaxResults => Int, NextToken => Str])
1389  
1390  
1391 If passed a sub as first parameter, it will call the sub for each element found in :
1392  
1393 - nodegroups, passing the object as the first parameter, and the string 'nodegroups' as the second parameter
1394  
1395 If not, it will return a a L<Paws::EKS::ListNodegroupsResponse> 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.
1396  
1397  
1398 =head2 ListAllUpdates(sub { },Name => Str, [AddonName => Str, MaxResults => Int, NextToken => Str, NodegroupName => Str])
1399  
1400 =head2 ListAllUpdates(Name => Str, [AddonName => Str, MaxResults => Int, NextToken => Str, NodegroupName => Str])
1401  
1402  
1403 If passed a sub as first parameter, it will call the sub for each element found in :
1404  
1405 - updateIds, passing the object as the first parameter, and the string 'updateIds' as the second parameter
1406  
1407 If not, it will return a a L<Paws::EKS::ListUpdatesResponse> 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.
1408  
1409  
1410  
1411  
1412  
1413 =head1 SEE ALSO
1414  
1415 This service class forms part of L<Paws>
1416  
1417 =head1 BUGS and CONTRIBUTIONS
1418  
1419 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1420  
1421 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1422  
1423 =cut
1424