blib/lib/Paws/ELBv2.pm untested

filter: Statementstmt 0.0% 0 / 255 Branchbran 0.0% 0 / 28 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 47 Podpod 0.0% 0 / 46 totaltotal 0.0% 0 / 376 CC 15 SCAR 16.9
CC
15
Cov
0%
DescribeAllAccountLimits
12.0
DescribeAllListenerCertificates
12.0
DescribeAllListeners
12.0
CRAP 5.4
1 package Paws::ELBv2;
2 use Moose;
3 sub service { 'elasticloadbalancing' }
4 sub signing_name { 'elasticloadbalancing' }
5 sub version { '2015-12-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::QueryCaller';
15  
16
17 sub AddListenerCertificates {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::ELBv2::AddListenerCertificates', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub AddTags {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::ELBv2::AddTags', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateListener {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateListener', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub CreateLoadBalancer {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateLoadBalancer', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub CreateRule {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateRule', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub CreateTargetGroup {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateTargetGroup', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DeleteListener {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteListener', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub DeleteLoadBalancer {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteLoadBalancer', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub DeleteRule {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteRule', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub DeleteTargetGroup {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteTargetGroup', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub DeregisterTargets {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::ELBv2::DeregisterTargets', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub DescribeAccountLimits {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeAccountLimits', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub DescribeListenerCertificates {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeListenerCertificates', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub DescribeListeners {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeListeners', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub DescribeLoadBalancerAttributes {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeLoadBalancerAttributes', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub DescribeLoadBalancers {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeLoadBalancers', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub DescribeRules {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeRules', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub DescribeSSLPolicies {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeSSLPolicies', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub DescribeTags {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTags', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub DescribeTargetGroupAttributes {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetGroupAttributes', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub DescribeTargetGroups {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetGroups', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub DescribeTargetHealth {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetHealth', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub ModifyListener {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyListener', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub ModifyLoadBalancerAttributes {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyLoadBalancerAttributes', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub ModifyRule {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyRule', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub ModifyTargetGroup {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyTargetGroup', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147 sub ModifyTargetGroupAttributes {
148 my $self = shift;
149 my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyTargetGroupAttributes', @_);
150 return $self->caller->do_call($self, $call_object);
151 }
152 sub RegisterTargets {
153 my $self = shift;
154 my $call_object = $self->new_with_coercions('Paws::ELBv2::RegisterTargets', @_);
155 return $self->caller->do_call($self, $call_object);
156 }
157 sub RemoveListenerCertificates {
158 my $self = shift;
159 my $call_object = $self->new_with_coercions('Paws::ELBv2::RemoveListenerCertificates', @_);
160 return $self->caller->do_call($self, $call_object);
161 }
162 sub RemoveTags {
163 my $self = shift;
164 my $call_object = $self->new_with_coercions('Paws::ELBv2::RemoveTags', @_);
165 return $self->caller->do_call($self, $call_object);
166 }
167 sub SetIpAddressType {
168 my $self = shift;
169 my $call_object = $self->new_with_coercions('Paws::ELBv2::SetIpAddressType', @_);
170 return $self->caller->do_call($self, $call_object);
171 }
172 sub SetRulePriorities {
173 my $self = shift;
174 my $call_object = $self->new_with_coercions('Paws::ELBv2::SetRulePriorities', @_);
175 return $self->caller->do_call($self, $call_object);
176 }
177 sub SetSecurityGroups {
178 my $self = shift;
179 my $call_object = $self->new_with_coercions('Paws::ELBv2::SetSecurityGroups', @_);
180 return $self->caller->do_call($self, $call_object);
181 }
182 sub SetSubnets {
183 my $self = shift;
184 my $call_object = $self->new_with_coercions('Paws::ELBv2::SetSubnets', @_);
185 return $self->caller->do_call($self, $call_object);
186 }
187
188 sub DescribeAllAccountLimits {
189 my $self = shift;
190  
191 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
192 my $result = $self->DescribeAccountLimits(@_);
193 my $next_result = $result;
194  
195 if (not defined $callback) {
196 while ($next_result->NextMarker) {
197 $next_result = $self->DescribeAccountLimits(@_, Marker => $next_result->NextMarker);
198 push @{ $result->Limits }, @{ $next_result->Limits };
199 }
200 return $result;
201 } else {
202 while ($result->NextMarker) {
203 $callback->($_ => 'Limits') foreach (@{ $result->Limits });
204 $result = $self->DescribeAccountLimits(@_, Marker => $result->NextMarker);
205 }
206 $callback->($_ => 'Limits') foreach (@{ $result->Limits });
207 }
208  
209 return undef
210 }
211 sub DescribeAllListenerCertificates {
212 my $self = shift;
213  
214 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
215 my $result = $self->DescribeListenerCertificates(@_);
216 my $next_result = $result;
217  
218 if (not defined $callback) {
219 while ($next_result->NextMarker) {
220 $next_result = $self->DescribeListenerCertificates(@_, Marker => $next_result->NextMarker);
221 push @{ $result->Certificates }, @{ $next_result->Certificates };
222 }
223 return $result;
224 } else {
225 while ($result->NextMarker) {
226 $callback->($_ => 'Certificates') foreach (@{ $result->Certificates });
227 $result = $self->DescribeListenerCertificates(@_, Marker => $result->NextMarker);
228 }
229 $callback->($_ => 'Certificates') foreach (@{ $result->Certificates });
230 }
231  
232 return undef
233 }
234 sub DescribeAllListeners {
235 my $self = shift;
236  
237 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
238 my $result = $self->DescribeListeners(@_);
239 my $next_result = $result;
240  
241 if (not defined $callback) {
242 while ($next_result->NextMarker) {
243 $next_result = $self->DescribeListeners(@_, Marker => $next_result->NextMarker);
244 push @{ $result->Listeners }, @{ $next_result->Listeners };
245 }
246 return $result;
247 } else {
248 while ($result->NextMarker) {
249 $callback->($_ => 'Listeners') foreach (@{ $result->Listeners });
250 $result = $self->DescribeListeners(@_, Marker => $result->NextMarker);
251 }
252 $callback->($_ => 'Listeners') foreach (@{ $result->Listeners });
253 }
254  
255 return undef
256 }
257 sub DescribeAllLoadBalancers {
258 my $self = shift;
259  
260 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
261 my $result = $self->DescribeLoadBalancers(@_);
262 my $next_result = $result;
263  
264 if (not defined $callback) {
265 while ($next_result->NextMarker) {
266 $next_result = $self->DescribeLoadBalancers(@_, Marker => $next_result->NextMarker);
267 push @{ $result->LoadBalancers }, @{ $next_result->LoadBalancers };
268 }
269 return $result;
270 } else {
271 while ($result->NextMarker) {
272 $callback->($_ => 'LoadBalancers') foreach (@{ $result->LoadBalancers });
273 $result = $self->DescribeLoadBalancers(@_, Marker => $result->NextMarker);
274 }
275 $callback->($_ => 'LoadBalancers') foreach (@{ $result->LoadBalancers });
276 }
277  
278 return undef
279 }
280 sub DescribeAllRules {
281 my $self = shift;
282  
283 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
284 my $result = $self->DescribeRules(@_);
285 my $next_result = $result;
286  
287 if (not defined $callback) {
288 while ($next_result->NextMarker) {
289 $next_result = $self->DescribeRules(@_, Marker => $next_result->NextMarker);
290 push @{ $result->Rules }, @{ $next_result->Rules };
291 }
292 return $result;
293 } else {
294 while ($result->NextMarker) {
295 $callback->($_ => 'Rules') foreach (@{ $result->Rules });
296 $result = $self->DescribeRules(@_, Marker => $result->NextMarker);
297 }
298 $callback->($_ => 'Rules') foreach (@{ $result->Rules });
299 }
300  
301 return undef
302 }
303 sub DescribeAllSSLPolicies {
304 my $self = shift;
305  
306 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
307 my $result = $self->DescribeSSLPolicies(@_);
308 my $next_result = $result;
309  
310 if (not defined $callback) {
311 while ($next_result->NextMarker) {
312 $next_result = $self->DescribeSSLPolicies(@_, Marker => $next_result->NextMarker);
313 push @{ $result->SslPolicies }, @{ $next_result->SslPolicies };
314 }
315 return $result;
316 } else {
317 while ($result->NextMarker) {
318 $callback->($_ => 'SslPolicies') foreach (@{ $result->SslPolicies });
319 $result = $self->DescribeSSLPolicies(@_, Marker => $result->NextMarker);
320 }
321 $callback->($_ => 'SslPolicies') foreach (@{ $result->SslPolicies });
322 }
323  
324 return undef
325 }
326 sub DescribeAllTargetGroups {
327 my $self = shift;
328  
329 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
330 my $result = $self->DescribeTargetGroups(@_);
331 my $next_result = $result;
332  
333 if (not defined $callback) {
334 while ($next_result->NextMarker) {
335 $next_result = $self->DescribeTargetGroups(@_, Marker => $next_result->NextMarker);
336 push @{ $result->TargetGroups }, @{ $next_result->TargetGroups };
337 }
338 return $result;
339 } else {
340 while ($result->NextMarker) {
341 $callback->($_ => 'TargetGroups') foreach (@{ $result->TargetGroups });
342 $result = $self->DescribeTargetGroups(@_, Marker => $result->NextMarker);
343 }
344 $callback->($_ => 'TargetGroups') foreach (@{ $result->TargetGroups });
345 }
346  
347 return undef
348 }
349  
350  
351 sub operations { qw/AddListenerCertificates AddTags CreateListener CreateLoadBalancer CreateRule CreateTargetGroup DeleteListener DeleteLoadBalancer DeleteRule DeleteTargetGroup DeregisterTargets DescribeAccountLimits DescribeListenerCertificates DescribeListeners DescribeLoadBalancerAttributes DescribeLoadBalancers DescribeRules DescribeSSLPolicies DescribeTags DescribeTargetGroupAttributes DescribeTargetGroups DescribeTargetHealth ModifyListener ModifyLoadBalancerAttributes ModifyRule ModifyTargetGroup ModifyTargetGroupAttributes RegisterTargets RemoveListenerCertificates RemoveTags SetIpAddressType SetRulePriorities SetSecurityGroups SetSubnets / }
352  
353 1;
354  
355 ### main pod documentation begin ###
356  
357 =head1 NAME
358  
359 Paws::ELBv2 - Perl Interface to AWS Elastic Load Balancing
360  
361 =head1 SYNOPSIS
362  
363 use Paws;
364  
365 my $obj = Paws->service('ELBv2');
366 my $res = $obj->Method(
367 Arg1 => $val1,
368 Arg2 => [ 'V1', 'V2' ],
369 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
370 # of the arguments type
371 Arg3 => { Att1 => 'Val1' },
372 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
373 # the constructor of the arguments type
374 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
375 );
376  
377 =head1 DESCRIPTION
378  
379 Elastic Load Balancing
380  
381 A load balancer distributes incoming traffic across targets, such as
382 your EC2 instances. This enables you to increase the availability of
383 your application. The load balancer also monitors the health of its
384 registered targets and ensures that it routes traffic only to healthy
385 targets. You configure your load balancer to accept incoming traffic by
386 specifying one or more listeners, which are configured with a protocol
387 and port number for connections from clients to the load balancer. You
388 configure a target group with a protocol and port number for
389 connections from the load balancer to the targets, and with health
390 check settings to be used when checking the health status of the
391 targets.
392  
393 Elastic Load Balancing supports the following types of load balancers:
394 Application Load Balancers, Network Load Balancers, Gateway Load
395 Balancers, and Classic Load Balancers. This reference covers the
396 following load balancer types:
397  
398 =over
399  
400 =item *
401  
402 Application Load Balancer - Operates at the application layer (layer 7)
403 and supports HTTP and HTTPS.
404  
405 =item *
406  
407 Network Load Balancer - Operates at the transport layer (layer 4) and
408 supports TCP, TLS, and UDP.
409  
410 =item *
411  
412 Gateway Load Balancer - Operates at the network layer (layer 3).
413  
414 =back
415  
416 For more information, see the Elastic Load Balancing User Guide
417 (https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
418  
419 All Elastic Load Balancing operations are idempotent, which means that
420 they complete at most one time. If you repeat an operation, it
421 succeeds.
422  
423 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2015-12-01>
424  
425  
426 =head1 METHODS
427  
428 =head2 AddListenerCertificates
429  
430 =over
431  
432 =item Certificates => ArrayRef[L<Paws::ELBv2::Certificate>]
433  
434 =item ListenerArn => Str
435  
436  
437 =back
438  
439 Each argument is described in detail in: L<Paws::ELBv2::AddListenerCertificates>
440  
441 Returns: a L<Paws::ELBv2::AddListenerCertificatesOutput> instance
442  
443 Adds the specified SSL server certificate to the certificate list for
444 the specified HTTPS or TLS listener.
445  
446 If the certificate in already in the certificate list, the call is
447 successful but the certificate is not added again.
448  
449 For more information, see HTTPS listeners
450 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html)
451 in the I<Application Load Balancers Guide> or TLS listeners
452 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html)
453 in the I<Network Load Balancers Guide>.
454  
455  
456 =head2 AddTags
457  
458 =over
459  
460 =item ResourceArns => ArrayRef[Str|Undef]
461  
462 =item Tags => ArrayRef[L<Paws::ELBv2::Tag>]
463  
464  
465 =back
466  
467 Each argument is described in detail in: L<Paws::ELBv2::AddTags>
468  
469 Returns: a L<Paws::ELBv2::AddTagsOutput> instance
470  
471 Adds the specified tags to the specified Elastic Load Balancing
472 resource. You can tag your Application Load Balancers, Network Load
473 Balancers, Gateway Load Balancers, target groups, listeners, and rules.
474  
475 Each tag consists of a key and an optional value. If a resource already
476 has a tag with the same key, C<AddTags> updates its value.
477  
478  
479 =head2 CreateListener
480  
481 =over
482  
483 =item DefaultActions => ArrayRef[L<Paws::ELBv2::Action>]
484  
485 =item LoadBalancerArn => Str
486  
487 =item [AlpnPolicy => ArrayRef[Str|Undef]]
488  
489 =item [Certificates => ArrayRef[L<Paws::ELBv2::Certificate>]]
490  
491 =item [Port => Int]
492  
493 =item [Protocol => Str]
494  
495 =item [SslPolicy => Str]
496  
497 =item [Tags => ArrayRef[L<Paws::ELBv2::Tag>]]
498  
499  
500 =back
501  
502 Each argument is described in detail in: L<Paws::ELBv2::CreateListener>
503  
504 Returns: a L<Paws::ELBv2::CreateListenerOutput> instance
505  
506 Creates a listener for the specified Application Load Balancer, Network
507 Load Balancer, or Gateway Load Balancer.
508  
509 For more information, see the following:
510  
511 =over
512  
513 =item *
514  
515 Listeners for your Application Load Balancers
516 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html)
517  
518 =item *
519  
520 Listeners for your Network Load Balancers
521 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-listeners.html)
522  
523 =item *
524  
525 Listeners for your Gateway Load Balancers
526 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-listeners.html)
527  
528 =back
529  
530 This operation is idempotent, which means that it completes at most one
531 time. If you attempt to create multiple listeners with the same
532 settings, each call succeeds.
533  
534  
535 =head2 CreateLoadBalancer
536  
537 =over
538  
539 =item Name => Str
540  
541 =item [CustomerOwnedIpv4Pool => Str]
542  
543 =item [IpAddressType => Str]
544  
545 =item [Scheme => Str]
546  
547 =item [SecurityGroups => ArrayRef[Str|Undef]]
548  
549 =item [SubnetMappings => ArrayRef[L<Paws::ELBv2::SubnetMapping>]]
550  
551 =item [Subnets => ArrayRef[Str|Undef]]
552  
553 =item [Tags => ArrayRef[L<Paws::ELBv2::Tag>]]
554  
555 =item [Type => Str]
556  
557  
558 =back
559  
560 Each argument is described in detail in: L<Paws::ELBv2::CreateLoadBalancer>
561  
562 Returns: a L<Paws::ELBv2::CreateLoadBalancerOutput> instance
563  
564 Creates an Application Load Balancer, Network Load Balancer, or Gateway
565 Load Balancer.
566  
567 For more information, see the following:
568  
569 =over
570  
571 =item *
572  
573 Application Load Balancers
574 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html)
575  
576 =item *
577  
578 Network Load Balancers
579 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html)
580  
581 =item *
582  
583 Gateway Load Balancers
584 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-load-balancers.html)
585  
586 =back
587  
588 This operation is idempotent, which means that it completes at most one
589 time. If you attempt to create multiple load balancers with the same
590 settings, each call succeeds.
591  
592  
593 =head2 CreateRule
594  
595 =over
596  
597 =item Actions => ArrayRef[L<Paws::ELBv2::Action>]
598  
599 =item Conditions => ArrayRef[L<Paws::ELBv2::RuleCondition>]
600  
601 =item ListenerArn => Str
602  
603 =item Priority => Int
604  
605 =item [Tags => ArrayRef[L<Paws::ELBv2::Tag>]]
606  
607  
608 =back
609  
610 Each argument is described in detail in: L<Paws::ELBv2::CreateRule>
611  
612 Returns: a L<Paws::ELBv2::CreateRuleOutput> instance
613  
614 Creates a rule for the specified listener. The listener must be
615 associated with an Application Load Balancer.
616  
617 Each rule consists of a priority, one or more actions, and one or more
618 conditions. Rules are evaluated in priority order, from the lowest
619 value to the highest value. When the conditions for a rule are met, its
620 actions are performed. If the conditions for no rules are met, the
621 actions for the default rule are performed. For more information, see
622 Listener rules
623 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#listener-rules)
624 in the I<Application Load Balancers Guide>.
625  
626  
627 =head2 CreateTargetGroup
628  
629 =over
630  
631 =item Name => Str
632  
633 =item [HealthCheckEnabled => Bool]
634  
635 =item [HealthCheckIntervalSeconds => Int]
636  
637 =item [HealthCheckPath => Str]
638  
639 =item [HealthCheckPort => Str]
640  
641 =item [HealthCheckProtocol => Str]
642  
643 =item [HealthCheckTimeoutSeconds => Int]
644  
645 =item [HealthyThresholdCount => Int]
646  
647 =item [Matcher => L<Paws::ELBv2::Matcher>]
648  
649 =item [Port => Int]
650  
651 =item [Protocol => Str]
652  
653 =item [ProtocolVersion => Str]
654  
655 =item [Tags => ArrayRef[L<Paws::ELBv2::Tag>]]
656  
657 =item [TargetType => Str]
658  
659 =item [UnhealthyThresholdCount => Int]
660  
661 =item [VpcId => Str]
662  
663  
664 =back
665  
666 Each argument is described in detail in: L<Paws::ELBv2::CreateTargetGroup>
667  
668 Returns: a L<Paws::ELBv2::CreateTargetGroupOutput> instance
669  
670 Creates a target group.
671  
672 For more information, see the following:
673  
674 =over
675  
676 =item *
677  
678 Target groups for your Application Load Balancers
679 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html)
680  
681 =item *
682  
683 Target groups for your Network Load Balancers
684 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)
685  
686 =item *
687  
688 Target groups for your Gateway Load Balancers
689 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/target-groups.html)
690  
691 =back
692  
693 This operation is idempotent, which means that it completes at most one
694 time. If you attempt to create multiple target groups with the same
695 settings, each call succeeds.
696  
697  
698 =head2 DeleteListener
699  
700 =over
701  
702 =item ListenerArn => Str
703  
704  
705 =back
706  
707 Each argument is described in detail in: L<Paws::ELBv2::DeleteListener>
708  
709 Returns: a L<Paws::ELBv2::DeleteListenerOutput> instance
710  
711 Deletes the specified listener.
712  
713 Alternatively, your listener is deleted when you delete the load
714 balancer to which it is attached.
715  
716  
717 =head2 DeleteLoadBalancer
718  
719 =over
720  
721 =item LoadBalancerArn => Str
722  
723  
724 =back
725  
726 Each argument is described in detail in: L<Paws::ELBv2::DeleteLoadBalancer>
727  
728 Returns: a L<Paws::ELBv2::DeleteLoadBalancerOutput> instance
729  
730 Deletes the specified Application Load Balancer, Network Load Balancer,
731 or Gateway Load Balancer. Deleting a load balancer also deletes its
732 listeners.
733  
734 You can't delete a load balancer if deletion protection is enabled. If
735 the load balancer does not exist or has already been deleted, the call
736 succeeds.
737  
738 Deleting a load balancer does not affect its registered targets. For
739 example, your EC2 instances continue to run and are still registered to
740 their target groups. If you no longer need these EC2 instances, you can
741 stop or terminate them.
742  
743  
744 =head2 DeleteRule
745  
746 =over
747  
748 =item RuleArn => Str
749  
750  
751 =back
752  
753 Each argument is described in detail in: L<Paws::ELBv2::DeleteRule>
754  
755 Returns: a L<Paws::ELBv2::DeleteRuleOutput> instance
756  
757 Deletes the specified rule.
758  
759 You can't delete the default rule.
760  
761  
762 =head2 DeleteTargetGroup
763  
764 =over
765  
766 =item TargetGroupArn => Str
767  
768  
769 =back
770  
771 Each argument is described in detail in: L<Paws::ELBv2::DeleteTargetGroup>
772  
773 Returns: a L<Paws::ELBv2::DeleteTargetGroupOutput> instance
774  
775 Deletes the specified target group.
776  
777 You can delete a target group if it is not referenced by any actions.
778 Deleting a target group also deletes any associated health checks.
779 Deleting a target group does not affect its registered targets. For
780 example, any EC2 instances continue to run until you stop or terminate
781 them.
782  
783  
784 =head2 DeregisterTargets
785  
786 =over
787  
788 =item TargetGroupArn => Str
789  
790 =item Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>]
791  
792  
793 =back
794  
795 Each argument is described in detail in: L<Paws::ELBv2::DeregisterTargets>
796  
797 Returns: a L<Paws::ELBv2::DeregisterTargetsOutput> instance
798  
799 Deregisters the specified targets from the specified target group.
800 After the targets are deregistered, they no longer receive traffic from
801 the load balancer.
802  
803  
804 =head2 DescribeAccountLimits
805  
806 =over
807  
808 =item [Marker => Str]
809  
810 =item [PageSize => Int]
811  
812  
813 =back
814  
815 Each argument is described in detail in: L<Paws::ELBv2::DescribeAccountLimits>
816  
817 Returns: a L<Paws::ELBv2::DescribeAccountLimitsOutput> instance
818  
819 Describes the current Elastic Load Balancing resource limits for your
820 Amazon Web Services account.
821  
822 For more information, see the following:
823  
824 =over
825  
826 =item *
827  
828 Quotas for your Application Load Balancers
829 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html)
830  
831 =item *
832  
833 Quotas for your Network Load Balancers
834 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-limits.html)
835  
836 =item *
837  
838 Quotas for your Gateway Load Balancers
839 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/quotas-limits.html)
840  
841 =back
842  
843  
844  
845 =head2 DescribeListenerCertificates
846  
847 =over
848  
849 =item ListenerArn => Str
850  
851 =item [Marker => Str]
852  
853 =item [PageSize => Int]
854  
855  
856 =back
857  
858 Each argument is described in detail in: L<Paws::ELBv2::DescribeListenerCertificates>
859  
860 Returns: a L<Paws::ELBv2::DescribeListenerCertificatesOutput> instance
861  
862 Describes the default certificate and the certificate list for the
863 specified HTTPS or TLS listener.
864  
865 If the default certificate is also in the certificate list, it appears
866 twice in the results (once with C<IsDefault> set to true and once with
867 C<IsDefault> set to false).
868  
869 For more information, see SSL certificates
870 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#https-listener-certificates)
871 in the I<Application Load Balancers Guide> or Server certificates
872 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#tls-listener-certificate)
873 in the I<Network Load Balancers Guide>.
874  
875  
876 =head2 DescribeListeners
877  
878 =over
879  
880 =item [ListenerArns => ArrayRef[Str|Undef]]
881  
882 =item [LoadBalancerArn => Str]
883  
884 =item [Marker => Str]
885  
886 =item [PageSize => Int]
887  
888  
889 =back
890  
891 Each argument is described in detail in: L<Paws::ELBv2::DescribeListeners>
892  
893 Returns: a L<Paws::ELBv2::DescribeListenersOutput> instance
894  
895 Describes the specified listeners or the listeners for the specified
896 Application Load Balancer, Network Load Balancer, or Gateway Load
897 Balancer. You must specify either a load balancer or one or more
898 listeners.
899  
900  
901 =head2 DescribeLoadBalancerAttributes
902  
903 =over
904  
905 =item LoadBalancerArn => Str
906  
907  
908 =back
909  
910 Each argument is described in detail in: L<Paws::ELBv2::DescribeLoadBalancerAttributes>
911  
912 Returns: a L<Paws::ELBv2::DescribeLoadBalancerAttributesOutput> instance
913  
914 Describes the attributes for the specified Application Load Balancer,
915 Network Load Balancer, or Gateway Load Balancer.
916  
917 For more information, see the following:
918  
919 =over
920  
921 =item *
922  
923 Load balancer attributes
924 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html#load-balancer-attributes)
925 in the I<Application Load Balancers Guide>
926  
927 =item *
928  
929 Load balancer attributes
930 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#load-balancer-attributes)
931 in the I<Network Load Balancers Guide>
932  
933 =item *
934  
935 Load balancer attributes
936 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-load-balancers.html#load-balancer-attributes)
937 in the I<Gateway Load Balancers Guide>
938  
939 =back
940  
941  
942  
943 =head2 DescribeLoadBalancers
944  
945 =over
946  
947 =item [LoadBalancerArns => ArrayRef[Str|Undef]]
948  
949 =item [Marker => Str]
950  
951 =item [Names => ArrayRef[Str|Undef]]
952  
953 =item [PageSize => Int]
954  
955  
956 =back
957  
958 Each argument is described in detail in: L<Paws::ELBv2::DescribeLoadBalancers>
959  
960 Returns: a L<Paws::ELBv2::DescribeLoadBalancersOutput> instance
961  
962 Describes the specified load balancers or all of your load balancers.
963  
964  
965 =head2 DescribeRules
966  
967 =over
968  
969 =item [ListenerArn => Str]
970  
971 =item [Marker => Str]
972  
973 =item [PageSize => Int]
974  
975 =item [RuleArns => ArrayRef[Str|Undef]]
976  
977  
978 =back
979  
980 Each argument is described in detail in: L<Paws::ELBv2::DescribeRules>
981  
982 Returns: a L<Paws::ELBv2::DescribeRulesOutput> instance
983  
984 Describes the specified rules or the rules for the specified listener.
985 You must specify either a listener or one or more rules.
986  
987  
988 =head2 DescribeSSLPolicies
989  
990 =over
991  
992 =item [Marker => Str]
993  
994 =item [Names => ArrayRef[Str|Undef]]
995  
996 =item [PageSize => Int]
997  
998  
999 =back
1000  
1001 Each argument is described in detail in: L<Paws::ELBv2::DescribeSSLPolicies>
1002  
1003 Returns: a L<Paws::ELBv2::DescribeSSLPoliciesOutput> instance
1004  
1005 Describes the specified policies or all policies used for SSL
1006 negotiation.
1007  
1008 For more information, see Security policies
1009 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies)
1010 in the I<Application Load Balancers Guide> or Security policies
1011 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies)
1012 in the I<Network Load Balancers Guide>.
1013  
1014  
1015 =head2 DescribeTags
1016  
1017 =over
1018  
1019 =item ResourceArns => ArrayRef[Str|Undef]
1020  
1021  
1022 =back
1023  
1024 Each argument is described in detail in: L<Paws::ELBv2::DescribeTags>
1025  
1026 Returns: a L<Paws::ELBv2::DescribeTagsOutput> instance
1027  
1028 Describes the tags for the specified Elastic Load Balancing resources.
1029 You can describe the tags for one or more Application Load Balancers,
1030 Network Load Balancers, Gateway Load Balancers, target groups,
1031 listeners, or rules.
1032  
1033  
1034 =head2 DescribeTargetGroupAttributes
1035  
1036 =over
1037  
1038 =item TargetGroupArn => Str
1039  
1040  
1041 =back
1042  
1043 Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetGroupAttributes>
1044  
1045 Returns: a L<Paws::ELBv2::DescribeTargetGroupAttributesOutput> instance
1046  
1047 Describes the attributes for the specified target group.
1048  
1049 For more information, see the following:
1050  
1051 =over
1052  
1053 =item *
1054  
1055 Target group attributes
1056 (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes)
1057 in the I<Application Load Balancers Guide>
1058  
1059 =item *
1060  
1061 Target group attributes
1062 (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-group-attributes)
1063 in the I<Network Load Balancers Guide>
1064  
1065 =item *
1066  
1067 Target group attributes
1068 (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/target-groups.html#target-group-attributes)
1069 in the I<Gateway Load Balancers Guide>
1070  
1071 =back
1072  
1073  
1074  
1075 =head2 DescribeTargetGroups
1076  
1077 =over
1078  
1079 =item [LoadBalancerArn => Str]
1080  
1081 =item [Marker => Str]
1082  
1083 =item [Names => ArrayRef[Str|Undef]]
1084  
1085 =item [PageSize => Int]
1086  
1087 =item [TargetGroupArns => ArrayRef[Str|Undef]]
1088  
1089  
1090 =back
1091  
1092 Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetGroups>
1093  
1094 Returns: a L<Paws::ELBv2::DescribeTargetGroupsOutput> instance
1095  
1096 Describes the specified target groups or all of your target groups. By
1097 default, all target groups are described. Alternatively, you can
1098 specify one of the following to filter the results: the ARN of the load
1099 balancer, the names of one or more target groups, or the ARNs of one or
1100 more target groups.
1101  
1102  
1103 =head2 DescribeTargetHealth
1104  
1105 =over
1106  
1107 =item TargetGroupArn => Str
1108  
1109 =item [Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>]]
1110  
1111  
1112 =back
1113  
1114 Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetHealth>
1115  
1116 Returns: a L<Paws::ELBv2::DescribeTargetHealthOutput> instance
1117  
1118 Describes the health of the specified targets or all of your targets.
1119  
1120  
1121 =head2 ModifyListener
1122  
1123 =over
1124  
1125 =item ListenerArn => Str
1126  
1127 =item [AlpnPolicy => ArrayRef[Str|Undef]]
1128  
1129 =item [Certificates => ArrayRef[L<Paws::ELBv2::Certificate>]]
1130  
1131 =item [DefaultActions => ArrayRef[L<Paws::ELBv2::Action>]]
1132  
1133 =item [Port => Int]
1134  
1135 =item [Protocol => Str]
1136  
1137 =item [SslPolicy => Str]
1138  
1139  
1140 =back
1141  
1142 Each argument is described in detail in: L<Paws::ELBv2::ModifyListener>
1143  
1144 Returns: a L<Paws::ELBv2::ModifyListenerOutput> instance
1145  
1146 Replaces the specified properties of the specified listener. Any
1147 properties that you do not specify remain unchanged.
1148  
1149 Changing the protocol from HTTPS to HTTP, or from TLS to TCP, removes
1150 the security policy and default certificate properties. If you change
1151 the protocol from HTTP to HTTPS, or from TCP to TLS, you must add the
1152 security policy and default certificate properties.
1153  
1154 To add an item to a list, remove an item from a list, or update an item
1155 in a list, you must provide the entire list. For example, to add an
1156 action, specify a list with the current actions plus the new action.
1157  
1158  
1159 =head2 ModifyLoadBalancerAttributes
1160  
1161 =over
1162  
1163 =item Attributes => ArrayRef[L<Paws::ELBv2::LoadBalancerAttribute>]
1164  
1165 =item LoadBalancerArn => Str
1166  
1167  
1168 =back
1169  
1170 Each argument is described in detail in: L<Paws::ELBv2::ModifyLoadBalancerAttributes>
1171  
1172 Returns: a L<Paws::ELBv2::ModifyLoadBalancerAttributesOutput> instance
1173  
1174 Modifies the specified attributes of the specified Application Load
1175 Balancer, Network Load Balancer, or Gateway Load Balancer.
1176  
1177 If any of the specified attributes can't be modified as requested, the
1178 call fails. Any existing attributes that you do not modify retain their
1179 current values.
1180  
1181  
1182 =head2 ModifyRule
1183  
1184 =over
1185  
1186 =item RuleArn => Str
1187  
1188 =item [Actions => ArrayRef[L<Paws::ELBv2::Action>]]
1189  
1190 =item [Conditions => ArrayRef[L<Paws::ELBv2::RuleCondition>]]
1191  
1192  
1193 =back
1194  
1195 Each argument is described in detail in: L<Paws::ELBv2::ModifyRule>
1196  
1197 Returns: a L<Paws::ELBv2::ModifyRuleOutput> instance
1198  
1199 Replaces the specified properties of the specified rule. Any properties
1200 that you do not specify are unchanged.
1201  
1202 To add an item to a list, remove an item from a list, or update an item
1203 in a list, you must provide the entire list. For example, to add an
1204 action, specify a list with the current actions plus the new action.
1205  
1206  
1207 =head2 ModifyTargetGroup
1208  
1209 =over
1210  
1211 =item TargetGroupArn => Str
1212  
1213 =item [HealthCheckEnabled => Bool]
1214  
1215 =item [HealthCheckIntervalSeconds => Int]
1216  
1217 =item [HealthCheckPath => Str]
1218  
1219 =item [HealthCheckPort => Str]
1220  
1221 =item [HealthCheckProtocol => Str]
1222  
1223 =item [HealthCheckTimeoutSeconds => Int]
1224  
1225 =item [HealthyThresholdCount => Int]
1226  
1227 =item [Matcher => L<Paws::ELBv2::Matcher>]
1228  
1229 =item [UnhealthyThresholdCount => Int]
1230  
1231  
1232 =back
1233  
1234 Each argument is described in detail in: L<Paws::ELBv2::ModifyTargetGroup>
1235  
1236 Returns: a L<Paws::ELBv2::ModifyTargetGroupOutput> instance
1237  
1238 Modifies the health checks used when evaluating the health state of the
1239 targets in the specified target group.
1240  
1241  
1242 =head2 ModifyTargetGroupAttributes
1243  
1244 =over
1245  
1246 =item Attributes => ArrayRef[L<Paws::ELBv2::TargetGroupAttribute>]
1247  
1248 =item TargetGroupArn => Str
1249  
1250  
1251 =back
1252  
1253 Each argument is described in detail in: L<Paws::ELBv2::ModifyTargetGroupAttributes>
1254  
1255 Returns: a L<Paws::ELBv2::ModifyTargetGroupAttributesOutput> instance
1256  
1257 Modifies the specified attributes of the specified target group.
1258  
1259  
1260 =head2 RegisterTargets
1261  
1262 =over
1263  
1264 =item TargetGroupArn => Str
1265  
1266 =item Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>]
1267  
1268  
1269 =back
1270  
1271 Each argument is described in detail in: L<Paws::ELBv2::RegisterTargets>
1272  
1273 Returns: a L<Paws::ELBv2::RegisterTargetsOutput> instance
1274  
1275 Registers the specified targets with the specified target group.
1276  
1277 If the target is an EC2 instance, it must be in the C<running> state
1278 when you register it.
1279  
1280 By default, the load balancer routes requests to registered targets
1281 using the protocol and port for the target group. Alternatively, you
1282 can override the port for a target when you register it. You can
1283 register each EC2 instance or IP address with the same target group
1284 multiple times using different ports.
1285  
1286 With a Network Load Balancer, you cannot register instances by instance
1287 ID if they have the following instance types: C1, CC1, CC2, CG1, CG2,
1288 CR1, CS1, G1, G2, HI1, HS1, M1, M2, M3, and T1. You can register
1289 instances of these types by IP address.
1290  
1291  
1292 =head2 RemoveListenerCertificates
1293  
1294 =over
1295  
1296 =item Certificates => ArrayRef[L<Paws::ELBv2::Certificate>]
1297  
1298 =item ListenerArn => Str
1299  
1300  
1301 =back
1302  
1303 Each argument is described in detail in: L<Paws::ELBv2::RemoveListenerCertificates>
1304  
1305 Returns: a L<Paws::ELBv2::RemoveListenerCertificatesOutput> instance
1306  
1307 Removes the specified certificate from the certificate list for the
1308 specified HTTPS or TLS listener.
1309  
1310  
1311 =head2 RemoveTags
1312  
1313 =over
1314  
1315 =item ResourceArns => ArrayRef[Str|Undef]
1316  
1317 =item TagKeys => ArrayRef[Str|Undef]
1318  
1319  
1320 =back
1321  
1322 Each argument is described in detail in: L<Paws::ELBv2::RemoveTags>
1323  
1324 Returns: a L<Paws::ELBv2::RemoveTagsOutput> instance
1325  
1326 Removes the specified tags from the specified Elastic Load Balancing
1327 resources. You can remove the tags for one or more Application Load
1328 Balancers, Network Load Balancers, Gateway Load Balancers, target
1329 groups, listeners, or rules.
1330  
1331  
1332 =head2 SetIpAddressType
1333  
1334 =over
1335  
1336 =item IpAddressType => Str
1337  
1338 =item LoadBalancerArn => Str
1339  
1340  
1341 =back
1342  
1343 Each argument is described in detail in: L<Paws::ELBv2::SetIpAddressType>
1344  
1345 Returns: a L<Paws::ELBv2::SetIpAddressTypeOutput> instance
1346  
1347 Sets the type of IP addresses used by the subnets of the specified
1348 Application Load Balancer or Network Load Balancer.
1349  
1350  
1351 =head2 SetRulePriorities
1352  
1353 =over
1354  
1355 =item RulePriorities => ArrayRef[L<Paws::ELBv2::RulePriorityPair>]
1356  
1357  
1358 =back
1359  
1360 Each argument is described in detail in: L<Paws::ELBv2::SetRulePriorities>
1361  
1362 Returns: a L<Paws::ELBv2::SetRulePrioritiesOutput> instance
1363  
1364 Sets the priorities of the specified rules.
1365  
1366 You can reorder the rules as long as there are no priority conflicts in
1367 the new order. Any existing rules that you do not specify retain their
1368 current priority.
1369  
1370  
1371 =head2 SetSecurityGroups
1372  
1373 =over
1374  
1375 =item LoadBalancerArn => Str
1376  
1377 =item SecurityGroups => ArrayRef[Str|Undef]
1378  
1379  
1380 =back
1381  
1382 Each argument is described in detail in: L<Paws::ELBv2::SetSecurityGroups>
1383  
1384 Returns: a L<Paws::ELBv2::SetSecurityGroupsOutput> instance
1385  
1386 Associates the specified security groups with the specified Application
1387 Load Balancer. The specified security groups override the previously
1388 associated security groups.
1389  
1390 You can't specify a security group for a Network Load Balancer or
1391 Gateway Load Balancer.
1392  
1393  
1394 =head2 SetSubnets
1395  
1396 =over
1397  
1398 =item LoadBalancerArn => Str
1399  
1400 =item [IpAddressType => Str]
1401  
1402 =item [SubnetMappings => ArrayRef[L<Paws::ELBv2::SubnetMapping>]]
1403  
1404 =item [Subnets => ArrayRef[Str|Undef]]
1405  
1406  
1407 =back
1408  
1409 Each argument is described in detail in: L<Paws::ELBv2::SetSubnets>
1410  
1411 Returns: a L<Paws::ELBv2::SetSubnetsOutput> instance
1412  
1413 Enables the Availability Zones for the specified public subnets for the
1414 specified Application Load Balancer or Network Load Balancer. The
1415 specified subnets replace the previously enabled subnets.
1416  
1417 When you specify subnets for a Network Load Balancer, you must include
1418 all subnets that were enabled previously, with their existing
1419 configurations, plus any additional subnets.
1420  
1421  
1422  
1423  
1424 =head1 PAGINATORS
1425  
1426 Paginator methods are helpers that repetively call methods that return partial results
1427  
1428 =head2 DescribeAllAccountLimits(sub { },[Marker => Str, PageSize => Int])
1429  
1430 =head2 DescribeAllAccountLimits([Marker => Str, PageSize => Int])
1431  
1432  
1433 If passed a sub as first parameter, it will call the sub for each element found in :
1434  
1435 - Limits, passing the object as the first parameter, and the string 'Limits' as the second parameter
1436  
1437 If not, it will return a a L<Paws::ELBv2::DescribeAccountLimitsOutput> 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.
1438  
1439  
1440 =head2 DescribeAllListenerCertificates(sub { },ListenerArn => Str, [Marker => Str, PageSize => Int])
1441  
1442 =head2 DescribeAllListenerCertificates(ListenerArn => Str, [Marker => Str, PageSize => Int])
1443  
1444  
1445 If passed a sub as first parameter, it will call the sub for each element found in :
1446  
1447 - Certificates, passing the object as the first parameter, and the string 'Certificates' as the second parameter
1448  
1449 If not, it will return a a L<Paws::ELBv2::DescribeListenerCertificatesOutput> 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.
1450  
1451  
1452 =head2 DescribeAllListeners(sub { },[ListenerArns => ArrayRef[Str|Undef], LoadBalancerArn => Str, Marker => Str, PageSize => Int])
1453  
1454 =head2 DescribeAllListeners([ListenerArns => ArrayRef[Str|Undef], LoadBalancerArn => Str, Marker => Str, PageSize => Int])
1455  
1456  
1457 If passed a sub as first parameter, it will call the sub for each element found in :
1458  
1459 - Listeners, passing the object as the first parameter, and the string 'Listeners' as the second parameter
1460  
1461 If not, it will return a a L<Paws::ELBv2::DescribeListenersOutput> 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.
1462  
1463  
1464 =head2 DescribeAllLoadBalancers(sub { },[LoadBalancerArns => ArrayRef[Str|Undef], Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
1465  
1466 =head2 DescribeAllLoadBalancers([LoadBalancerArns => ArrayRef[Str|Undef], Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
1467  
1468  
1469 If passed a sub as first parameter, it will call the sub for each element found in :
1470  
1471 - LoadBalancers, passing the object as the first parameter, and the string 'LoadBalancers' as the second parameter
1472  
1473 If not, it will return a a L<Paws::ELBv2::DescribeLoadBalancersOutput> 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.
1474  
1475  
1476 =head2 DescribeAllRules(sub { },[ListenerArn => Str, Marker => Str, PageSize => Int, RuleArns => ArrayRef[Str|Undef]])
1477  
1478 =head2 DescribeAllRules([ListenerArn => Str, Marker => Str, PageSize => Int, RuleArns => ArrayRef[Str|Undef]])
1479  
1480  
1481 If passed a sub as first parameter, it will call the sub for each element found in :
1482  
1483 - Rules, passing the object as the first parameter, and the string 'Rules' as the second parameter
1484  
1485 If not, it will return a a L<Paws::ELBv2::DescribeRulesOutput> 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.
1486  
1487  
1488 =head2 DescribeAllSSLPolicies(sub { },[Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
1489  
1490 =head2 DescribeAllSSLPolicies([Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
1491  
1492  
1493 If passed a sub as first parameter, it will call the sub for each element found in :
1494  
1495 - SslPolicies, passing the object as the first parameter, and the string 'SslPolicies' as the second parameter
1496  
1497 If not, it will return a a L<Paws::ELBv2::DescribeSSLPoliciesOutput> 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.
1498  
1499  
1500 =head2 DescribeAllTargetGroups(sub { },[LoadBalancerArn => Str, Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int, TargetGroupArns => ArrayRef[Str|Undef]])
1501  
1502 =head2 DescribeAllTargetGroups([LoadBalancerArn => Str, Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int, TargetGroupArns => ArrayRef[Str|Undef]])
1503  
1504  
1505 If passed a sub as first parameter, it will call the sub for each element found in :
1506  
1507 - TargetGroups, passing the object as the first parameter, and the string 'TargetGroups' as the second parameter
1508  
1509 If not, it will return a a L<Paws::ELBv2::DescribeTargetGroupsOutput> 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.
1510  
1511  
1512  
1513  
1514  
1515 =head1 SEE ALSO
1516  
1517 This service class forms part of L<Paws>
1518  
1519 =head1 BUGS and CONTRIBUTIONS
1520  
1521 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1522  
1523 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1524  
1525 =cut
1526