blib/lib/Paws/ELB.pm

filter: Statementstmt 18.1% 25 / 138 Branchbran 0.0% 0 / 16 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 25.6% 10 / 39 Podpod 86.1% 31 / 36 totaltotal 28.8% 66 / 229 CC 13 SCAR 28.1
CC
13
Cov
16%
DescribeAllAccountLimits
56.0
DescribeAllLoadBalancers
56.0
flattened_arrays
2.0
CRAP 16.6
« blib/lib/Paws/SQS.pm ↑ Summary blib/lib/Paws/Net/RestJsonCaller.pm »
1 package Paws::ELB;
2 3 ▶ use Moose;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 14 ▶ sub service { 'elasticloadbalancing' }
Subroutine service: called CC=1 SCAR=0.0
Pod undocumented
4 1 ▶ sub signing_name { 'elasticloadbalancing' }
Subroutine signing_name: called CC=1 SCAR=0.0
Pod undocumented
5 1 ▶ sub version { '2012-06-01' }
Subroutine version: called CC=1 SCAR=0.0
Pod undocumented
6 0 ▶ sub flattened_arrays { 0 }
Subroutine flattened_arrays: not called CC=1 SCAR=6.9
Pod undocumented
7 3 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 14 ▶ has retry => (is => 'ro', isa => 'HashRef', default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
9 14 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 3 });
11 14 ▶ has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
Subroutine __ANON__: called CC=1 SCAR=0.0
12 14 ] });
13  
14 3 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller';
15  
16
17 0 ▶ sub AddTags {
Subroutine AddTags: not called CC=1 SCAR=6.9
Pod documented
18 0 my $self = shift;
19 0 my $call_object = $self->new_with_coercions('Paws::ELB::AddTags', @_);
20 0 return $self->caller->do_call($self, $call_object);
21 }
22 0 ▶ sub ApplySecurityGroupsToLoadBalancer {
Subroutine ApplySecurityGroupsToLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
23 0 my $self = shift;
24 0 my $call_object = $self->new_with_coercions('Paws::ELB::ApplySecurityGroupsToLoadBalancer', @_);
25 0 return $self->caller->do_call($self, $call_object);
26 }
27 0 ▶ sub AttachLoadBalancerToSubnets {
Subroutine AttachLoadBalancerToSubnets: not called CC=1 SCAR=6.9
Pod documented
28 0 my $self = shift;
29 0 my $call_object = $self->new_with_coercions('Paws::ELB::AttachLoadBalancerToSubnets', @_);
30 0 return $self->caller->do_call($self, $call_object);
31 }
32 0 ▶ sub ConfigureHealthCheck {
Subroutine ConfigureHealthCheck: not called CC=1 SCAR=6.9
Pod documented
33 0 my $self = shift;
34 0 my $call_object = $self->new_with_coercions('Paws::ELB::ConfigureHealthCheck', @_);
35 0 return $self->caller->do_call($self, $call_object);
36 }
37 0 ▶ sub CreateAppCookieStickinessPolicy {
Subroutine CreateAppCookieStickinessPolicy: not called CC=1 SCAR=6.9
Pod documented
38 0 my $self = shift;
39 0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateAppCookieStickinessPolicy', @_);
40 0 return $self->caller->do_call($self, $call_object);
41 }
42 0 ▶ sub CreateLBCookieStickinessPolicy {
Subroutine CreateLBCookieStickinessPolicy: not called CC=1 SCAR=6.9
Pod documented
43 0 my $self = shift;
44 0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLBCookieStickinessPolicy', @_);
45 0 return $self->caller->do_call($self, $call_object);
46 }
47 0 ▶ sub CreateLoadBalancer {
Subroutine CreateLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
48 0 my $self = shift;
49 0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancer', @_);
50 0 return $self->caller->do_call($self, $call_object);
51 }
52 0 ▶ sub CreateLoadBalancerListeners {
Subroutine CreateLoadBalancerListeners: not called CC=1 SCAR=6.9
Pod documented
53 0 my $self = shift;
54 0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancerListeners', @_);
55 0 return $self->caller->do_call($self, $call_object);
56 }
57 0 ▶ sub CreateLoadBalancerPolicy {
Subroutine CreateLoadBalancerPolicy: not called CC=1 SCAR=6.9
Pod documented
58 0 my $self = shift;
59 0 my $call_object = $self->new_with_coercions('Paws::ELB::CreateLoadBalancerPolicy', @_);
60 0 return $self->caller->do_call($self, $call_object);
61 }
62 0 ▶ sub DeleteLoadBalancer {
Subroutine DeleteLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
63 0 my $self = shift;
64 0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancer', @_);
65 0 return $self->caller->do_call($self, $call_object);
66 }
67 0 ▶ sub DeleteLoadBalancerListeners {
Subroutine DeleteLoadBalancerListeners: not called CC=1 SCAR=6.9
Pod documented
68 0 my $self = shift;
69 0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancerListeners', @_);
70 0 return $self->caller->do_call($self, $call_object);
71 }
72 0 ▶ sub DeleteLoadBalancerPolicy {
Subroutine DeleteLoadBalancerPolicy: not called CC=1 SCAR=6.9
Pod documented
73 0 my $self = shift;
74 0 my $call_object = $self->new_with_coercions('Paws::ELB::DeleteLoadBalancerPolicy', @_);
75 0 return $self->caller->do_call($self, $call_object);
76 }
77 0 ▶ sub DeregisterInstancesFromLoadBalancer {
Subroutine DeregisterInstancesFromLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
78 0 my $self = shift;
79 0 my $call_object = $self->new_with_coercions('Paws::ELB::DeregisterInstancesFromLoadBalancer', @_);
80 0 return $self->caller->do_call($self, $call_object);
81 }
82 0 ▶ sub DescribeAccountLimits {
Subroutine DescribeAccountLimits: not called CC=1 SCAR=6.9
Pod documented
83 0 my $self = shift;
84 0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeAccountLimits', @_);
85 0 return $self->caller->do_call($self, $call_object);
86 }
87 0 ▶ sub DescribeInstanceHealth {
Subroutine DescribeInstanceHealth: not called CC=1 SCAR=6.9
Pod documented
88 0 my $self = shift;
89 0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeInstanceHealth', @_);
90 0 return $self->caller->do_call($self, $call_object);
91 }
92 0 ▶ sub DescribeLoadBalancerAttributes {
Subroutine DescribeLoadBalancerAttributes: not called CC=1 SCAR=6.9
Pod documented
93 0 my $self = shift;
94 0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerAttributes', @_);
95 0 return $self->caller->do_call($self, $call_object);
96 }
97 1 ▶ sub DescribeLoadBalancerPolicies {
Subroutine DescribeLoadBalancerPolicies: called CC=1 SCAR=0.0
Pod documented
98 1 my $self = shift;
99 1 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerPolicies', @_);
100 1 return $self->caller->do_call($self, $call_object);
101 }
102 1 ▶ sub DescribeLoadBalancerPolicyTypes {
Subroutine DescribeLoadBalancerPolicyTypes: called CC=1 SCAR=0.0
Pod documented
103 1 my $self = shift;
104 1 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancerPolicyTypes', @_);
105 1 return $self->caller->do_call($self, $call_object);
106 }
107 1 ▶ sub DescribeLoadBalancers {
Subroutine DescribeLoadBalancers: called CC=1 SCAR=0.0
Pod documented
108 1 my $self = shift;
109 1 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeLoadBalancers', @_);
110 1 return $self->caller->do_call($self, $call_object);
111 }
112 0 ▶ sub DescribeTags {
Subroutine DescribeTags: not called CC=1 SCAR=6.9
Pod documented
113 0 my $self = shift;
114 0 my $call_object = $self->new_with_coercions('Paws::ELB::DescribeTags', @_);
115 0 return $self->caller->do_call($self, $call_object);
116 }
117 0 ▶ sub DetachLoadBalancerFromSubnets {
Subroutine DetachLoadBalancerFromSubnets: not called CC=1 SCAR=6.9
Pod documented
118 0 my $self = shift;
119 0 my $call_object = $self->new_with_coercions('Paws::ELB::DetachLoadBalancerFromSubnets', @_);
120 0 return $self->caller->do_call($self, $call_object);
121 }
122 0 ▶ sub DisableAvailabilityZonesForLoadBalancer {
Subroutine DisableAvailabilityZonesForLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
123 0 my $self = shift;
124 0 my $call_object = $self->new_with_coercions('Paws::ELB::DisableAvailabilityZonesForLoadBalancer', @_);
125 0 return $self->caller->do_call($self, $call_object);
126 }
127 0 ▶ sub EnableAvailabilityZonesForLoadBalancer {
Subroutine EnableAvailabilityZonesForLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
128 0 my $self = shift;
129 0 my $call_object = $self->new_with_coercions('Paws::ELB::EnableAvailabilityZonesForLoadBalancer', @_);
130 0 return $self->caller->do_call($self, $call_object);
131 }
132 1 ▶ sub ModifyLoadBalancerAttributes {
Subroutine ModifyLoadBalancerAttributes: called CC=1 SCAR=0.0
Pod documented
133 1 my $self = shift;
134 1 my $call_object = $self->new_with_coercions('Paws::ELB::ModifyLoadBalancerAttributes', @_);
135 1 return $self->caller->do_call($self, $call_object);
136 }
137 0 ▶ sub RegisterInstancesWithLoadBalancer {
Subroutine RegisterInstancesWithLoadBalancer: not called CC=1 SCAR=6.9
Pod documented
138 0 my $self = shift;
139 0 my $call_object = $self->new_with_coercions('Paws::ELB::RegisterInstancesWithLoadBalancer', @_);
140 0 return $self->caller->do_call($self, $call_object);
141 }
142 0 ▶ sub RemoveTags {
Subroutine RemoveTags: not called CC=1 SCAR=6.9
Pod documented
143 0 my $self = shift;
144 0 my $call_object = $self->new_with_coercions('Paws::ELB::RemoveTags', @_);
145 0 return $self->caller->do_call($self, $call_object);
146 }
147 0 ▶ sub SetLoadBalancerListenerSSLCertificate {
Subroutine SetLoadBalancerListenerSSLCertificate: not called CC=1 SCAR=6.9
Pod documented
148 0 my $self = shift;
149 0 my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerListenerSSLCertificate', @_);
150 0 return $self->caller->do_call($self, $call_object);
151 }
152 0 ▶ sub SetLoadBalancerPoliciesForBackendServer {
Subroutine SetLoadBalancerPoliciesForBackendServer: not called CC=1 SCAR=6.9
Pod documented
153 0 my $self = shift;
154 0 my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerPoliciesForBackendServer', @_);
155 0 return $self->caller->do_call($self, $call_object);
156 }
157 0 ▶ sub SetLoadBalancerPoliciesOfListener {
Subroutine SetLoadBalancerPoliciesOfListener: not called CC=1 SCAR=6.9
Pod documented
158 0 my $self = shift;
159 0 my $call_object = $self->new_with_coercions('Paws::ELB::SetLoadBalancerPoliciesOfListener', @_);
160 0 return $self->caller->do_call($self, $call_object);
161 }
162
163 0 ▶ sub DescribeAllAccountLimits {
Subroutine DescribeAllAccountLimits: not called CC=7 SCAR=40.3
Pod documented
164 0 my $self = shift;
165  
166 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
167 0 my $result = $self->DescribeAccountLimits(@_);
168 0 my $next_result = $result;
169  
170 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
171 0 ▶ while ($next_result->NextMarker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextMarker) 0 0 0
172 0 $next_result = $self->DescribeAccountLimits(@_, Marker => $next_result->NextMarker);
173 0 push @{ $result->Limits }, @{ $next_result->Limits };
174 }
175 0 return $result;
176 } else {
177 0 ▶ while ($result->NextMarker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextMarker) 0 0 0
178 0 $callback->($_ => 'Limits') foreach (@{ $result->Limits });
179 0 $result = $self->DescribeAccountLimits(@_, Marker => $result->NextMarker);
180 }
181 0 $callback->($_ => 'Limits') foreach (@{ $result->Limits });
182 }
183  
184 return undef
185 0 }
186 0 ▶ sub DescribeAllLoadBalancers {
Subroutine DescribeAllLoadBalancers: not called CC=7 SCAR=40.3
Pod documented
187 0 my $self = shift;
188  
189 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
190 0 my $result = $self->DescribeLoadBalancers(@_);
191 0 my $next_result = $result;
192  
193 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
194 0 ▶ while ($next_result->NextMarker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextMarker) 0 0 0
195 0 $next_result = $self->DescribeLoadBalancers(@_, Marker => $next_result->NextMarker);
196 0 push @{ $result->LoadBalancerDescriptions }, @{ $next_result->LoadBalancerDescriptions };
197 }
198 0 return $result;
199 } else {
200 0 ▶ while ($result->NextMarker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextMarker) 0 0 0
201 0 $callback->($_ => 'LoadBalancerDescriptions') foreach (@{ $result->LoadBalancerDescriptions });
202 0 $result = $self->DescribeLoadBalancers(@_, Marker => $result->NextMarker);
203 }
204 0 $callback->($_ => 'LoadBalancerDescriptions') foreach (@{ $result->LoadBalancerDescriptions });
205 }
206  
207 return undef
208 0 }
209  
210  
211 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 / }
Subroutine operations: not called CC=1 SCAR=6.9
Pod undocumented
212  
213 3 1;
214  
215 ### main pod documentation begin ###
216  
217 =head1 NAME
218  
219 Paws::ELB - Perl Interface to AWS Elastic Load Balancing
220  
221 =head1 SYNOPSIS
222  
223 use Paws;
224  
225 my $obj = Paws->service('ELB');
226 my $res = $obj->Method(
227 Arg1 => $val1,
228 Arg2 => [ 'V1', 'V2' ],
229 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
230 # of the arguments type
231 Arg3 => { Att1 => 'Val1' },
232 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
233 # the constructor of the arguments type
234 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
235 );
236  
237 =head1 DESCRIPTION
238  
239 Elastic Load Balancing
240  
241 A load balancer can distribute incoming traffic across your EC2
242 instances. This enables you to increase the availability of your
243 application. The load balancer also monitors the health of its
244 registered instances and ensures that it routes traffic only to healthy
245 instances. You configure your load balancer to accept incoming traffic
246 by specifying one or more listeners, which are configured with a
247 protocol and port number for connections from clients to the load
248 balancer and a protocol and port number for connections from the load
249 balancer to the instances.
250  
251 Elastic Load Balancing supports three types of load balancers:
252 Application Load Balancers, Network Load Balancers, and Classic Load
253 Balancers. You can select a load balancer based on your application
254 needs. For more information, see the Elastic Load Balancing User Guide
255 (https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
256  
257 This reference covers the 2012-06-01 API, which supports Classic Load
258 Balancers. The 2015-12-01 API supports Application Load Balancers and
259 Network Load Balancers.
260  
261 To get started, create a load balancer with one or more listeners using
262 CreateLoadBalancer. Register your instances with the load balancer
263 using RegisterInstancesWithLoadBalancer.
264  
265 All Elastic Load Balancing operations are I<idempotent>, which means
266 that they complete at most one time. If you repeat an operation, it
267 succeeds with a 200 OK response code.
268  
269 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01>
270  
271  
272 =head1 METHODS
273  
274 =head2 AddTags
275  
276 =over
277  
278 =item LoadBalancerNames => ArrayRef[Str|Undef]
279  
280 =item Tags => ArrayRef[L<Paws::ELB::Tag>]
281  
282  
283 =back
284  
285 Each argument is described in detail in: L<Paws::ELB::AddTags>
286  
287 Returns: a L<Paws::ELB::AddTagsOutput> instance
288  
289 Adds the specified tags to the specified load balancer. Each load
290 balancer can have a maximum of 10 tags.
291  
292 Each tag consists of a key and an optional value. If a tag with the
293 same key is already associated with the load balancer, C<AddTags>
294 updates its value.
295  
296 For more information, see Tag Your Classic Load Balancer
297 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/add-remove-tags.html)
298 in the I<Classic Load Balancers Guide>.
299  
300  
301 =head2 ApplySecurityGroupsToLoadBalancer
302  
303 =over
304  
305 =item LoadBalancerName => Str
306  
307 =item SecurityGroups => ArrayRef[Str|Undef]
308  
309  
310 =back
311  
312 Each argument is described in detail in: L<Paws::ELB::ApplySecurityGroupsToLoadBalancer>
313  
314 Returns: a L<Paws::ELB::ApplySecurityGroupsToLoadBalancerOutput> instance
315  
316 Associates one or more security groups with your load balancer in a
317 virtual private cloud (VPC). The specified security groups override the
318 previously associated security groups.
319  
320 For more information, see Security Groups for Load Balancers in a VPC
321 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-groups.html#elb-vpc-security-groups)
322 in the I<Classic Load Balancers Guide>.
323  
324  
325 =head2 AttachLoadBalancerToSubnets
326  
327 =over
328  
329 =item LoadBalancerName => Str
330  
331 =item Subnets => ArrayRef[Str|Undef]
332  
333  
334 =back
335  
336 Each argument is described in detail in: L<Paws::ELB::AttachLoadBalancerToSubnets>
337  
338 Returns: a L<Paws::ELB::AttachLoadBalancerToSubnetsOutput> instance
339  
340 Adds one or more subnets to the set of configured subnets for the
341 specified load balancer.
342  
343 The load balancer evenly distributes requests across all registered
344 subnets. For more information, see Add or Remove Subnets for Your Load
345 Balancer in a VPC
346 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-manage-subnets.html)
347 in the I<Classic Load Balancers Guide>.
348  
349  
350 =head2 ConfigureHealthCheck
351  
352 =over
353  
354 =item HealthCheck => L<Paws::ELB::HealthCheck>
355  
356 =item LoadBalancerName => Str
357  
358  
359 =back
360  
361 Each argument is described in detail in: L<Paws::ELB::ConfigureHealthCheck>
362  
363 Returns: a L<Paws::ELB::ConfigureHealthCheckOutput> instance
364  
365 Specifies the health check settings to use when evaluating the health
366 state of your EC2 instances.
367  
368 For more information, see Configure Health Checks for Your Load
369 Balancer
370 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-healthchecks.html)
371 in the I<Classic Load Balancers Guide>.
372  
373  
374 =head2 CreateAppCookieStickinessPolicy
375  
376 =over
377  
378 =item CookieName => Str
379  
380 =item LoadBalancerName => Str
381  
382 =item PolicyName => Str
383  
384  
385 =back
386  
387 Each argument is described in detail in: L<Paws::ELB::CreateAppCookieStickinessPolicy>
388  
389 Returns: a L<Paws::ELB::CreateAppCookieStickinessPolicyOutput> instance
390  
391 Generates a stickiness policy with sticky session lifetimes that follow
392 that of an application-generated cookie. This policy can be associated
393 only with HTTP/HTTPS listeners.
394  
395 This policy is similar to the policy created by
396 CreateLBCookieStickinessPolicy, except that the lifetime of the special
397 Elastic Load Balancing cookie, C<AWSELB>, follows the lifetime of the
398 application-generated cookie specified in the policy configuration. The
399 load balancer only inserts a new stickiness cookie when the application
400 response includes a new application cookie.
401  
402 If the application cookie is explicitly removed or expires, the session
403 stops being sticky until a new application cookie is issued.
404  
405 For more information, see Application-Controlled Session Stickiness
406 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-application)
407 in the I<Classic Load Balancers Guide>.
408  
409  
410 =head2 CreateLBCookieStickinessPolicy
411  
412 =over
413  
414 =item LoadBalancerName => Str
415  
416 =item PolicyName => Str
417  
418 =item [CookieExpirationPeriod => Int]
419  
420  
421 =back
422  
423 Each argument is described in detail in: L<Paws::ELB::CreateLBCookieStickinessPolicy>
424  
425 Returns: a L<Paws::ELB::CreateLBCookieStickinessPolicyOutput> instance
426  
427 Generates a stickiness policy with sticky session lifetimes controlled
428 by the lifetime of the browser (user-agent) or a specified expiration
429 period. This policy can be associated only with HTTP/HTTPS listeners.
430  
431 When a load balancer implements this policy, the load balancer uses a
432 special cookie to track the instance for each request. When the load
433 balancer receives a request, it first checks to see if this cookie is
434 present in the request. If so, the load balancer sends the request to
435 the application server specified in the cookie. If not, the load
436 balancer sends the request to a server that is chosen based on the
437 existing load-balancing algorithm.
438  
439 A cookie is inserted into the response for binding subsequent requests
440 from the same user to that server. The validity of the cookie is based
441 on the cookie expiration time, which is specified in the policy
442 configuration.
443  
444 For more information, see Duration-Based Session Stickiness
445 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration)
446 in the I<Classic Load Balancers Guide>.
447  
448  
449 =head2 CreateLoadBalancer
450  
451 =over
452  
453 =item Listeners => ArrayRef[L<Paws::ELB::Listener>]
454  
455 =item LoadBalancerName => Str
456  
457 =item [AvailabilityZones => ArrayRef[Str|Undef]]
458  
459 =item [Scheme => Str]
460  
461 =item [SecurityGroups => ArrayRef[Str|Undef]]
462  
463 =item [Subnets => ArrayRef[Str|Undef]]
464  
465 =item [Tags => ArrayRef[L<Paws::ELB::Tag>]]
466  
467  
468 =back
469  
470 Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancer>
471  
472 Returns: a L<Paws::ELB::CreateAccessPointOutput> instance
473  
474 Creates a Classic Load Balancer.
475  
476 You can add listeners, security groups, subnets, and tags when you
477 create your load balancer, or you can add them later using
478 CreateLoadBalancerListeners, ApplySecurityGroupsToLoadBalancer,
479 AttachLoadBalancerToSubnets, and AddTags.
480  
481 To describe your current load balancers, see DescribeLoadBalancers.
482 When you are finished with a load balancer, you can delete it using
483 DeleteLoadBalancer.
484  
485 You can create up to 20 load balancers per region per account. You can
486 request an increase for the number of load balancers for your account.
487 For more information, see Limits for Your Classic Load Balancer
488 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html)
489 in the I<Classic Load Balancers Guide>.
490  
491  
492 =head2 CreateLoadBalancerListeners
493  
494 =over
495  
496 =item Listeners => ArrayRef[L<Paws::ELB::Listener>]
497  
498 =item LoadBalancerName => Str
499  
500  
501 =back
502  
503 Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancerListeners>
504  
505 Returns: a L<Paws::ELB::CreateLoadBalancerListenerOutput> instance
506  
507 Creates one or more listeners for the specified load balancer. If a
508 listener with the specified port does not already exist, it is created;
509 otherwise, the properties of the new listener must match the properties
510 of the existing listener.
511  
512 For more information, see Listeners for Your Classic Load Balancer
513 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html)
514 in the I<Classic Load Balancers Guide>.
515  
516  
517 =head2 CreateLoadBalancerPolicy
518  
519 =over
520  
521 =item LoadBalancerName => Str
522  
523 =item PolicyName => Str
524  
525 =item PolicyTypeName => Str
526  
527 =item [PolicyAttributes => ArrayRef[L<Paws::ELB::PolicyAttribute>]]
528  
529  
530 =back
531  
532 Each argument is described in detail in: L<Paws::ELB::CreateLoadBalancerPolicy>
533  
534 Returns: a L<Paws::ELB::CreateLoadBalancerPolicyOutput> instance
535  
536 Creates a policy with the specified attributes for the specified load
537 balancer.
538  
539 Policies are settings that are saved for your load balancer and that
540 can be applied to the listener or the application server, depending on
541 the policy type.
542  
543  
544 =head2 DeleteLoadBalancer
545  
546 =over
547  
548 =item LoadBalancerName => Str
549  
550  
551 =back
552  
553 Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancer>
554  
555 Returns: a L<Paws::ELB::DeleteAccessPointOutput> instance
556  
557 Deletes the specified load balancer.
558  
559 If you are attempting to recreate a load balancer, you must reconfigure
560 all settings. The DNS name associated with a deleted load balancer are
561 no longer usable. The name and associated DNS record of the deleted
562 load balancer no longer exist and traffic sent to any of its IP
563 addresses is no longer delivered to your instances.
564  
565 If the load balancer does not exist or has already been deleted, the
566 call to C<DeleteLoadBalancer> still succeeds.
567  
568  
569 =head2 DeleteLoadBalancerListeners
570  
571 =over
572  
573 =item LoadBalancerName => Str
574  
575 =item LoadBalancerPorts => ArrayRef[Int]
576  
577  
578 =back
579  
580 Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancerListeners>
581  
582 Returns: a L<Paws::ELB::DeleteLoadBalancerListenerOutput> instance
583  
584 Deletes the specified listeners from the specified load balancer.
585  
586  
587 =head2 DeleteLoadBalancerPolicy
588  
589 =over
590  
591 =item LoadBalancerName => Str
592  
593 =item PolicyName => Str
594  
595  
596 =back
597  
598 Each argument is described in detail in: L<Paws::ELB::DeleteLoadBalancerPolicy>
599  
600 Returns: a L<Paws::ELB::DeleteLoadBalancerPolicyOutput> instance
601  
602 Deletes the specified policy from the specified load balancer. This
603 policy must not be enabled for any listeners.
604  
605  
606 =head2 DeregisterInstancesFromLoadBalancer
607  
608 =over
609  
610 =item Instances => ArrayRef[L<Paws::ELB::Instance>]
611  
612 =item LoadBalancerName => Str
613  
614  
615 =back
616  
617 Each argument is described in detail in: L<Paws::ELB::DeregisterInstancesFromLoadBalancer>
618  
619 Returns: a L<Paws::ELB::DeregisterEndPointsOutput> instance
620  
621 Deregisters the specified instances from the specified load balancer.
622 After the instance is deregistered, it no longer receives traffic from
623 the load balancer.
624  
625 You can use DescribeLoadBalancers to verify that the instance is
626 deregistered from the load balancer.
627  
628 For more information, see Register or De-Register EC2 Instances
629 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-deregister-register-instances.html)
630 in the I<Classic Load Balancers Guide>.
631  
632  
633 =head2 DescribeAccountLimits
634  
635 =over
636  
637 =item [Marker => Str]
638  
639 =item [PageSize => Int]
640  
641  
642 =back
643  
644 Each argument is described in detail in: L<Paws::ELB::DescribeAccountLimits>
645  
646 Returns: a L<Paws::ELB::DescribeAccountLimitsOutput> instance
647  
648 Describes the current Elastic Load Balancing resource limits for your
649 AWS account.
650  
651 For more information, see Limits for Your Classic Load Balancer
652 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html)
653 in the I<Classic Load Balancers Guide>.
654  
655  
656 =head2 DescribeInstanceHealth
657  
658 =over
659  
660 =item LoadBalancerName => Str
661  
662 =item [Instances => ArrayRef[L<Paws::ELB::Instance>]]
663  
664  
665 =back
666  
667 Each argument is described in detail in: L<Paws::ELB::DescribeInstanceHealth>
668  
669 Returns: a L<Paws::ELB::DescribeEndPointStateOutput> instance
670  
671 Describes the state of the specified instances with respect to the
672 specified load balancer. If no instances are specified, the call
673 describes the state of all instances that are currently registered with
674 the load balancer. If instances are specified, their state is returned
675 even if they are no longer registered with the load balancer. The state
676 of terminated instances is not returned.
677  
678  
679 =head2 DescribeLoadBalancerAttributes
680  
681 =over
682  
683 =item LoadBalancerName => Str
684  
685  
686 =back
687  
688 Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerAttributes>
689  
690 Returns: a L<Paws::ELB::DescribeLoadBalancerAttributesOutput> instance
691  
692 Describes the attributes for the specified load balancer.
693  
694  
695 =head2 DescribeLoadBalancerPolicies
696  
697 =over
698  
699 =item [LoadBalancerName => Str]
700  
701 =item [PolicyNames => ArrayRef[Str|Undef]]
702  
703  
704 =back
705  
706 Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerPolicies>
707  
708 Returns: a L<Paws::ELB::DescribeLoadBalancerPoliciesOutput> instance
709  
710 Describes the specified policies.
711  
712 If you specify a load balancer name, the action returns the
713 descriptions of all policies created for the load balancer. If you
714 specify a policy name associated with your load balancer, the action
715 returns the description of that policy. If you don't specify a load
716 balancer name, the action returns descriptions of the specified sample
717 policies, or descriptions of all sample policies. The names of the
718 sample policies have the C<ELBSample-> prefix.
719  
720  
721 =head2 DescribeLoadBalancerPolicyTypes
722  
723 =over
724  
725 =item [PolicyTypeNames => ArrayRef[Str|Undef]]
726  
727  
728 =back
729  
730 Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancerPolicyTypes>
731  
732 Returns: a L<Paws::ELB::DescribeLoadBalancerPolicyTypesOutput> instance
733  
734 Describes the specified load balancer policy types or all load balancer
735 policy types.
736  
737 The description of each type indicates how it can be used. For example,
738 some policies can be used only with layer 7 listeners, some policies
739 can be used only with layer 4 listeners, and some policies can be used
740 only with your EC2 instances.
741  
742 You can use CreateLoadBalancerPolicy to create a policy configuration
743 for any of these policy types. Then, depending on the policy type, use
744 either SetLoadBalancerPoliciesOfListener or
745 SetLoadBalancerPoliciesForBackendServer to set the policy.
746  
747  
748 =head2 DescribeLoadBalancers
749  
750 =over
751  
752 =item [LoadBalancerNames => ArrayRef[Str|Undef]]
753  
754 =item [Marker => Str]
755  
756 =item [PageSize => Int]
757  
758  
759 =back
760  
761 Each argument is described in detail in: L<Paws::ELB::DescribeLoadBalancers>
762  
763 Returns: a L<Paws::ELB::DescribeAccessPointsOutput> instance
764  
765 Describes the specified the load balancers. If no load balancers are
766 specified, the call describes all of your load balancers.
767  
768  
769 =head2 DescribeTags
770  
771 =over
772  
773 =item LoadBalancerNames => ArrayRef[Str|Undef]
774  
775  
776 =back
777  
778 Each argument is described in detail in: L<Paws::ELB::DescribeTags>
779  
780 Returns: a L<Paws::ELB::DescribeTagsOutput> instance
781  
782 Describes the tags associated with the specified load balancers.
783  
784  
785 =head2 DetachLoadBalancerFromSubnets
786  
787 =over
788  
789 =item LoadBalancerName => Str
790  
791 =item Subnets => ArrayRef[Str|Undef]
792  
793  
794 =back
795  
796 Each argument is described in detail in: L<Paws::ELB::DetachLoadBalancerFromSubnets>
797  
798 Returns: a L<Paws::ELB::DetachLoadBalancerFromSubnetsOutput> instance
799  
800 Removes the specified subnets from the set of configured subnets for
801 the load balancer.
802  
803 After a subnet is removed, all EC2 instances registered with the load
804 balancer in the removed subnet go into the C<OutOfService> state. Then,
805 the load balancer balances the traffic among the remaining routable
806 subnets.
807  
808  
809 =head2 DisableAvailabilityZonesForLoadBalancer
810  
811 =over
812  
813 =item AvailabilityZones => ArrayRef[Str|Undef]
814  
815 =item LoadBalancerName => Str
816  
817  
818 =back
819  
820 Each argument is described in detail in: L<Paws::ELB::DisableAvailabilityZonesForLoadBalancer>
821  
822 Returns: a L<Paws::ELB::RemoveAvailabilityZonesOutput> instance
823  
824 Removes the specified Availability Zones from the set of Availability
825 Zones for the specified load balancer in EC2-Classic or a default VPC.
826  
827 For load balancers in a non-default VPC, use
828 DetachLoadBalancerFromSubnets.
829  
830 There must be at least one Availability Zone registered with a load
831 balancer at all times. After an Availability Zone is removed, all
832 instances registered with the load balancer that are in the removed
833 Availability Zone go into the C<OutOfService> state. Then, the load
834 balancer attempts to equally balance the traffic among its remaining
835 Availability Zones.
836  
837 For more information, see Add or Remove Availability Zones
838 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-az.html)
839 in the I<Classic Load Balancers Guide>.
840  
841  
842 =head2 EnableAvailabilityZonesForLoadBalancer
843  
844 =over
845  
846 =item AvailabilityZones => ArrayRef[Str|Undef]
847  
848 =item LoadBalancerName => Str
849  
850  
851 =back
852  
853 Each argument is described in detail in: L<Paws::ELB::EnableAvailabilityZonesForLoadBalancer>
854  
855 Returns: a L<Paws::ELB::AddAvailabilityZonesOutput> instance
856  
857 Adds the specified Availability Zones to the set of Availability Zones
858 for the specified load balancer in EC2-Classic or a default VPC.
859  
860 For load balancers in a non-default VPC, use
861 AttachLoadBalancerToSubnets.
862  
863 The load balancer evenly distributes requests across all its registered
864 Availability Zones that contain instances. For more information, see
865 Add or Remove Availability Zones
866 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-az.html)
867 in the I<Classic Load Balancers Guide>.
868  
869  
870 =head2 ModifyLoadBalancerAttributes
871  
872 =over
873  
874 =item LoadBalancerAttributes => L<Paws::ELB::LoadBalancerAttributes>
875  
876 =item LoadBalancerName => Str
877  
878  
879 =back
880  
881 Each argument is described in detail in: L<Paws::ELB::ModifyLoadBalancerAttributes>
882  
883 Returns: a L<Paws::ELB::ModifyLoadBalancerAttributesOutput> instance
884  
885 Modifies the attributes of the specified load balancer.
886  
887 You can modify the load balancer attributes, such as C<AccessLogs>,
888 C<ConnectionDraining>, and C<CrossZoneLoadBalancing> by either enabling
889 or disabling them. Or, you can modify the load balancer attribute
890 C<ConnectionSettings> by specifying an idle connection timeout value
891 for your load balancer.
892  
893 For more information, see the following in the I<Classic Load Balancers
894 Guide>:
895  
896 =over
897  
898 =item *
899  
900 Cross-Zone Load Balancing
901 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html)
902  
903 =item *
904  
905 Connection Draining
906 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html)
907  
908 =item *
909  
910 Access Logs
911 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html)
912  
913 =item *
914  
915 Idle Connection Timeout
916 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html)
917  
918 =back
919  
920  
921  
922 =head2 RegisterInstancesWithLoadBalancer
923  
924 =over
925  
926 =item Instances => ArrayRef[L<Paws::ELB::Instance>]
927  
928 =item LoadBalancerName => Str
929  
930  
931 =back
932  
933 Each argument is described in detail in: L<Paws::ELB::RegisterInstancesWithLoadBalancer>
934  
935 Returns: a L<Paws::ELB::RegisterEndPointsOutput> instance
936  
937 Adds the specified instances to the specified load balancer.
938  
939 The instance must be a running instance in the same network as the load
940 balancer (EC2-Classic or the same VPC). If you have EC2-Classic
941 instances and a load balancer in a VPC with ClassicLink enabled, you
942 can link the EC2-Classic instances to that VPC and then register the
943 linked EC2-Classic instances with the load balancer in the VPC.
944  
945 Note that C<RegisterInstanceWithLoadBalancer> completes when the
946 request has been registered. Instance registration takes a little time
947 to complete. To check the state of the registered instances, use
948 DescribeLoadBalancers or DescribeInstanceHealth.
949  
950 After the instance is registered, it starts receiving traffic and
951 requests from the load balancer. Any instance that is not in one of the
952 Availability Zones registered for the load balancer is moved to the
953 C<OutOfService> state. If an Availability Zone is added to the load
954 balancer later, any instances registered with the load balancer move to
955 the C<InService> state.
956  
957 To deregister instances from a load balancer, use
958 DeregisterInstancesFromLoadBalancer.
959  
960 For more information, see Register or De-Register EC2 Instances
961 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-deregister-register-instances.html)
962 in the I<Classic Load Balancers Guide>.
963  
964  
965 =head2 RemoveTags
966  
967 =over
968  
969 =item LoadBalancerNames => ArrayRef[Str|Undef]
970  
971 =item Tags => ArrayRef[L<Paws::ELB::TagKeyOnly>]
972  
973  
974 =back
975  
976 Each argument is described in detail in: L<Paws::ELB::RemoveTags>
977  
978 Returns: a L<Paws::ELB::RemoveTagsOutput> instance
979  
980 Removes one or more tags from the specified load balancer.
981  
982  
983 =head2 SetLoadBalancerListenerSSLCertificate
984  
985 =over
986  
987 =item LoadBalancerName => Str
988  
989 =item LoadBalancerPort => Int
990  
991 =item SSLCertificateId => Str
992  
993  
994 =back
995  
996 Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerListenerSSLCertificate>
997  
998 Returns: a L<Paws::ELB::SetLoadBalancerListenerSSLCertificateOutput> instance
999  
1000 Sets the certificate that terminates the specified listener's SSL
1001 connections. The specified certificate replaces any prior certificate
1002 that was used on the same load balancer and port.
1003  
1004 For more information about updating your SSL certificate, see Replace
1005 the SSL Certificate for Your Load Balancer
1006 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-update-ssl-cert.html)
1007 in the I<Classic Load Balancers Guide>.
1008  
1009  
1010 =head2 SetLoadBalancerPoliciesForBackendServer
1011  
1012 =over
1013  
1014 =item InstancePort => Int
1015  
1016 =item LoadBalancerName => Str
1017  
1018 =item PolicyNames => ArrayRef[Str|Undef]
1019  
1020  
1021 =back
1022  
1023 Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerPoliciesForBackendServer>
1024  
1025 Returns: a L<Paws::ELB::SetLoadBalancerPoliciesForBackendServerOutput> instance
1026  
1027 Replaces the set of policies associated with the specified port on
1028 which the EC2 instance is listening with a new set of policies. At this
1029 time, only the back-end server authentication policy type can be
1030 applied to the instance ports; this policy type is composed of multiple
1031 public key policies.
1032  
1033 Each time you use C<SetLoadBalancerPoliciesForBackendServer> to enable
1034 the policies, use the C<PolicyNames> parameter to list the policies
1035 that you want to enable.
1036  
1037 You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to
1038 verify that the policy is associated with the EC2 instance.
1039  
1040 For more information about enabling back-end instance authentication,
1041 see Configure Back-end Instance Authentication
1042 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-create-https-ssl-load-balancer.html#configure_backendauth_clt)
1043 in the I<Classic Load Balancers Guide>. For more information about
1044 Proxy Protocol, see Configure Proxy Protocol Support
1045 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-proxy-protocol.html)
1046 in the I<Classic Load Balancers Guide>.
1047  
1048  
1049 =head2 SetLoadBalancerPoliciesOfListener
1050  
1051 =over
1052  
1053 =item LoadBalancerName => Str
1054  
1055 =item LoadBalancerPort => Int
1056  
1057 =item PolicyNames => ArrayRef[Str|Undef]
1058  
1059  
1060 =back
1061  
1062 Each argument is described in detail in: L<Paws::ELB::SetLoadBalancerPoliciesOfListener>
1063  
1064 Returns: a L<Paws::ELB::SetLoadBalancerPoliciesOfListenerOutput> instance
1065  
1066 Replaces the current set of policies for the specified load balancer
1067 port with the specified set of policies.
1068  
1069 To enable back-end server authentication, use
1070 SetLoadBalancerPoliciesForBackendServer.
1071  
1072 For more information about setting policies, see Update the SSL
1073 Negotiation Configuration
1074 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/ssl-config-update.html),
1075 Duration-Based Session Stickiness
1076 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration),
1077 and Application-Controlled Session Stickiness
1078 (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-application)
1079 in the I<Classic Load Balancers Guide>.
1080  
1081  
1082  
1083  
1084 =head1 PAGINATORS
1085  
1086 Paginator methods are helpers that repetively call methods that return partial results
1087  
1088 =head2 DescribeAllAccountLimits(sub { },[Marker => Str, PageSize => Int])
1089  
1090 =head2 DescribeAllAccountLimits([Marker => Str, PageSize => Int])
1091  
1092  
1093 If passed a sub as first parameter, it will call the sub for each element found in :
1094  
1095 - Limits, passing the object as the first parameter, and the string 'Limits' as the second parameter
1096  
1097 If not, it will return a a L<Paws::ELB::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.
1098  
1099  
1100 =head2 DescribeAllLoadBalancers(sub { },[LoadBalancerNames => ArrayRef[Str|Undef], Marker => Str, PageSize => Int])
1101  
1102 =head2 DescribeAllLoadBalancers([LoadBalancerNames => ArrayRef[Str|Undef], Marker => Str, PageSize => Int])
1103  
1104  
1105 If passed a sub as first parameter, it will call the sub for each element found in :
1106  
1107 - LoadBalancerDescriptions, passing the object as the first parameter, and the string 'LoadBalancerDescriptions' as the second parameter
1108  
1109 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.
1110  
1111  
1112  
1113  
1114  
1115 =head1 SEE ALSO
1116  
1117 This service class forms part of L<Paws>
1118  
1119 =head1 BUGS and CONTRIBUTIONS
1120  
1121 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1122  
1123 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1124  
1125 =cut
1126  
« blib/lib/Paws/SQS.pm ↑ Summary blib/lib/Paws/Net/RestJsonCaller.pm »