File Coverage

blib/lib/Paws/ELBv2.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::ELBv2;
2 1     1   3987 use Moose;
  1         4  
  1         7  
3             sub service { 'elasticloadbalancing' }
4             sub version { '2015-12-01' }
5             sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse';
14              
15            
16             sub AddTags {
17             my $self = shift;
18             my $call_object = $self->new_with_coercions('Paws::ELBv2::AddTags', @_);
19             return $self->caller->do_call($self, $call_object);
20             }
21             sub CreateListener {
22             my $self = shift;
23             my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateListener', @_);
24             return $self->caller->do_call($self, $call_object);
25             }
26             sub CreateLoadBalancer {
27             my $self = shift;
28             my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateLoadBalancer', @_);
29             return $self->caller->do_call($self, $call_object);
30             }
31             sub CreateRule {
32             my $self = shift;
33             my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateRule', @_);
34             return $self->caller->do_call($self, $call_object);
35             }
36             sub CreateTargetGroup {
37             my $self = shift;
38             my $call_object = $self->new_with_coercions('Paws::ELBv2::CreateTargetGroup', @_);
39             return $self->caller->do_call($self, $call_object);
40             }
41             sub DeleteListener {
42             my $self = shift;
43             my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteListener', @_);
44             return $self->caller->do_call($self, $call_object);
45             }
46             sub DeleteLoadBalancer {
47             my $self = shift;
48             my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteLoadBalancer', @_);
49             return $self->caller->do_call($self, $call_object);
50             }
51             sub DeleteRule {
52             my $self = shift;
53             my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteRule', @_);
54             return $self->caller->do_call($self, $call_object);
55             }
56             sub DeleteTargetGroup {
57             my $self = shift;
58             my $call_object = $self->new_with_coercions('Paws::ELBv2::DeleteTargetGroup', @_);
59             return $self->caller->do_call($self, $call_object);
60             }
61             sub DeregisterTargets {
62             my $self = shift;
63             my $call_object = $self->new_with_coercions('Paws::ELBv2::DeregisterTargets', @_);
64             return $self->caller->do_call($self, $call_object);
65             }
66             sub DescribeAccountLimits {
67             my $self = shift;
68             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeAccountLimits', @_);
69             return $self->caller->do_call($self, $call_object);
70             }
71             sub DescribeListeners {
72             my $self = shift;
73             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeListeners', @_);
74             return $self->caller->do_call($self, $call_object);
75             }
76             sub DescribeLoadBalancerAttributes {
77             my $self = shift;
78             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeLoadBalancerAttributes', @_);
79             return $self->caller->do_call($self, $call_object);
80             }
81             sub DescribeLoadBalancers {
82             my $self = shift;
83             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeLoadBalancers', @_);
84             return $self->caller->do_call($self, $call_object);
85             }
86             sub DescribeRules {
87             my $self = shift;
88             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeRules', @_);
89             return $self->caller->do_call($self, $call_object);
90             }
91             sub DescribeSSLPolicies {
92             my $self = shift;
93             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeSSLPolicies', @_);
94             return $self->caller->do_call($self, $call_object);
95             }
96             sub DescribeTags {
97             my $self = shift;
98             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTags', @_);
99             return $self->caller->do_call($self, $call_object);
100             }
101             sub DescribeTargetGroupAttributes {
102             my $self = shift;
103             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetGroupAttributes', @_);
104             return $self->caller->do_call($self, $call_object);
105             }
106             sub DescribeTargetGroups {
107             my $self = shift;
108             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetGroups', @_);
109             return $self->caller->do_call($self, $call_object);
110             }
111             sub DescribeTargetHealth {
112             my $self = shift;
113             my $call_object = $self->new_with_coercions('Paws::ELBv2::DescribeTargetHealth', @_);
114             return $self->caller->do_call($self, $call_object);
115             }
116             sub ModifyListener {
117             my $self = shift;
118             my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyListener', @_);
119             return $self->caller->do_call($self, $call_object);
120             }
121             sub ModifyLoadBalancerAttributes {
122             my $self = shift;
123             my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyLoadBalancerAttributes', @_);
124             return $self->caller->do_call($self, $call_object);
125             }
126             sub ModifyRule {
127             my $self = shift;
128             my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyRule', @_);
129             return $self->caller->do_call($self, $call_object);
130             }
131             sub ModifyTargetGroup {
132             my $self = shift;
133             my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyTargetGroup', @_);
134             return $self->caller->do_call($self, $call_object);
135             }
136             sub ModifyTargetGroupAttributes {
137             my $self = shift;
138             my $call_object = $self->new_with_coercions('Paws::ELBv2::ModifyTargetGroupAttributes', @_);
139             return $self->caller->do_call($self, $call_object);
140             }
141             sub RegisterTargets {
142             my $self = shift;
143             my $call_object = $self->new_with_coercions('Paws::ELBv2::RegisterTargets', @_);
144             return $self->caller->do_call($self, $call_object);
145             }
146             sub RemoveTags {
147             my $self = shift;
148             my $call_object = $self->new_with_coercions('Paws::ELBv2::RemoveTags', @_);
149             return $self->caller->do_call($self, $call_object);
150             }
151             sub SetIpAddressType {
152             my $self = shift;
153             my $call_object = $self->new_with_coercions('Paws::ELBv2::SetIpAddressType', @_);
154             return $self->caller->do_call($self, $call_object);
155             }
156             sub SetRulePriorities {
157             my $self = shift;
158             my $call_object = $self->new_with_coercions('Paws::ELBv2::SetRulePriorities', @_);
159             return $self->caller->do_call($self, $call_object);
160             }
161             sub SetSecurityGroups {
162             my $self = shift;
163             my $call_object = $self->new_with_coercions('Paws::ELBv2::SetSecurityGroups', @_);
164             return $self->caller->do_call($self, $call_object);
165             }
166             sub SetSubnets {
167             my $self = shift;
168             my $call_object = $self->new_with_coercions('Paws::ELBv2::SetSubnets', @_);
169             return $self->caller->do_call($self, $call_object);
170             }
171            
172             sub DescribeAllListeners {
173             my $self = shift;
174              
175             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
176             my $result = $self->DescribeListeners(@_);
177             my $next_result = $result;
178              
179             if (not defined $callback) {
180             while ($next_result->NextMarker) {
181             $next_result = $self->DescribeListeners(@_, Marker => $next_result->NextMarker);
182             push @{ $result->Listeners }, @{ $next_result->Listeners };
183             }
184             return $result;
185             } else {
186             while ($result->NextMarker) {
187             $callback->($_ => 'Listeners') foreach (@{ $result->Listeners });
188             $result = $self->DescribeListeners(@_, Marker => $result->NextMarker);
189             }
190             $callback->($_ => 'Listeners') foreach (@{ $result->Listeners });
191             }
192              
193             return undef
194             }
195             sub DescribeAllLoadBalancers {
196             my $self = shift;
197              
198             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
199             my $result = $self->DescribeLoadBalancers(@_);
200             my $next_result = $result;
201              
202             if (not defined $callback) {
203             while ($next_result->NextMarker) {
204             $next_result = $self->DescribeLoadBalancers(@_, Marker => $next_result->NextMarker);
205             push @{ $result->LoadBalancers }, @{ $next_result->LoadBalancers };
206             }
207             return $result;
208             } else {
209             while ($result->NextMarker) {
210             $callback->($_ => 'LoadBalancers') foreach (@{ $result->LoadBalancers });
211             $result = $self->DescribeLoadBalancers(@_, Marker => $result->NextMarker);
212             }
213             $callback->($_ => 'LoadBalancers') foreach (@{ $result->LoadBalancers });
214             }
215              
216             return undef
217             }
218             sub DescribeAllTargetGroups {
219             my $self = shift;
220              
221             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
222             my $result = $self->DescribeTargetGroups(@_);
223             my $next_result = $result;
224              
225             if (not defined $callback) {
226             while ($next_result->NextMarker) {
227             $next_result = $self->DescribeTargetGroups(@_, Marker => $next_result->NextMarker);
228             push @{ $result->TargetGroups }, @{ $next_result->TargetGroups };
229             }
230             return $result;
231             } else {
232             while ($result->NextMarker) {
233             $callback->($_ => 'TargetGroups') foreach (@{ $result->TargetGroups });
234             $result = $self->DescribeTargetGroups(@_, Marker => $result->NextMarker);
235             }
236             $callback->($_ => 'TargetGroups') foreach (@{ $result->TargetGroups });
237             }
238              
239             return undef
240             }
241              
242              
243             sub operations { qw/AddTags CreateListener CreateLoadBalancer CreateRule CreateTargetGroup DeleteListener DeleteLoadBalancer DeleteRule DeleteTargetGroup DeregisterTargets DescribeAccountLimits DescribeListeners DescribeLoadBalancerAttributes DescribeLoadBalancers DescribeRules DescribeSSLPolicies DescribeTags DescribeTargetGroupAttributes DescribeTargetGroups DescribeTargetHealth ModifyListener ModifyLoadBalancerAttributes ModifyRule ModifyTargetGroup ModifyTargetGroupAttributes RegisterTargets RemoveTags SetIpAddressType SetRulePriorities SetSecurityGroups SetSubnets / }
244              
245             1;
246              
247             ### main pod documentation begin ###
248              
249             =head1 NAME
250              
251             Paws::ELBv2 - Perl Interface to AWS Elastic Load Balancing
252              
253             =head1 SYNOPSIS
254              
255             use Paws;
256              
257             my $obj = Paws->service('ELBv2');
258             my $res = $obj->Method(
259             Arg1 => $val1,
260             Arg2 => [ 'V1', 'V2' ],
261             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
262             # of the arguments type
263             Arg3 => { Att1 => 'Val1' },
264             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
265             # the constructor of the arguments type
266             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
267             );
268              
269             =head1 DESCRIPTION
270              
271             Elastic Load Balancing
272              
273             A load balancer distributes incoming traffic across targets, such as
274             your EC2 instances. This enables you to increase the availability of
275             your application. The load balancer also monitors the health of its
276             registered targets and ensures that it routes traffic only to healthy
277             targets. You configure your load balancer to accept incoming traffic by
278             specifying one or more listeners, which are configured with a protocol
279             and port number for connections from clients to the load balancer. You
280             configure a target group with a protocol and port number for
281             connections from the load balancer to the targets, and with health
282             check settings to be used when checking the health status of the
283             targets.
284              
285             Elastic Load Balancing supports the following types of load balancers:
286             Application Load Balancers, Network Load Balancers, and Classic Load
287             Balancers.
288              
289             An Application Load Balancer makes routing and load balancing decisions
290             at the application layer (HTTP/HTTPS). A Network Load Balancer makes
291             routing and load balancing decisions at the transport layer (TCP). Both
292             Application Load Balancers and Network Load Balancers can route
293             requests to one or more ports on each EC2 instance or container
294             instance in your virtual private cloud (VPC).
295              
296             A Classic Load Balancer makes routing and load balancing decisions
297             either at the transport layer (TCP/SSL) or the application layer
298             (HTTP/HTTPS), and supports either EC2-Classic or a VPC. For more
299             information, see the Elastic Load Balancing User Guide.
300              
301             This reference covers the 2015-12-01 API, which supports Application
302             Load Balancers and Network Load Balancers. The 2012-06-01 API supports
303             Classic Load Balancers.
304              
305             To get started, complete the following tasks:
306              
307             =over
308              
309             =item 1.
310              
311             Create a load balancer using CreateLoadBalancer.
312              
313             =item 2.
314              
315             Create a target group using CreateTargetGroup.
316              
317             =item 3.
318              
319             Register targets for the target group using RegisterTargets.
320              
321             =item 4.
322              
323             Create one or more listeners for your load balancer using
324             CreateListener.
325              
326             =back
327              
328             To delete a load balancer and its related resources, complete the
329             following tasks:
330              
331             =over
332              
333             =item 1.
334              
335             Delete the load balancer using DeleteLoadBalancer.
336              
337             =item 2.
338              
339             Delete the target group using DeleteTargetGroup.
340              
341             =back
342              
343             All Elastic Load Balancing operations are idempotent, which means that
344             they complete at most one time. If you repeat an operation, it
345             succeeds.
346              
347             =head1 METHODS
348              
349             =head2 AddTags(ResourceArns => ArrayRef[Str|Undef], Tags => ArrayRef[L<Paws::ELBv2::Tag>])
350              
351             Each argument is described in detail in: L<Paws::ELBv2::AddTags>
352              
353             Returns: a L<Paws::ELBv2::AddTagsOutput> instance
354              
355             Adds the specified tags to the specified Elastic Load Balancing
356             resource. You can tag your Application Load Balancers, Network Load
357             Balancers, and your target groups.
358              
359             Each tag consists of a key and an optional value. If a resource already
360             has a tag with the same key, C<AddTags> updates its value.
361              
362             To list the current tags for your resources, use DescribeTags. To
363             remove tags from your resources, use RemoveTags.
364              
365              
366             =head2 CreateListener(DefaultActions => ArrayRef[L<Paws::ELBv2::Action>], LoadBalancerArn => Str, Port => Int, Protocol => Str, [Certificates => ArrayRef[L<Paws::ELBv2::Certificate>], SslPolicy => Str])
367              
368             Each argument is described in detail in: L<Paws::ELBv2::CreateListener>
369              
370             Returns: a L<Paws::ELBv2::CreateListenerOutput> instance
371              
372             Creates a listener for the specified Application Load Balancer or
373             Network Load Balancer.
374              
375             You can create up to 10 listeners per load balancer.
376              
377             To update a listener, use ModifyListener. When you are finished with a
378             listener, you can delete it using DeleteListener. If you are finished
379             with both the listener and the load balancer, you can delete them both
380             using DeleteLoadBalancer.
381              
382             For more information, see Listeners for Your Application Load Balancers
383             in the I<Application Load Balancers Guide> and Listeners for Your
384             Network Load Balancers in the I<Network Load Balancers Guide>.
385              
386              
387             =head2 CreateLoadBalancer(Name => Str, [IpAddressType => Str, Scheme => Str, SecurityGroups => ArrayRef[Str|Undef], SubnetMappings => ArrayRef[L<Paws::ELBv2::SubnetMapping>], Subnets => ArrayRef[Str|Undef], Tags => ArrayRef[L<Paws::ELBv2::Tag>], Type => Str])
388              
389             Each argument is described in detail in: L<Paws::ELBv2::CreateLoadBalancer>
390              
391             Returns: a L<Paws::ELBv2::CreateLoadBalancerOutput> instance
392              
393             Creates an Application Load Balancer or a Network Load Balancer.
394              
395             When you create a load balancer, you can specify security groups,
396             subnets, IP address type, and tags. Otherwise, you could do so later
397             using SetSecurityGroups, SetSubnets, SetIpAddressType, and AddTags.
398              
399             To create listeners for your load balancer, use CreateListener. To
400             describe your current load balancers, see DescribeLoadBalancers. When
401             you are finished with a load balancer, you can delete it using
402             DeleteLoadBalancer.
403              
404             You can create up to 20 load balancers per region per account. You can
405             request an increase for the number of load balancers for your account.
406             For more information, see Limits for Your Application Load Balancer in
407             the I<Application Load Balancers Guide> and Limits for Your Network
408             Load Balancer in the I<Network Load Balancers Guide>.
409              
410             For more information, see Application Load Balancers in the
411             I<Application Load Balancers Guide> and Network Load Balancers in the
412             I<Network Load Balancers Guide>.
413              
414              
415             =head2 CreateRule(Actions => ArrayRef[L<Paws::ELBv2::Action>], Conditions => ArrayRef[L<Paws::ELBv2::RuleCondition>], ListenerArn => Str, Priority => Int)
416              
417             Each argument is described in detail in: L<Paws::ELBv2::CreateRule>
418              
419             Returns: a L<Paws::ELBv2::CreateRuleOutput> instance
420              
421             Creates a rule for the specified listener. The listener must be
422             associated with an Application Load Balancer.
423              
424             Rules are evaluated in priority order, from the lowest value to the
425             highest value. When the condition for a rule is met, the specified
426             action is taken. If no conditions are met, the action for the default
427             rule is taken. For more information, see Listener Rules in the
428             I<Application Load Balancers Guide>.
429              
430             To view your current rules, use DescribeRules. To update a rule, use
431             ModifyRule. To set the priorities of your rules, use SetRulePriorities.
432             To delete a rule, use DeleteRule.
433              
434              
435             =head2 CreateTargetGroup(Name => Str, Port => Int, Protocol => Str, VpcId => Str, [HealthCheckIntervalSeconds => Int, HealthCheckPath => Str, HealthCheckPort => Str, HealthCheckProtocol => Str, HealthCheckTimeoutSeconds => Int, HealthyThresholdCount => Int, Matcher => L<Paws::ELBv2::Matcher>, TargetType => Str, UnhealthyThresholdCount => Int])
436              
437             Each argument is described in detail in: L<Paws::ELBv2::CreateTargetGroup>
438              
439             Returns: a L<Paws::ELBv2::CreateTargetGroupOutput> instance
440              
441             Creates a target group.
442              
443             To register targets with the target group, use RegisterTargets. To
444             update the health check settings for the target group, use
445             ModifyTargetGroup. To monitor the health of targets in the target
446             group, use DescribeTargetHealth.
447              
448             To route traffic to the targets in a target group, specify the target
449             group in an action using CreateListener or CreateRule.
450              
451             To delete a target group, use DeleteTargetGroup.
452              
453             For more information, see Target Groups for Your Application Load
454             Balancers in the I<Application Load Balancers Guide> or Target Groups
455             for Your Network Load Balancers in the I<Network Load Balancers Guide>.
456              
457              
458             =head2 DeleteListener(ListenerArn => Str)
459              
460             Each argument is described in detail in: L<Paws::ELBv2::DeleteListener>
461              
462             Returns: a L<Paws::ELBv2::DeleteListenerOutput> instance
463              
464             Deletes the specified listener.
465              
466             Alternatively, your listener is deleted when you delete the load
467             balancer it is attached to using DeleteLoadBalancer.
468              
469              
470             =head2 DeleteLoadBalancer(LoadBalancerArn => Str)
471              
472             Each argument is described in detail in: L<Paws::ELBv2::DeleteLoadBalancer>
473              
474             Returns: a L<Paws::ELBv2::DeleteLoadBalancerOutput> instance
475              
476             Deletes the specified Application Load Balancer or Network Load
477             Balancer and its attached listeners.
478              
479             You can't delete a load balancer if deletion protection is enabled. If
480             the load balancer does not exist or has already been deleted, the call
481             succeeds.
482              
483             Deleting a load balancer does not affect its registered targets. For
484             example, your EC2 instances continue to run and are still registered to
485             their target groups. If you no longer need these EC2 instances, you can
486             stop or terminate them.
487              
488              
489             =head2 DeleteRule(RuleArn => Str)
490              
491             Each argument is described in detail in: L<Paws::ELBv2::DeleteRule>
492              
493             Returns: a L<Paws::ELBv2::DeleteRuleOutput> instance
494              
495             Deletes the specified rule.
496              
497              
498             =head2 DeleteTargetGroup(TargetGroupArn => Str)
499              
500             Each argument is described in detail in: L<Paws::ELBv2::DeleteTargetGroup>
501              
502             Returns: a L<Paws::ELBv2::DeleteTargetGroupOutput> instance
503              
504             Deletes the specified target group.
505              
506             You can delete a target group if it is not referenced by any actions.
507             Deleting a target group also deletes any associated health checks.
508              
509              
510             =head2 DeregisterTargets(TargetGroupArn => Str, Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>])
511              
512             Each argument is described in detail in: L<Paws::ELBv2::DeregisterTargets>
513              
514             Returns: a L<Paws::ELBv2::DeregisterTargetsOutput> instance
515              
516             Deregisters the specified targets from the specified target group.
517             After the targets are deregistered, they no longer receive traffic from
518             the load balancer.
519              
520              
521             =head2 DescribeAccountLimits([Marker => Str, PageSize => Int])
522              
523             Each argument is described in detail in: L<Paws::ELBv2::DescribeAccountLimits>
524              
525             Returns: a L<Paws::ELBv2::DescribeAccountLimitsOutput> instance
526              
527             Describes the current Elastic Load Balancing resource limits for your
528             AWS account.
529              
530             For more information, see Limits for Your Application Load Balancers in
531             the I<Application Load Balancer Guide> or Limits for Your Network Load
532             Balancers in the I<Network Load Balancers Guide>.
533              
534              
535             =head2 DescribeListeners([ListenerArns => ArrayRef[Str|Undef], LoadBalancerArn => Str, Marker => Str, PageSize => Int])
536              
537             Each argument is described in detail in: L<Paws::ELBv2::DescribeListeners>
538              
539             Returns: a L<Paws::ELBv2::DescribeListenersOutput> instance
540              
541             Describes the specified listeners or the listeners for the specified
542             Application Load Balancer or Network Load Balancer. You must specify
543             either a load balancer or one or more listeners.
544              
545              
546             =head2 DescribeLoadBalancerAttributes(LoadBalancerArn => Str)
547              
548             Each argument is described in detail in: L<Paws::ELBv2::DescribeLoadBalancerAttributes>
549              
550             Returns: a L<Paws::ELBv2::DescribeLoadBalancerAttributesOutput> instance
551              
552             Describes the attributes for the specified Application Load Balancer or
553             Network Load Balancer.
554              
555              
556             =head2 DescribeLoadBalancers([LoadBalancerArns => ArrayRef[Str|Undef], Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
557              
558             Each argument is described in detail in: L<Paws::ELBv2::DescribeLoadBalancers>
559              
560             Returns: a L<Paws::ELBv2::DescribeLoadBalancersOutput> instance
561              
562             Describes the specified load balancers or all of your load balancers.
563              
564             To describe the listeners for a load balancer, use DescribeListeners.
565             To describe the attributes for a load balancer, use
566             DescribeLoadBalancerAttributes.
567              
568              
569             =head2 DescribeRules([ListenerArn => Str, Marker => Str, PageSize => Int, RuleArns => ArrayRef[Str|Undef]])
570              
571             Each argument is described in detail in: L<Paws::ELBv2::DescribeRules>
572              
573             Returns: a L<Paws::ELBv2::DescribeRulesOutput> instance
574              
575             Describes the specified rules or the rules for the specified listener.
576             You must specify either a listener or one or more rules.
577              
578              
579             =head2 DescribeSSLPolicies([Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
580              
581             Each argument is described in detail in: L<Paws::ELBv2::DescribeSSLPolicies>
582              
583             Returns: a L<Paws::ELBv2::DescribeSSLPoliciesOutput> instance
584              
585             Describes the specified policies or all policies used for SSL
586             negotiation.
587              
588             For more information, see Security Policies in the I<Application Load
589             Balancers Guide>.
590              
591              
592             =head2 DescribeTags(ResourceArns => ArrayRef[Str|Undef])
593              
594             Each argument is described in detail in: L<Paws::ELBv2::DescribeTags>
595              
596             Returns: a L<Paws::ELBv2::DescribeTagsOutput> instance
597              
598             Describes the tags for the specified resources. You can describe the
599             tags for one or more Application Load Balancers, Network Load
600             Balancers, and target groups.
601              
602              
603             =head2 DescribeTargetGroupAttributes(TargetGroupArn => Str)
604              
605             Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetGroupAttributes>
606              
607             Returns: a L<Paws::ELBv2::DescribeTargetGroupAttributesOutput> instance
608              
609             Describes the attributes for the specified target group.
610              
611              
612             =head2 DescribeTargetGroups([LoadBalancerArn => Str, Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int, TargetGroupArns => ArrayRef[Str|Undef]])
613              
614             Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetGroups>
615              
616             Returns: a L<Paws::ELBv2::DescribeTargetGroupsOutput> instance
617              
618             Describes the specified target groups or all of your target groups. By
619             default, all target groups are described. Alternatively, you can
620             specify one of the following to filter the results: the ARN of the load
621             balancer, the names of one or more target groups, or the ARNs of one or
622             more target groups.
623              
624             To describe the targets for a target group, use DescribeTargetHealth.
625             To describe the attributes of a target group, use
626             DescribeTargetGroupAttributes.
627              
628              
629             =head2 DescribeTargetHealth(TargetGroupArn => Str, [Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>]])
630              
631             Each argument is described in detail in: L<Paws::ELBv2::DescribeTargetHealth>
632              
633             Returns: a L<Paws::ELBv2::DescribeTargetHealthOutput> instance
634              
635             Describes the health of the specified targets or all of your targets.
636              
637              
638             =head2 ModifyListener(ListenerArn => Str, [Certificates => ArrayRef[L<Paws::ELBv2::Certificate>], DefaultActions => ArrayRef[L<Paws::ELBv2::Action>], Port => Int, Protocol => Str, SslPolicy => Str])
639              
640             Each argument is described in detail in: L<Paws::ELBv2::ModifyListener>
641              
642             Returns: a L<Paws::ELBv2::ModifyListenerOutput> instance
643              
644             Modifies the specified properties of the specified listener.
645              
646             Any properties that you do not specify retain their current values.
647             However, changing the protocol from HTTPS to HTTP removes the security
648             policy and SSL certificate properties. If you change the protocol from
649             HTTP to HTTPS, you must add the security policy and server certificate.
650              
651              
652             =head2 ModifyLoadBalancerAttributes(Attributes => ArrayRef[L<Paws::ELBv2::LoadBalancerAttribute>], LoadBalancerArn => Str)
653              
654             Each argument is described in detail in: L<Paws::ELBv2::ModifyLoadBalancerAttributes>
655              
656             Returns: a L<Paws::ELBv2::ModifyLoadBalancerAttributesOutput> instance
657              
658             Modifies the specified attributes of the specified Application Load
659             Balancer or Network Load Balancer.
660              
661             If any of the specified attributes can't be modified as requested, the
662             call fails. Any existing attributes that you do not modify retain their
663             current values.
664              
665              
666             =head2 ModifyRule(RuleArn => Str, [Actions => ArrayRef[L<Paws::ELBv2::Action>], Conditions => ArrayRef[L<Paws::ELBv2::RuleCondition>]])
667              
668             Each argument is described in detail in: L<Paws::ELBv2::ModifyRule>
669              
670             Returns: a L<Paws::ELBv2::ModifyRuleOutput> instance
671              
672             Modifies the specified rule.
673              
674             Any existing properties that you do not modify retain their current
675             values.
676              
677             To modify the default action, use ModifyListener.
678              
679              
680             =head2 ModifyTargetGroup(TargetGroupArn => Str, [HealthCheckIntervalSeconds => Int, HealthCheckPath => Str, HealthCheckPort => Str, HealthCheckProtocol => Str, HealthCheckTimeoutSeconds => Int, HealthyThresholdCount => Int, Matcher => L<Paws::ELBv2::Matcher>, UnhealthyThresholdCount => Int])
681              
682             Each argument is described in detail in: L<Paws::ELBv2::ModifyTargetGroup>
683              
684             Returns: a L<Paws::ELBv2::ModifyTargetGroupOutput> instance
685              
686             Modifies the health checks used when evaluating the health state of the
687             targets in the specified target group.
688              
689             To monitor the health of the targets, use DescribeTargetHealth.
690              
691              
692             =head2 ModifyTargetGroupAttributes(Attributes => ArrayRef[L<Paws::ELBv2::TargetGroupAttribute>], TargetGroupArn => Str)
693              
694             Each argument is described in detail in: L<Paws::ELBv2::ModifyTargetGroupAttributes>
695              
696             Returns: a L<Paws::ELBv2::ModifyTargetGroupAttributesOutput> instance
697              
698             Modifies the specified attributes of the specified target group.
699              
700              
701             =head2 RegisterTargets(TargetGroupArn => Str, Targets => ArrayRef[L<Paws::ELBv2::TargetDescription>])
702              
703             Each argument is described in detail in: L<Paws::ELBv2::RegisterTargets>
704              
705             Returns: a L<Paws::ELBv2::RegisterTargetsOutput> instance
706              
707             Registers the specified targets with the specified target group.
708              
709             By default, the load balancer routes requests to registered targets
710             using the protocol and port number for the target group. Alternatively,
711             you can override the port for a target when you register it.
712              
713             The target must be in the virtual private cloud (VPC) that you
714             specified for the target group. If the target is an EC2 instance, it
715             must be in the C<running> state when you register it.
716              
717             Network Load Balancers do not support the following instance types as
718             targets: C1, CC1, CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, HS1, M1, M2,
719             M3, and T1.
720              
721             To remove a target from a target group, use DeregisterTargets.
722              
723              
724             =head2 RemoveTags(ResourceArns => ArrayRef[Str|Undef], TagKeys => ArrayRef[Str|Undef])
725              
726             Each argument is described in detail in: L<Paws::ELBv2::RemoveTags>
727              
728             Returns: a L<Paws::ELBv2::RemoveTagsOutput> instance
729              
730             Removes the specified tags from the specified Elastic Load Balancing
731             resource.
732              
733             To list the current tags for your resources, use DescribeTags.
734              
735              
736             =head2 SetIpAddressType(IpAddressType => Str, LoadBalancerArn => Str)
737              
738             Each argument is described in detail in: L<Paws::ELBv2::SetIpAddressType>
739              
740             Returns: a L<Paws::ELBv2::SetIpAddressTypeOutput> instance
741              
742             Sets the type of IP addresses used by the subnets of the specified
743             Application Load Balancer or Network Load Balancer.
744              
745             Note that Network Load Balancers must use C<ipv4>.
746              
747              
748             =head2 SetRulePriorities(RulePriorities => ArrayRef[L<Paws::ELBv2::RulePriorityPair>])
749              
750             Each argument is described in detail in: L<Paws::ELBv2::SetRulePriorities>
751              
752             Returns: a L<Paws::ELBv2::SetRulePrioritiesOutput> instance
753              
754             Sets the priorities of the specified rules.
755              
756             You can reorder the rules as long as there are no priority conflicts in
757             the new order. Any existing rules that you do not specify retain their
758             current priority.
759              
760              
761             =head2 SetSecurityGroups(LoadBalancerArn => Str, SecurityGroups => ArrayRef[Str|Undef])
762              
763             Each argument is described in detail in: L<Paws::ELBv2::SetSecurityGroups>
764              
765             Returns: a L<Paws::ELBv2::SetSecurityGroupsOutput> instance
766              
767             Associates the specified security groups with the specified Application
768             Load Balancer. The specified security groups override the previously
769             associated security groups.
770              
771             Note that you can't specify a security group for a Network Load
772             Balancer.
773              
774              
775             =head2 SetSubnets(LoadBalancerArn => Str, Subnets => ArrayRef[Str|Undef], [SubnetMappings => ArrayRef[L<Paws::ELBv2::SubnetMapping>]])
776              
777             Each argument is described in detail in: L<Paws::ELBv2::SetSubnets>
778              
779             Returns: a L<Paws::ELBv2::SetSubnetsOutput> instance
780              
781             Enables the Availability Zone for the specified subnets for the
782             specified Application Load Balancer. The specified subnets replace the
783             previously enabled subnets.
784              
785             Note that you can't change the subnets for a Network Load Balancer.
786              
787              
788              
789              
790             =head1 PAGINATORS
791              
792             Paginator methods are helpers that repetively call methods that return partial results
793              
794             =head2 DescribeAllListeners(sub { },[ListenerArns => ArrayRef[Str|Undef], LoadBalancerArn => Str, Marker => Str, PageSize => Int])
795              
796             =head2 DescribeAllListeners([ListenerArns => ArrayRef[Str|Undef], LoadBalancerArn => Str, Marker => Str, PageSize => Int])
797              
798              
799             If passed a sub as first parameter, it will call the sub for each element found in :
800              
801             - Listeners, passing the object as the first parameter, and the string 'Listeners' as the second parameter
802              
803             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.
804              
805              
806             =head2 DescribeAllLoadBalancers(sub { },[LoadBalancerArns => ArrayRef[Str|Undef], Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
807              
808             =head2 DescribeAllLoadBalancers([LoadBalancerArns => ArrayRef[Str|Undef], Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int])
809              
810              
811             If passed a sub as first parameter, it will call the sub for each element found in :
812              
813             - LoadBalancers, passing the object as the first parameter, and the string 'LoadBalancers' as the second parameter
814              
815             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.
816              
817              
818             =head2 DescribeAllTargetGroups(sub { },[LoadBalancerArn => Str, Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int, TargetGroupArns => ArrayRef[Str|Undef]])
819              
820             =head2 DescribeAllTargetGroups([LoadBalancerArn => Str, Marker => Str, Names => ArrayRef[Str|Undef], PageSize => Int, TargetGroupArns => ArrayRef[Str|Undef]])
821              
822              
823             If passed a sub as first parameter, it will call the sub for each element found in :
824              
825             - TargetGroups, passing the object as the first parameter, and the string 'TargetGroups' as the second parameter
826              
827             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.
828              
829              
830              
831              
832              
833             =head1 SEE ALSO
834              
835             This service class forms part of L<Paws>
836              
837             =head1 BUGS and CONTRIBUTIONS
838              
839             The source code is located here: https://github.com/pplu/aws-sdk-perl
840              
841             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
842              
843             =cut
844