File Coverage

blib/lib/Paws/ELB.pm
Criterion Covered Total %
statement 20 115 17.3
branch 0 4 0.0
condition n/a
subroutine 8 36 22.2
pod 30 34 88.2
total 58 189 30.6


line stmt bran cond sub pod time code
1             package Paws::ELB;
2 1     1   2192 use Moose;
  1     3   2  
  1         9  
  3         2258  
  3         8  
  3         23  
3 15     15 0 58 sub service { 'elasticloadbalancing' }
4 1     1 0 5 sub version { '2012-06-01' }
5 0     0 0 0 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 0     0 1 0 my $self = shift;
18 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::AddTags', @_);
19 0         0 return $self->caller->do_call($self, $call_object);
20             }
21             sub ApplySecurityGroupsToLoadBalancer {
22 0     0 1 0 my $self = shift;
23 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::ApplySecurityGroupsToLoadBalancer', @_);
24 0         0 return $self->caller->do_call($self, $call_object);
25             }
26             sub AttachLoadBalancerToSubnets {
27 0     0 1 0 my $self = shift;
28 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::AttachLoadBalancerToSubnets', @_);
29 0         0 return $self->caller->do_call($self, $call_object);
30             }
31             sub ConfigureHealthCheck {
32 0     0 1 0 my $self = shift;
33 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::ConfigureHealthCheck', @_);
34 0         0 return $self->caller->do_call($self, $call_object);
35             }
36             sub CreateAppCookieStickinessPolicy {
37 0     0 1 0 my $self = shift;
38 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateAppCookieStickinessPolicy', @_);
39 0         0 return $self->caller->do_call($self, $call_object);
40             }
41             sub CreateLBCookieStickinessPolicy {
42 0     0 1 0 my $self = shift;
43 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLBCookieStickinessPolicy', @_);
44 0         0 return $self->caller->do_call($self, $call_object);
45             }
46             sub CreateLoadBalancer {
47 0     0 1 0 my $self = shift;
48 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancer', @_);
49 0         0 return $self->caller->do_call($self, $call_object);
50             }
51             sub CreateLoadBalancerListeners {
52 0     0 1 0 my $self = shift;
53 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancerListeners', @_);
54 0         0 return $self->caller->do_call($self, $call_object);
55             }
56             sub CreateLoadBalancerPolicy {
57 0     0 1 0 my $self = shift;
58 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancerPolicy', @_);
59 0         0 return $self->caller->do_call($self, $call_object);
60             }
61             sub DeleteLoadBalancer {
62 0     0 1 0 my $self = shift;
63 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancer', @_);
64 0         0 return $self->caller->do_call($self, $call_object);
65             }
66             sub DeleteLoadBalancerListeners {
67 0     0 1 0 my $self = shift;
68 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancerListeners', @_);
69 0         0 return $self->caller->do_call($self, $call_object);
70             }
71             sub DeleteLoadBalancerPolicy {
72 0     0 1 0 my $self = shift;
73 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancerPolicy', @_);
74 0         0 return $self->caller->do_call($self, $call_object);
75             }
76             sub DeregisterInstancesFromLoadBalancer {
77 0     0 1 0 my $self = shift;
78 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DeregisterInstancesFromLoadBalancer', @_);
79 0         0 return $self->caller->do_call($self, $call_object);
80             }
81             sub DescribeAccountLimits {
82 0     0 1 0 my $self = shift;
83 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeAccountLimits', @_);
84 0         0 return $self->caller->do_call($self, $call_object);
85             }
86             sub DescribeInstanceHealth {
87 0     0 1 0 my $self = shift;
88 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeInstanceHealth', @_);
89 0         0 return $self->caller->do_call($self, $call_object);
90             }
91             sub DescribeLoadBalancerAttributes {
92 0     0 1 0 my $self = shift;
93 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerAttributes', @_);
94 0         0 return $self->caller->do_call($self, $call_object);
95             }
96             sub DescribeLoadBalancerPolicies {
97 1     1 1 206 my $self = shift;
98 1         5 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerPolicies', @_);
99 1         381 return $self->caller->do_call($self, $call_object);
100             }
101             sub DescribeLoadBalancerPolicyTypes {
102 1     1 1 180 my $self = shift;
103 1         7 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerPolicyTypes', @_);
104 1         281 return $self->caller->do_call($self, $call_object);
105             }
106             sub DescribeLoadBalancers {
107 1     1 1 239 my $self = shift;
108 1         6 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancers', @_);
109 1         486 return $self->caller->do_call($self, $call_object);
110             }
111             sub DescribeTags {
112 0     0 1 0 my $self = shift;
113 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeTags', @_);
114 0         0 return $self->caller->do_call($self, $call_object);
115             }
116             sub DetachLoadBalancerFromSubnets {
117 0     0 1 0 my $self = shift;
118 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DetachLoadBalancerFromSubnets', @_);
119 0         0 return $self->caller->do_call($self, $call_object);
120             }
121             sub DisableAvailabilityZonesForLoadBalancer {
122 0     0 1 0 my $self = shift;
123 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::DisableAvailabilityZonesForLoadBalancer', @_);
124 0         0 return $self->caller->do_call($self, $call_object);
125             }
126             sub EnableAvailabilityZonesForLoadBalancer {
127 0     0 1 0 my $self = shift;
128 0         0 my $call_object = $self->new_with_coercions('Paws::ELB::EnableAvailabilityZonesForLoadBalancer', @_);
129 0         0 return $self->caller->do_call($self, $call_object);
130             }
131             sub ModifyLoadBalancerAttributes {
132 1     1 1 8 my $self = shift;
133 1         5 my $call_object = $self->new_with_coercions('Paws::ELB::ModifyLoadBalancerAttributes', @_);
134 1         735 return $self->caller->do_call($self, $call_object);
135             }
136             sub RegisterInstancesWithLoadBalancer {
137 0     0 1   my $self = shift;
138 0           my $call_object = $self->new_with_coercions('Paws::ELB::RegisterInstancesWithLoadBalancer', @_);
139 0           return $self->caller->do_call($self, $call_object);
140             }
141             sub RemoveTags {
142 0     0 1   my $self = shift;
143 0           my $call_object = $self->new_with_coercions('Paws::ELB::RemoveTags', @_);
144 0           return $self->caller->do_call($self, $call_object);
145             }
146             sub SetLoadBalancerListenerSSLCertificate {
147 0     0 1   my $self = shift;
148 0           my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerListenerSSLCertificate', @_);
149 0           return $self->caller->do_call($self, $call_object);
150             }
151             sub SetLoadBalancerPoliciesForBackendServer {
152 0     0 1   my $self = shift;
153 0           my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerPoliciesForBackendServer', @_);
154 0           return $self->caller->do_call($self, $call_object);
155             }
156             sub SetLoadBalancerPoliciesOfListener {
157 0     0 1   my $self = shift;
158 0           my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerPoliciesOfListener', @_);
159 0           return $self->caller->do_call($self, $call_object);
160             }
161            
162             sub DescribeAllLoadBalancers {
163 0     0 1   my $self = shift;
164              
165 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
166 0           my $result = $self->DescribeLoadBalancers(@_);
167 0           my $next_result = $result;
168              
169 0 0         if (not defined $callback) {
170 0           while ($next_result->NextMarker) {
171 0           $next_result = $self->DescribeLoadBalancers(@_, Marker => $next_result->NextMarker);
172 0           push @{ $result->LoadBalancerDescriptions }, @{ $next_result->LoadBalancerDescriptions };
  0            
  0            
173             }
174 0           return $result;
175             } else {
176 0           while ($result->NextMarker) {
177 0           $callback->($_ => 'LoadBalancerDescriptions') foreach (@{ $result->LoadBalancerDescriptions });
  0            
178 0           $result = $self->DescribeLoadBalancers(@_, Marker => $result->NextMarker);
179             }
180 0           $callback->($_ => 'LoadBalancerDescriptions') foreach (@{ $result->LoadBalancerDescriptions });
  0            
181             }
182              
183             return undef
184 0           }
185              
186              
187 0     0 0   sub operations { qw/AddTags ApplySecurityGroupsToLoadBalancer AttachLoadBalancerToSubnets ConfigureHealthCheck CreateAppCookieStickinessPolicy CreateLBCookieStickinessPolicy CreateLoadBalancer CreateLoadBalancerListeners CreateLoadBalancerPolicy DeleteLoadBalancer DeleteLoadBalancerListeners DeleteLoadBalancerPolicy DeregisterInstancesFromLoadBalancer DescribeAccountLimits DescribeInstanceHealth DescribeLoadBalancerAttributes DescribeLoadBalancerPolicies DescribeLoadBalancerPolicyTypes DescribeLoadBalancers DescribeTags DetachLoadBalancerFromSubnets DisableAvailabilityZonesForLoadBalancer EnableAvailabilityZonesForLoadBalancer ModifyLoadBalancerAttributes RegisterInstancesWithLoadBalancer RemoveTags SetLoadBalancerListenerSSLCertificate SetLoadBalancerPoliciesForBackendServer SetLoadBalancerPoliciesOfListener / }
188              
189             1;
190              
191             ### main pod documentation begin ###
192              
193             =head1 NAME
194              
195             Paws::ELB - Perl Interface to AWS Elastic Load Balancing
196              
197             =head1 SYNOPSIS
198              
199             use Paws;
200              
201             my $obj = Paws->service('ELB');
202             my $res = $obj->Method(
203             Arg1 => $val1,
204             Arg2 => [ 'V1', 'V2' ],
205             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
206             # of the arguments type
207             Arg3 => { Att1 => 'Val1' },
208             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
209             # the constructor of the arguments type
210             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
211             );
212              
213             =head1 DESCRIPTION
214              
215             Elastic Load Balancing
216              
217             A load balancer distributes incoming traffic across your EC2 instances.
218             This enables you to increase the availability of your application. The
219             load balancer also monitors the health of its registered instances and
220             ensures that it routes traffic only to healthy instances. You configure
221             your load balancer to accept incoming traffic by specifying one or more
222             listeners, which are configured with a protocol and port number for
223             connections from clients to the load balancer and a protocol and port
224             number for connections from the load balancer to the instances.
225              
226             Elastic Load Balancing supports two types of load balancers: Classic
227             Load Balancers and Application Load Balancers (new). A Classic Load
228             Balancer makes routing and load balancing decisions either at the
229             transport layer (TCP/SSL) or the application layer (HTTP/HTTPS), and
230             supports either EC2-Classic or a VPC. An Application Load Balancer
231             makes routing and load balancing decisions at the application layer
232             (HTTP/HTTPS), supports path-based routing, and can route requests to
233             one or more ports on each EC2 instance or container instance in your
234             virtual private cloud (VPC). For more information, see the Elastic Load
235             Balancing User Guide.
236              
237             This reference covers the 2012-06-01 API, which supports Classic Load
238             Balancers. The 2015-12-01 API supports Application Load Balancers.
239              
240             To get started, create a load balancer with one or more listeners using
241             CreateLoadBalancer. Register your instances with the load balancer
242             using RegisterInstancesWithLoadBalancer.
243              
244             All Elastic Load Balancing operations are I<idempotent>, which means
245             that they complete at most one time. If you repeat an operation, it
246             succeeds with a 200 OK response code.
247              
248             =head1 METHODS
249              
250             =head2 AddTags(LoadBalancerNames => ArrayRef[Str|Undef], Tags => ArrayRef[L<Paws::ELB::Tag>])
251              
252             Each argument is described in detail in: L<Paws::ELB::AddTags>
253              
254             Returns: a L<Paws::ELB::AddTagsOutput> instance
255              
256             Adds the specified tags to the specified load balancer. Each load
257             balancer can have a maximum of 10 tags.
258              
259             Each tag consists of a key and an optional value. If a tag with the
260             same key is already associated with the load balancer, C<AddTags>
261             updates its value.
262              
263             For more information, see Tag Your Classic Load Balancer in the
264             I<Classic Load Balancer Guide>.
265              
266              
267             =head2 ApplySecurityGroupsToLoadBalancer(LoadBalancerName => Str, SecurityGroups => ArrayRef[Str|Undef])
268              
269             Each argument is described in detail in: L<Paws::ELB::ApplySecurityGroupsToLoadBalancer>
270              
271             Returns: a L<Paws::ELB::ApplySecurityGroupsToLoadBalancerOutput> instance
272              
273             Associates one or more security groups with your load balancer in a
274             virtual private cloud (VPC). The specified security groups override the
275             previously associated security groups.
276              
277             For more information, see Security Groups for Load Balancers in a VPC
278             in the I<Classic Load Balancer Guide>.
279              
280              
281             =head2 AttachLoadBalancerToSubnets(LoadBalancerName => Str, Subnets => ArrayRef[Str|Undef])
282              
283             Each argument is described in detail in: L<Paws::ELB::AttachLoadBalancerToSubnets>
284              
285             Returns: a L<Paws::ELB::AttachLoadBalancerToSubnetsOutput> instance
286              
287             Adds one or more subnets to the set of configured subnets for the
288             specified load balancer.
289              
290             The load balancer evenly distributes requests across all registered
291             subnets. For more information, see Add or Remove Subnets for Your Load
292             Balancer in a VPC in the I<Classic Load Balancer Guide>.
293              
294              
295             =head2 ConfigureHealthCheck(HealthCheck => L<Paws::ELB::HealthCheck>, LoadBalancerName => Str)
296              
297             Each argument is described in detail in: L<Paws::ELB::ConfigureHealthCheck>
298              
299             Returns: a L<Paws::ELB::ConfigureHealthCheckOutput> instance
300              
301             Specifies the health check settings to use when evaluating the health
302             state of your EC2 instances.
303              
304             For more information, see Configure Health Checks for Your Load
305             Balancer in the I<Classic Load Balancer Guide>.
306              
307              
308             =head2 CreateAppCookieStickinessPolicy(CookieName => Str, LoadBalancerName => Str, PolicyName => Str)
309              
310             Each argument is described in detail in: L<Paws::ELB::CreateAppCookieStickinessPolicy>
311              
312             Returns: a L<Paws::ELB::CreateAppCookieStickinessPolicyOutput> instance
313              
314             Generates a stickiness policy with sticky session lifetimes that follow
315             that of an application-generated cookie. This policy can be associated
316             only with HTTP/HTTPS listeners.
317              
318             This policy is similar to the policy created by
319             CreateLBCookieStickinessPolicy, except that the lifetime of the special
320             Elastic Load Balancing cookie, C<AWSELB>, follows the lifetime of the
321             application-generated cookie specified in the policy configuration. The
322             load balancer only inserts a new stickiness cookie when the application
323             response includes a new application cookie.
324              
325             If the application cookie is explicitly removed or expires, the session
326             stops being sticky until a new application cookie is issued.
327              
328             For more information, see Application-Controlled Session Stickiness in
329             the I<Classic Load Balancer Guide>.
330              
331              
332             =head2 CreateLBCookieStickinessPolicy(LoadBalancerName => Str, PolicyName => Str, [CookieExpirationPeriod => Int])
333              
334             Each argument is described in detail in: L<Paws::ELB::CreateLBCookieStickinessPolicy>
335              
336             Returns: a L<Paws::ELB::CreateLBCookieStickinessPolicyOutput> instance
337              
338             Generates a stickiness policy with sticky session lifetimes controlled
339             by the lifetime of the browser (user-agent) or a specified expiration
340             period. This policy can be associated only with HTTP/HTTPS listeners.
341              
342             When a load balancer implements this policy, the load balancer uses a
343             special cookie to track the instance for each request. When the load
344             balancer receives a request, it first checks to see if this cookie is
345             present in the request. If so, the load balancer sends the request to
346             the application server specified in the cookie. If not, the load
347             balancer sends the request to a server that is chosen based on the
348             existing load-balancing algorithm.
349              
350             A cookie is inserted into the response for binding subsequent requests
351             from the same user to that server. The validity of the cookie is based
352             on the cookie expiration time, which is specified in the policy
353             configuration.
354              
355             For more information, see Duration-Based Session Stickiness in the
356             I<Classic Load Balancer Guide>.
357              
358              
359             =head2 CreateLoadBalancer(Listeners => ArrayRef[L<Paws::ELB::Listener>], LoadBalancerName => Str, [AvailabilityZones => ArrayRef[Str|Undef], Scheme => Str, SecurityGroups => ArrayRef[Str|Undef], Subnets => ArrayRef[Str|Undef], Tags => ArrayRef[L<Paws::ELB::Tag>]])
360              
361             Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancer>
362              
363             Returns: a L<Paws::ELB::CreateAccessPointOutput> instance
364              
365             Creates a Classic Load Balancer.
366              
367             You can add listeners, security groups, subnets, and tags when you
368             create your load balancer, or you can add them later using
369             CreateLoadBalancerListeners, ApplySecurityGroupsToLoadBalancer,
370             AttachLoadBalancerToSubnets, and AddTags.
371              
372             To describe your current load balancers, see DescribeLoadBalancers.
373             When you are finished with a load balancer, you can delete it using
374             DeleteLoadBalancer.
375              
376             You can create up to 20 load balancers per region per account. You can
377             request an increase for the number of load balancers for your account.
378             For more information, see Limits for Your Classic Load Balancer in the
379             I<Classic Load Balancer Guide>.
380              
381              
382             =head2 CreateLoadBalancerListeners(Listeners => ArrayRef[L<Paws::ELB::Listener>], LoadBalancerName => Str)
383              
384             Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancerListeners>
385              
386             Returns: a L<Paws::ELB::CreateLoadBalancerListenerOutput> instance
387              
388             Creates one or more listeners for the specified load balancer. If a
389             listener with the specified port does not already exist, it is created;
390             otherwise, the properties of the new listener must match the properties
391             of the existing listener.
392              
393             For more information, see Listeners for Your Classic Load Balancer in
394             the I<Classic Load Balancer Guide>.
395              
396              
397             =head2 CreateLoadBalancerPolicy(LoadBalancerName => Str, PolicyName => Str, PolicyTypeName => Str, [PolicyAttributes => ArrayRef[L<Paws::ELB::PolicyAttribute>]])
398              
399             Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancerPolicy>
400              
401             Returns: a L<Paws::ELB::CreateLoadBalancerPolicyOutput> instance
402              
403             Creates a policy with the specified attributes for the specified load
404             balancer.
405              
406             Policies are settings that are saved for your load balancer and that
407             can be applied to the listener or the application server, depending on
408             the policy type.
409              
410              
411             =head2 DeleteLoadBalancer(LoadBalancerName => Str)
412              
413             Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancer>
414              
415             Returns: a L<Paws::ELB::DeleteAccessPointOutput> instance
416              
417             Deletes the specified load balancer.
418              
419             If you are attempting to recreate a load balancer, you must reconfigure
420             all settings. The DNS name associated with a deleted load balancer are
421             no longer usable. The name and associated DNS record of the deleted
422             load balancer no longer exist and traffic sent to any of its IP
423             addresses is no longer delivered to your instances.
424              
425             If the load balancer does not exist or has already been deleted, the
426             call to C<DeleteLoadBalancer> still succeeds.
427              
428              
429             =head2 DeleteLoadBalancerListeners(LoadBalancerName => Str, LoadBalancerPorts => ArrayRef[Int])
430              
431             Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancerListeners>
432              
433             Returns: a L<Paws::ELB::DeleteLoadBalancerListenerOutput> instance
434              
435             Deletes the specified listeners from the specified load balancer.
436              
437              
438             =head2 DeleteLoadBalancerPolicy(LoadBalancerName => Str, PolicyName => Str)
439              
440             Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancerPolicy>
441              
442             Returns: a L<Paws::ELB::DeleteLoadBalancerPolicyOutput> instance
443              
444             Deletes the specified policy from the specified load balancer. This
445             policy must not be enabled for any listeners.
446              
447              
448             =head2 DeregisterInstancesFromLoadBalancer(Instances => ArrayRef[L<Paws::ELB::Instance>], LoadBalancerName => Str)
449              
450             Each argument is described in detail in: L<Paws::ELB::DeregisterInstancesFromLoadBalancer>
451              
452             Returns: a L<Paws::ELB::DeregisterEndPointsOutput> instance
453              
454             Deregisters the specified instances from the specified load balancer.
455             After the instance is deregistered, it no longer receives traffic from
456             the load balancer.
457              
458             You can use DescribeLoadBalancers to verify that the instance is
459             deregistered from the load balancer.
460              
461             For more information, see Register or De-Register EC2 Instances in the
462             I<Classic Load Balancer Guide>.
463              
464              
465             =head2 DescribeAccountLimits([Marker => Str, PageSize => Int])
466              
467             Each argument is described in detail in: L<Paws::ELB::DescribeAccountLimits>
468              
469             Returns: a L<Paws::ELB::DescribeAccountLimitsOutput> instance
470              
471             Describes the current Elastic Load Balancing resource limits for your
472             AWS account.
473              
474             For more information, see Limits for Your Classic Load Balancer in the
475             I<Classic Load Balancer Guide>.
476              
477              
478             =head2 DescribeInstanceHealth(LoadBalancerName => Str, [Instances => ArrayRef[L<Paws::ELB::Instance>]])
479              
480             Each argument is described in detail in: L<Paws::ELB::DescribeInstanceHealth>
481              
482             Returns: a L<Paws::ELB::DescribeEndPointStateOutput> instance
483              
484             Describes the state of the specified instances with respect to the
485             specified load balancer. If no instances are specified, the call
486             describes the state of all instances that are currently registered with
487             the load balancer. If instances are specified, their state is returned
488             even if they are no longer registered with the load balancer. The state
489             of terminated instances is not returned.
490              
491              
492             =head2 DescribeLoadBalancerAttributes(LoadBalancerName => Str)
493              
494             Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerAttributes>
495              
496             Returns: a L<Paws::ELB::DescribeLoadBalancerAttributesOutput> instance
497              
498             Describes the attributes for the specified load balancer.
499              
500              
501             =head2 DescribeLoadBalancerPolicies([LoadBalancerName => Str, PolicyNames => ArrayRef[Str|Undef]])
502              
503             Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerPolicies>
504              
505             Returns: a L<Paws::ELB::DescribeLoadBalancerPoliciesOutput> instance
506              
507             Describes the specified policies.
508              
509             If you specify a load balancer name, the action returns the
510             descriptions of all policies created for the load balancer. If you
511             specify a policy name associated with your load balancer, the action
512             returns the description of that policy. If you don't specify a load
513             balancer name, the action returns descriptions of the specified sample
514             policies, or descriptions of all sample policies. The names of the
515             sample policies have the C<ELBSample-> prefix.
516              
517              
518             =head2 DescribeLoadBalancerPolicyTypes([PolicyTypeNames => ArrayRef[Str|Undef]])
519              
520             Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerPolicyTypes>
521              
522             Returns: a L<Paws::ELB::DescribeLoadBalancerPolicyTypesOutput> instance
523              
524             Describes the specified load balancer policy types or all load balancer
525             policy types.
526              
527             The description of each type indicates how it can be used. For example,
528             some policies can be used only with layer 7 listeners, some policies
529             can be used only with layer 4 listeners, and some policies can be used
530             only with your EC2 instances.
531              
532             You can use CreateLoadBalancerPolicy to create a policy configuration
533             for any of these policy types. Then, depending on the policy type, use
534             either SetLoadBalancerPoliciesOfListener or
535             SetLoadBalancerPoliciesForBackendServer to set the policy.
536              
537              
538             =head2 DescribeLoadBalancers([LoadBalancerNames => ArrayRef[Str|Undef], Marker => Str, PageSize => Int])
539              
540             Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancers>
541              
542             Returns: a L<Paws::ELB::DescribeAccessPointsOutput> instance
543              
544             Describes the specified the load balancers. If no load balancers are
545             specified, the call describes all of your load balancers.
546              
547              
548             =head2 DescribeTags(LoadBalancerNames => ArrayRef[Str|Undef])
549              
550             Each argument is described in detail in: L<Paws::ELB::DescribeTags>
551              
552             Returns: a L<Paws::ELB::DescribeTagsOutput> instance
553              
554             Describes the tags associated with the specified load balancers.
555              
556              
557             =head2 DetachLoadBalancerFromSubnets(LoadBalancerName => Str, Subnets => ArrayRef[Str|Undef])
558              
559             Each argument is described in detail in: L<Paws::ELB::DetachLoadBalancerFromSubnets>
560              
561             Returns: a L<Paws::ELB::DetachLoadBalancerFromSubnetsOutput> instance
562              
563             Removes the specified subnets from the set of configured subnets for
564             the load balancer.
565              
566             After a subnet is removed, all EC2 instances registered with the load
567             balancer in the removed subnet go into the C<OutOfService> state. Then,
568             the load balancer balances the traffic among the remaining routable
569             subnets.
570              
571              
572             =head2 DisableAvailabilityZonesForLoadBalancer(AvailabilityZones => ArrayRef[Str|Undef], LoadBalancerName => Str)
573              
574             Each argument is described in detail in: L<Paws::ELB::DisableAvailabilityZonesForLoadBalancer>
575              
576             Returns: a L<Paws::ELB::RemoveAvailabilityZonesOutput> instance
577              
578             Removes the specified Availability Zones from the set of Availability
579             Zones for the specified load balancer.
580              
581             There must be at least one Availability Zone registered with a load
582             balancer at all times. After an Availability Zone is removed, all
583             instances registered with the load balancer that are in the removed
584             Availability Zone go into the C<OutOfService> state. Then, the load
585             balancer attempts to equally balance the traffic among its remaining
586             Availability Zones.
587              
588             For more information, see Add or Remove Availability Zones in the
589             I<Classic Load Balancer Guide>.
590              
591              
592             =head2 EnableAvailabilityZonesForLoadBalancer(AvailabilityZones => ArrayRef[Str|Undef], LoadBalancerName => Str)
593              
594             Each argument is described in detail in: L<Paws::ELB::EnableAvailabilityZonesForLoadBalancer>
595              
596             Returns: a L<Paws::ELB::AddAvailabilityZonesOutput> instance
597              
598             Adds the specified Availability Zones to the set of Availability Zones
599             for the specified load balancer.
600              
601             The load balancer evenly distributes requests across all its registered
602             Availability Zones that contain instances.
603              
604             For more information, see Add or Remove Availability Zones in the
605             I<Classic Load Balancer Guide>.
606              
607              
608             =head2 ModifyLoadBalancerAttributes(LoadBalancerAttributes => L<Paws::ELB::LoadBalancerAttributes>, LoadBalancerName => Str)
609              
610             Each argument is described in detail in: L<Paws::ELB::ModifyLoadBalancerAttributes>
611              
612             Returns: a L<Paws::ELB::ModifyLoadBalancerAttributesOutput> instance
613              
614             Modifies the attributes of the specified load balancer.
615              
616             You can modify the load balancer attributes, such as C<AccessLogs>,
617             C<ConnectionDraining>, and C<CrossZoneLoadBalancing> by either enabling
618             or disabling them. Or, you can modify the load balancer attribute
619             C<ConnectionSettings> by specifying an idle connection timeout value
620             for your load balancer.
621              
622             For more information, see the following in the I<Classic Load Balancer
623             Guide>:
624              
625             =over
626              
627             =item *
628              
629             Cross-Zone Load Balancing
630              
631             =item *
632              
633             Connection Draining
634              
635             =item *
636              
637             Access Logs
638              
639             =item *
640              
641             Idle Connection Timeout
642              
643             =back
644              
645              
646              
647             =head2 RegisterInstancesWithLoadBalancer(Instances => ArrayRef[L<Paws::ELB::Instance>], LoadBalancerName => Str)
648              
649             Each argument is described in detail in: L<Paws::ELB::RegisterInstancesWithLoadBalancer>
650              
651             Returns: a L<Paws::ELB::RegisterEndPointsOutput> instance
652              
653             Adds the specified instances to the specified load balancer.
654              
655             The instance must be a running instance in the same network as the load
656             balancer (EC2-Classic or the same VPC). If you have EC2-Classic
657             instances and a load balancer in a VPC with ClassicLink enabled, you
658             can link the EC2-Classic instances to that VPC and then register the
659             linked EC2-Classic instances with the load balancer in the VPC.
660              
661             Note that C<RegisterInstanceWithLoadBalancer> completes when the
662             request has been registered. Instance registration takes a little time
663             to complete. To check the state of the registered instances, use
664             DescribeLoadBalancers or DescribeInstanceHealth.
665              
666             After the instance is registered, it starts receiving traffic and
667             requests from the load balancer. Any instance that is not in one of the
668             Availability Zones registered for the load balancer is moved to the
669             C<OutOfService> state. If an Availability Zone is added to the load
670             balancer later, any instances registered with the load balancer move to
671             the C<InService> state.
672              
673             To deregister instances from a load balancer, use
674             DeregisterInstancesFromLoadBalancer.
675              
676             For more information, see Register or De-Register EC2 Instances in the
677             I<Classic Load Balancer Guide>.
678              
679              
680             =head2 RemoveTags(LoadBalancerNames => ArrayRef[Str|Undef], Tags => ArrayRef[L<Paws::ELB::TagKeyOnly>])
681              
682             Each argument is described in detail in: L<Paws::ELB::RemoveTags>
683              
684             Returns: a L<Paws::ELB::RemoveTagsOutput> instance
685              
686             Removes one or more tags from the specified load balancer.
687              
688              
689             =head2 SetLoadBalancerListenerSSLCertificate(LoadBalancerName => Str, LoadBalancerPort => Int, SSLCertificateId => Str)
690              
691             Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerListenerSSLCertificate>
692              
693             Returns: a L<Paws::ELB::SetLoadBalancerListenerSSLCertificateOutput> instance
694              
695             Sets the certificate that terminates the specified listener's SSL
696             connections. The specified certificate replaces any prior certificate
697             that was used on the same load balancer and port.
698              
699             For more information about updating your SSL certificate, see Replace
700             the SSL Certificate for Your Load Balancer in the I<Classic Load
701             Balancer Guide>.
702              
703              
704             =head2 SetLoadBalancerPoliciesForBackendServer(InstancePort => Int, LoadBalancerName => Str, PolicyNames => ArrayRef[Str|Undef])
705              
706             Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerPoliciesForBackendServer>
707              
708             Returns: a L<Paws::ELB::SetLoadBalancerPoliciesForBackendServerOutput> instance
709              
710             Replaces the set of policies associated with the specified port on
711             which the EC2 instance is listening with a new set of policies. At this
712             time, only the back-end server authentication policy type can be
713             applied to the instance ports; this policy type is composed of multiple
714             public key policies.
715              
716             Each time you use C<SetLoadBalancerPoliciesForBackendServer> to enable
717             the policies, use the C<PolicyNames> parameter to list the policies
718             that you want to enable.
719              
720             You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to
721             verify that the policy is associated with the EC2 instance.
722              
723             For more information about enabling back-end instance authentication,
724             see Configure Back-end Instance Authentication in the I<Classic Load
725             Balancer Guide>. For more information about Proxy Protocol, see
726             Configure Proxy Protocol Support in the I<Classic Load Balancer Guide>.
727              
728              
729             =head2 SetLoadBalancerPoliciesOfListener(LoadBalancerName => Str, LoadBalancerPort => Int, PolicyNames => ArrayRef[Str|Undef])
730              
731             Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerPoliciesOfListener>
732              
733             Returns: a L<Paws::ELB::SetLoadBalancerPoliciesOfListenerOutput> instance
734              
735             Replaces the current set of policies for the specified load balancer
736             port with the specified set of policies.
737              
738             To enable back-end server authentication, use
739             SetLoadBalancerPoliciesForBackendServer.
740              
741             For more information about setting policies, see Update the SSL
742             Negotiation Configuration, Duration-Based Session Stickiness, and
743             Application-Controlled Session Stickiness in the I<Classic Load
744             Balancer Guide>.
745              
746              
747              
748              
749             =head1 PAGINATORS
750              
751             Paginator methods are helpers that repetively call methods that return partial results
752              
753             =head2 DescribeAllLoadBalancers(sub { },[LoadBalancerNames => ArrayRef[Str|Undef], Marker => Str, PageSize => Int])
754              
755             =head2 DescribeAllLoadBalancers([LoadBalancerNames => ArrayRef[Str|Undef], Marker => Str, PageSize => Int])
756              
757              
758             If passed a sub as first parameter, it will call the sub for each element found in :
759              
760             - LoadBalancerDescriptions, passing the object as the first parameter, and the string 'LoadBalancerDescriptions' as the second parameter
761              
762             If not, it will return a a L<Paws::ELB::DescribeAccessPointsOutput> 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.
763              
764              
765              
766              
767              
768             =head1 SEE ALSO
769              
770             This service class forms part of L<Paws>
771              
772             =head1 BUGS and CONTRIBUTIONS
773              
774             The source code is located here: https://github.com/pplu/aws-sdk-perl
775              
776             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
777              
778             =cut
779