blib/lib/Paws/Lightsail.pm untested

filter: Statementstmt 0.0% 0 / 841 Branchbran 0.0% 0 / 80 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 169 Podpod 0.0% 0 / 168 totaltotal 0.0% 0 / 1258 CC 41 SCAR 15.8
CC
41
Cov
0%
GetAllActiveNames
12.0
GetAllBlueprints
12.0
GetAllBundles
12.0
CRAP 4.9
1 package Paws::Lightsail;
2 use Moose;
3 sub service { 'lightsail' }
4 sub signing_name { 'lightsail' }
5 sub version { '2016-11-28' }
6 sub target_prefix { 'Lightsail_20161128' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AllocateStaticIp {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::Lightsail::AllocateStaticIp', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub AttachCertificateToDistribution {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::Lightsail::AttachCertificateToDistribution', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub AttachDisk {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::Lightsail::AttachDisk', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub AttachInstancesToLoadBalancer {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::Lightsail::AttachInstancesToLoadBalancer', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub AttachLoadBalancerTlsCertificate {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::Lightsail::AttachLoadBalancerTlsCertificate', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub AttachStaticIp {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::Lightsail::AttachStaticIp', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CloseInstancePublicPorts {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::Lightsail::CloseInstancePublicPorts', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub CopySnapshot {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::Lightsail::CopySnapshot', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub CreateCertificate {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateCertificate', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub CreateCloudFormationStack {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateCloudFormationStack', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub CreateContactMethod {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateContactMethod', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub CreateContainerService {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateContainerService', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub CreateContainerServiceDeployment {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateContainerServiceDeployment', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub CreateContainerServiceRegistryLogin {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateContainerServiceRegistryLogin', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub CreateDisk {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDisk', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub CreateDiskFromSnapshot {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDiskFromSnapshot', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub CreateDiskSnapshot {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDiskSnapshot', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub CreateDistribution {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDistribution', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub CreateDomain {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDomain', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub CreateDomainEntry {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateDomainEntry', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub CreateInstances {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateInstances', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub CreateInstancesFromSnapshot {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateInstancesFromSnapshot', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub CreateInstanceSnapshot {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateInstanceSnapshot', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub CreateKeyPair {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateKeyPair', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub CreateLoadBalancer {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateLoadBalancer', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub CreateLoadBalancerTlsCertificate {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateLoadBalancerTlsCertificate', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub CreateRelationalDatabase {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateRelationalDatabase', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub CreateRelationalDatabaseFromSnapshot {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateRelationalDatabaseFromSnapshot', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub CreateRelationalDatabaseSnapshot {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::Lightsail::CreateRelationalDatabaseSnapshot', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub DeleteAlarm {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteAlarm', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub DeleteAutoSnapshot {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteAutoSnapshot', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub DeleteCertificate {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteCertificate', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub DeleteContactMethod {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteContactMethod', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub DeleteContainerImage {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteContainerImage', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub DeleteContainerService {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteContainerService', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub DeleteDisk {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteDisk', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub DeleteDiskSnapshot {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteDiskSnapshot', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub DeleteDistribution {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteDistribution', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub DeleteDomain {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteDomain', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub DeleteDomainEntry {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteDomainEntry', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub DeleteInstance {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteInstance', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub DeleteInstanceSnapshot {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteInstanceSnapshot', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub DeleteKeyPair {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteKeyPair', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub DeleteKnownHostKeys {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteKnownHostKeys', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub DeleteLoadBalancer {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteLoadBalancer', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub DeleteLoadBalancerTlsCertificate {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteLoadBalancerTlsCertificate', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub DeleteRelationalDatabase {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteRelationalDatabase', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub DeleteRelationalDatabaseSnapshot {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::Lightsail::DeleteRelationalDatabaseSnapshot', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub DetachCertificateFromDistribution {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::Lightsail::DetachCertificateFromDistribution', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub DetachDisk {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::Lightsail::DetachDisk', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub DetachInstancesFromLoadBalancer {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::Lightsail::DetachInstancesFromLoadBalancer', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub DetachStaticIp {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::Lightsail::DetachStaticIp', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278 sub DisableAddOn {
279 my $self = shift;
280 my $call_object = $self->new_with_coercions('Paws::Lightsail::DisableAddOn', @_);
281 return $self->caller->do_call($self, $call_object);
282 }
283 sub DownloadDefaultKeyPair {
284 my $self = shift;
285 my $call_object = $self->new_with_coercions('Paws::Lightsail::DownloadDefaultKeyPair', @_);
286 return $self->caller->do_call($self, $call_object);
287 }
288 sub EnableAddOn {
289 my $self = shift;
290 my $call_object = $self->new_with_coercions('Paws::Lightsail::EnableAddOn', @_);
291 return $self->caller->do_call($self, $call_object);
292 }
293 sub ExportSnapshot {
294 my $self = shift;
295 my $call_object = $self->new_with_coercions('Paws::Lightsail::ExportSnapshot', @_);
296 return $self->caller->do_call($self, $call_object);
297 }
298 sub GetActiveNames {
299 my $self = shift;
300 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetActiveNames', @_);
301 return $self->caller->do_call($self, $call_object);
302 }
303 sub GetAlarms {
304 my $self = shift;
305 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetAlarms', @_);
306 return $self->caller->do_call($self, $call_object);
307 }
308 sub GetAutoSnapshots {
309 my $self = shift;
310 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetAutoSnapshots', @_);
311 return $self->caller->do_call($self, $call_object);
312 }
313 sub GetBlueprints {
314 my $self = shift;
315 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetBlueprints', @_);
316 return $self->caller->do_call($self, $call_object);
317 }
318 sub GetBundles {
319 my $self = shift;
320 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetBundles', @_);
321 return $self->caller->do_call($self, $call_object);
322 }
323 sub GetCertificates {
324 my $self = shift;
325 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetCertificates', @_);
326 return $self->caller->do_call($self, $call_object);
327 }
328 sub GetCloudFormationStackRecords {
329 my $self = shift;
330 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetCloudFormationStackRecords', @_);
331 return $self->caller->do_call($self, $call_object);
332 }
333 sub GetContactMethods {
334 my $self = shift;
335 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContactMethods', @_);
336 return $self->caller->do_call($self, $call_object);
337 }
338 sub GetContainerAPIMetadata {
339 my $self = shift;
340 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerAPIMetadata', @_);
341 return $self->caller->do_call($self, $call_object);
342 }
343 sub GetContainerImages {
344 my $self = shift;
345 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerImages', @_);
346 return $self->caller->do_call($self, $call_object);
347 }
348 sub GetContainerLog {
349 my $self = shift;
350 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerLog', @_);
351 return $self->caller->do_call($self, $call_object);
352 }
353 sub GetContainerServiceDeployments {
354 my $self = shift;
355 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerServiceDeployments', @_);
356 return $self->caller->do_call($self, $call_object);
357 }
358 sub GetContainerServiceMetricData {
359 my $self = shift;
360 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerServiceMetricData', @_);
361 return $self->caller->do_call($self, $call_object);
362 }
363 sub GetContainerServicePowers {
364 my $self = shift;
365 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerServicePowers', @_);
366 return $self->caller->do_call($self, $call_object);
367 }
368 sub GetContainerServices {
369 my $self = shift;
370 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetContainerServices', @_);
371 return $self->caller->do_call($self, $call_object);
372 }
373 sub GetDisk {
374 my $self = shift;
375 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDisk', @_);
376 return $self->caller->do_call($self, $call_object);
377 }
378 sub GetDisks {
379 my $self = shift;
380 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDisks', @_);
381 return $self->caller->do_call($self, $call_object);
382 }
383 sub GetDiskSnapshot {
384 my $self = shift;
385 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDiskSnapshot', @_);
386 return $self->caller->do_call($self, $call_object);
387 }
388 sub GetDiskSnapshots {
389 my $self = shift;
390 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDiskSnapshots', @_);
391 return $self->caller->do_call($self, $call_object);
392 }
393 sub GetDistributionBundles {
394 my $self = shift;
395 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDistributionBundles', @_);
396 return $self->caller->do_call($self, $call_object);
397 }
398 sub GetDistributionLatestCacheReset {
399 my $self = shift;
400 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDistributionLatestCacheReset', @_);
401 return $self->caller->do_call($self, $call_object);
402 }
403 sub GetDistributionMetricData {
404 my $self = shift;
405 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDistributionMetricData', @_);
406 return $self->caller->do_call($self, $call_object);
407 }
408 sub GetDistributions {
409 my $self = shift;
410 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDistributions', @_);
411 return $self->caller->do_call($self, $call_object);
412 }
413 sub GetDomain {
414 my $self = shift;
415 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDomain', @_);
416 return $self->caller->do_call($self, $call_object);
417 }
418 sub GetDomains {
419 my $self = shift;
420 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetDomains', @_);
421 return $self->caller->do_call($self, $call_object);
422 }
423 sub GetExportSnapshotRecords {
424 my $self = shift;
425 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetExportSnapshotRecords', @_);
426 return $self->caller->do_call($self, $call_object);
427 }
428 sub GetInstance {
429 my $self = shift;
430 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstance', @_);
431 return $self->caller->do_call($self, $call_object);
432 }
433 sub GetInstanceAccessDetails {
434 my $self = shift;
435 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstanceAccessDetails', @_);
436 return $self->caller->do_call($self, $call_object);
437 }
438 sub GetInstanceMetricData {
439 my $self = shift;
440 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstanceMetricData', @_);
441 return $self->caller->do_call($self, $call_object);
442 }
443 sub GetInstancePortStates {
444 my $self = shift;
445 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstancePortStates', @_);
446 return $self->caller->do_call($self, $call_object);
447 }
448 sub GetInstances {
449 my $self = shift;
450 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstances', @_);
451 return $self->caller->do_call($self, $call_object);
452 }
453 sub GetInstanceSnapshot {
454 my $self = shift;
455 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstanceSnapshot', @_);
456 return $self->caller->do_call($self, $call_object);
457 }
458 sub GetInstanceSnapshots {
459 my $self = shift;
460 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstanceSnapshots', @_);
461 return $self->caller->do_call($self, $call_object);
462 }
463 sub GetInstanceState {
464 my $self = shift;
465 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetInstanceState', @_);
466 return $self->caller->do_call($self, $call_object);
467 }
468 sub GetKeyPair {
469 my $self = shift;
470 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetKeyPair', @_);
471 return $self->caller->do_call($self, $call_object);
472 }
473 sub GetKeyPairs {
474 my $self = shift;
475 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetKeyPairs', @_);
476 return $self->caller->do_call($self, $call_object);
477 }
478 sub GetLoadBalancer {
479 my $self = shift;
480 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetLoadBalancer', @_);
481 return $self->caller->do_call($self, $call_object);
482 }
483 sub GetLoadBalancerMetricData {
484 my $self = shift;
485 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetLoadBalancerMetricData', @_);
486 return $self->caller->do_call($self, $call_object);
487 }
488 sub GetLoadBalancers {
489 my $self = shift;
490 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetLoadBalancers', @_);
491 return $self->caller->do_call($self, $call_object);
492 }
493 sub GetLoadBalancerTlsCertificates {
494 my $self = shift;
495 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetLoadBalancerTlsCertificates', @_);
496 return $self->caller->do_call($self, $call_object);
497 }
498 sub GetOperation {
499 my $self = shift;
500 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetOperation', @_);
501 return $self->caller->do_call($self, $call_object);
502 }
503 sub GetOperations {
504 my $self = shift;
505 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetOperations', @_);
506 return $self->caller->do_call($self, $call_object);
507 }
508 sub GetOperationsForResource {
509 my $self = shift;
510 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetOperationsForResource', @_);
511 return $self->caller->do_call($self, $call_object);
512 }
513 sub GetRegions {
514 my $self = shift;
515 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRegions', @_);
516 return $self->caller->do_call($self, $call_object);
517 }
518 sub GetRelationalDatabase {
519 my $self = shift;
520 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabase', @_);
521 return $self->caller->do_call($self, $call_object);
522 }
523 sub GetRelationalDatabaseBlueprints {
524 my $self = shift;
525 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseBlueprints', @_);
526 return $self->caller->do_call($self, $call_object);
527 }
528 sub GetRelationalDatabaseBundles {
529 my $self = shift;
530 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseBundles', @_);
531 return $self->caller->do_call($self, $call_object);
532 }
533 sub GetRelationalDatabaseEvents {
534 my $self = shift;
535 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseEvents', @_);
536 return $self->caller->do_call($self, $call_object);
537 }
538 sub GetRelationalDatabaseLogEvents {
539 my $self = shift;
540 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseLogEvents', @_);
541 return $self->caller->do_call($self, $call_object);
542 }
543 sub GetRelationalDatabaseLogStreams {
544 my $self = shift;
545 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseLogStreams', @_);
546 return $self->caller->do_call($self, $call_object);
547 }
548 sub GetRelationalDatabaseMasterUserPassword {
549 my $self = shift;
550 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseMasterUserPassword', @_);
551 return $self->caller->do_call($self, $call_object);
552 }
553 sub GetRelationalDatabaseMetricData {
554 my $self = shift;
555 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseMetricData', @_);
556 return $self->caller->do_call($self, $call_object);
557 }
558 sub GetRelationalDatabaseParameters {
559 my $self = shift;
560 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseParameters', @_);
561 return $self->caller->do_call($self, $call_object);
562 }
563 sub GetRelationalDatabases {
564 my $self = shift;
565 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabases', @_);
566 return $self->caller->do_call($self, $call_object);
567 }
568 sub GetRelationalDatabaseSnapshot {
569 my $self = shift;
570 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseSnapshot', @_);
571 return $self->caller->do_call($self, $call_object);
572 }
573 sub GetRelationalDatabaseSnapshots {
574 my $self = shift;
575 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetRelationalDatabaseSnapshots', @_);
576 return $self->caller->do_call($self, $call_object);
577 }
578 sub GetStaticIp {
579 my $self = shift;
580 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetStaticIp', @_);
581 return $self->caller->do_call($self, $call_object);
582 }
583 sub GetStaticIps {
584 my $self = shift;
585 my $call_object = $self->new_with_coercions('Paws::Lightsail::GetStaticIps', @_);
586 return $self->caller->do_call($self, $call_object);
587 }
588 sub ImportKeyPair {
589 my $self = shift;
590 my $call_object = $self->new_with_coercions('Paws::Lightsail::ImportKeyPair', @_);
591 return $self->caller->do_call($self, $call_object);
592 }
593 sub IsVpcPeered {
594 my $self = shift;
595 my $call_object = $self->new_with_coercions('Paws::Lightsail::IsVpcPeered', @_);
596 return $self->caller->do_call($self, $call_object);
597 }
598 sub OpenInstancePublicPorts {
599 my $self = shift;
600 my $call_object = $self->new_with_coercions('Paws::Lightsail::OpenInstancePublicPorts', @_);
601 return $self->caller->do_call($self, $call_object);
602 }
603 sub PeerVpc {
604 my $self = shift;
605 my $call_object = $self->new_with_coercions('Paws::Lightsail::PeerVpc', @_);
606 return $self->caller->do_call($self, $call_object);
607 }
608 sub PutAlarm {
609 my $self = shift;
610 my $call_object = $self->new_with_coercions('Paws::Lightsail::PutAlarm', @_);
611 return $self->caller->do_call($self, $call_object);
612 }
613 sub PutInstancePublicPorts {
614 my $self = shift;
615 my $call_object = $self->new_with_coercions('Paws::Lightsail::PutInstancePublicPorts', @_);
616 return $self->caller->do_call($self, $call_object);
617 }
618 sub RebootInstance {
619 my $self = shift;
620 my $call_object = $self->new_with_coercions('Paws::Lightsail::RebootInstance', @_);
621 return $self->caller->do_call($self, $call_object);
622 }
623 sub RebootRelationalDatabase {
624 my $self = shift;
625 my $call_object = $self->new_with_coercions('Paws::Lightsail::RebootRelationalDatabase', @_);
626 return $self->caller->do_call($self, $call_object);
627 }
628 sub RegisterContainerImage {
629 my $self = shift;
630 my $call_object = $self->new_with_coercions('Paws::Lightsail::RegisterContainerImage', @_);
631 return $self->caller->do_call($self, $call_object);
632 }
633 sub ReleaseStaticIp {
634 my $self = shift;
635 my $call_object = $self->new_with_coercions('Paws::Lightsail::ReleaseStaticIp', @_);
636 return $self->caller->do_call($self, $call_object);
637 }
638 sub ResetDistributionCache {
639 my $self = shift;
640 my $call_object = $self->new_with_coercions('Paws::Lightsail::ResetDistributionCache', @_);
641 return $self->caller->do_call($self, $call_object);
642 }
643 sub SendContactMethodVerification {
644 my $self = shift;
645 my $call_object = $self->new_with_coercions('Paws::Lightsail::SendContactMethodVerification', @_);
646 return $self->caller->do_call($self, $call_object);
647 }
648 sub SetIpAddressType {
649 my $self = shift;
650 my $call_object = $self->new_with_coercions('Paws::Lightsail::SetIpAddressType', @_);
651 return $self->caller->do_call($self, $call_object);
652 }
653 sub StartInstance {
654 my $self = shift;
655 my $call_object = $self->new_with_coercions('Paws::Lightsail::StartInstance', @_);
656 return $self->caller->do_call($self, $call_object);
657 }
658 sub StartRelationalDatabase {
659 my $self = shift;
660 my $call_object = $self->new_with_coercions('Paws::Lightsail::StartRelationalDatabase', @_);
661 return $self->caller->do_call($self, $call_object);
662 }
663 sub StopInstance {
664 my $self = shift;
665 my $call_object = $self->new_with_coercions('Paws::Lightsail::StopInstance', @_);
666 return $self->caller->do_call($self, $call_object);
667 }
668 sub StopRelationalDatabase {
669 my $self = shift;
670 my $call_object = $self->new_with_coercions('Paws::Lightsail::StopRelationalDatabase', @_);
671 return $self->caller->do_call($self, $call_object);
672 }
673 sub TagResource {
674 my $self = shift;
675 my $call_object = $self->new_with_coercions('Paws::Lightsail::TagResource', @_);
676 return $self->caller->do_call($self, $call_object);
677 }
678 sub TestAlarm {
679 my $self = shift;
680 my $call_object = $self->new_with_coercions('Paws::Lightsail::TestAlarm', @_);
681 return $self->caller->do_call($self, $call_object);
682 }
683 sub UnpeerVpc {
684 my $self = shift;
685 my $call_object = $self->new_with_coercions('Paws::Lightsail::UnpeerVpc', @_);
686 return $self->caller->do_call($self, $call_object);
687 }
688 sub UntagResource {
689 my $self = shift;
690 my $call_object = $self->new_with_coercions('Paws::Lightsail::UntagResource', @_);
691 return $self->caller->do_call($self, $call_object);
692 }
693 sub UpdateContainerService {
694 my $self = shift;
695 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateContainerService', @_);
696 return $self->caller->do_call($self, $call_object);
697 }
698 sub UpdateDistribution {
699 my $self = shift;
700 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateDistribution', @_);
701 return $self->caller->do_call($self, $call_object);
702 }
703 sub UpdateDistributionBundle {
704 my $self = shift;
705 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateDistributionBundle', @_);
706 return $self->caller->do_call($self, $call_object);
707 }
708 sub UpdateDomainEntry {
709 my $self = shift;
710 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateDomainEntry', @_);
711 return $self->caller->do_call($self, $call_object);
712 }
713 sub UpdateLoadBalancerAttribute {
714 my $self = shift;
715 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateLoadBalancerAttribute', @_);
716 return $self->caller->do_call($self, $call_object);
717 }
718 sub UpdateRelationalDatabase {
719 my $self = shift;
720 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateRelationalDatabase', @_);
721 return $self->caller->do_call($self, $call_object);
722 }
723 sub UpdateRelationalDatabaseParameters {
724 my $self = shift;
725 my $call_object = $self->new_with_coercions('Paws::Lightsail::UpdateRelationalDatabaseParameters', @_);
726 return $self->caller->do_call($self, $call_object);
727 }
728
729 sub GetAllActiveNames {
730 my $self = shift;
731  
732 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
733 my $result = $self->GetActiveNames(@_);
734 my $next_result = $result;
735  
736 if (not defined $callback) {
737 while ($next_result->nextPageToken) {
738 $next_result = $self->GetActiveNames(@_, pageToken => $next_result->nextPageToken);
739 push @{ $result->activeNames }, @{ $next_result->activeNames };
740 }
741 return $result;
742 } else {
743 while ($result->nextPageToken) {
744 $callback->($_ => 'activeNames') foreach (@{ $result->activeNames });
745 $result = $self->GetActiveNames(@_, pageToken => $result->nextPageToken);
746 }
747 $callback->($_ => 'activeNames') foreach (@{ $result->activeNames });
748 }
749  
750 return undef
751 }
752 sub GetAllBlueprints {
753 my $self = shift;
754  
755 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
756 my $result = $self->GetBlueprints(@_);
757 my $next_result = $result;
758  
759 if (not defined $callback) {
760 while ($next_result->nextPageToken) {
761 $next_result = $self->GetBlueprints(@_, pageToken => $next_result->nextPageToken);
762 push @{ $result->blueprints }, @{ $next_result->blueprints };
763 }
764 return $result;
765 } else {
766 while ($result->nextPageToken) {
767 $callback->($_ => 'blueprints') foreach (@{ $result->blueprints });
768 $result = $self->GetBlueprints(@_, pageToken => $result->nextPageToken);
769 }
770 $callback->($_ => 'blueprints') foreach (@{ $result->blueprints });
771 }
772  
773 return undef
774 }
775 sub GetAllBundles {
776 my $self = shift;
777  
778 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
779 my $result = $self->GetBundles(@_);
780 my $next_result = $result;
781  
782 if (not defined $callback) {
783 while ($next_result->nextPageToken) {
784 $next_result = $self->GetBundles(@_, pageToken => $next_result->nextPageToken);
785 push @{ $result->bundles }, @{ $next_result->bundles };
786 }
787 return $result;
788 } else {
789 while ($result->nextPageToken) {
790 $callback->($_ => 'bundles') foreach (@{ $result->bundles });
791 $result = $self->GetBundles(@_, pageToken => $result->nextPageToken);
792 }
793 $callback->($_ => 'bundles') foreach (@{ $result->bundles });
794 }
795  
796 return undef
797 }
798 sub GetAllCloudFormationStackRecords {
799 my $self = shift;
800  
801 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
802 my $result = $self->GetCloudFormationStackRecords(@_);
803 my $next_result = $result;
804  
805 if (not defined $callback) {
806 while ($next_result->nextPageToken) {
807 $next_result = $self->GetCloudFormationStackRecords(@_, pageToken => $next_result->nextPageToken);
808 push @{ $result->cloudFormationStackRecords }, @{ $next_result->cloudFormationStackRecords };
809 }
810 return $result;
811 } else {
812 while ($result->nextPageToken) {
813 $callback->($_ => 'cloudFormationStackRecords') foreach (@{ $result->cloudFormationStackRecords });
814 $result = $self->GetCloudFormationStackRecords(@_, pageToken => $result->nextPageToken);
815 }
816 $callback->($_ => 'cloudFormationStackRecords') foreach (@{ $result->cloudFormationStackRecords });
817 }
818  
819 return undef
820 }
821 sub GetAllDisks {
822 my $self = shift;
823  
824 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
825 my $result = $self->GetDisks(@_);
826 my $next_result = $result;
827  
828 if (not defined $callback) {
829 while ($next_result->nextPageToken) {
830 $next_result = $self->GetDisks(@_, pageToken => $next_result->nextPageToken);
831 push @{ $result->disks }, @{ $next_result->disks };
832 }
833 return $result;
834 } else {
835 while ($result->nextPageToken) {
836 $callback->($_ => 'disks') foreach (@{ $result->disks });
837 $result = $self->GetDisks(@_, pageToken => $result->nextPageToken);
838 }
839 $callback->($_ => 'disks') foreach (@{ $result->disks });
840 }
841  
842 return undef
843 }
844 sub GetAllDiskSnapshots {
845 my $self = shift;
846  
847 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
848 my $result = $self->GetDiskSnapshots(@_);
849 my $next_result = $result;
850  
851 if (not defined $callback) {
852 while ($next_result->nextPageToken) {
853 $next_result = $self->GetDiskSnapshots(@_, pageToken => $next_result->nextPageToken);
854 push @{ $result->diskSnapshots }, @{ $next_result->diskSnapshots };
855 }
856 return $result;
857 } else {
858 while ($result->nextPageToken) {
859 $callback->($_ => 'diskSnapshots') foreach (@{ $result->diskSnapshots });
860 $result = $self->GetDiskSnapshots(@_, pageToken => $result->nextPageToken);
861 }
862 $callback->($_ => 'diskSnapshots') foreach (@{ $result->diskSnapshots });
863 }
864  
865 return undef
866 }
867 sub GetAllDomains {
868 my $self = shift;
869  
870 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
871 my $result = $self->GetDomains(@_);
872 my $next_result = $result;
873  
874 if (not defined $callback) {
875 while ($next_result->nextPageToken) {
876 $next_result = $self->GetDomains(@_, pageToken => $next_result->nextPageToken);
877 push @{ $result->domains }, @{ $next_result->domains };
878 }
879 return $result;
880 } else {
881 while ($result->nextPageToken) {
882 $callback->($_ => 'domains') foreach (@{ $result->domains });
883 $result = $self->GetDomains(@_, pageToken => $result->nextPageToken);
884 }
885 $callback->($_ => 'domains') foreach (@{ $result->domains });
886 }
887  
888 return undef
889 }
890 sub GetAllExportSnapshotRecords {
891 my $self = shift;
892  
893 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
894 my $result = $self->GetExportSnapshotRecords(@_);
895 my $next_result = $result;
896  
897 if (not defined $callback) {
898 while ($next_result->nextPageToken) {
899 $next_result = $self->GetExportSnapshotRecords(@_, pageToken => $next_result->nextPageToken);
900 push @{ $result->exportSnapshotRecords }, @{ $next_result->exportSnapshotRecords };
901 }
902 return $result;
903 } else {
904 while ($result->nextPageToken) {
905 $callback->($_ => 'exportSnapshotRecords') foreach (@{ $result->exportSnapshotRecords });
906 $result = $self->GetExportSnapshotRecords(@_, pageToken => $result->nextPageToken);
907 }
908 $callback->($_ => 'exportSnapshotRecords') foreach (@{ $result->exportSnapshotRecords });
909 }
910  
911 return undef
912 }
913 sub GetAllInstances {
914 my $self = shift;
915  
916 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
917 my $result = $self->GetInstances(@_);
918 my $next_result = $result;
919  
920 if (not defined $callback) {
921 while ($next_result->nextPageToken) {
922 $next_result = $self->GetInstances(@_, pageToken => $next_result->nextPageToken);
923 push @{ $result->instances }, @{ $next_result->instances };
924 }
925 return $result;
926 } else {
927 while ($result->nextPageToken) {
928 $callback->($_ => 'instances') foreach (@{ $result->instances });
929 $result = $self->GetInstances(@_, pageToken => $result->nextPageToken);
930 }
931 $callback->($_ => 'instances') foreach (@{ $result->instances });
932 }
933  
934 return undef
935 }
936 sub GetAllInstanceSnapshots {
937 my $self = shift;
938  
939 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
940 my $result = $self->GetInstanceSnapshots(@_);
941 my $next_result = $result;
942  
943 if (not defined $callback) {
944 while ($next_result->nextPageToken) {
945 $next_result = $self->GetInstanceSnapshots(@_, pageToken => $next_result->nextPageToken);
946 push @{ $result->instanceSnapshots }, @{ $next_result->instanceSnapshots };
947 }
948 return $result;
949 } else {
950 while ($result->nextPageToken) {
951 $callback->($_ => 'instanceSnapshots') foreach (@{ $result->instanceSnapshots });
952 $result = $self->GetInstanceSnapshots(@_, pageToken => $result->nextPageToken);
953 }
954 $callback->($_ => 'instanceSnapshots') foreach (@{ $result->instanceSnapshots });
955 }
956  
957 return undef
958 }
959 sub GetAllKeyPairs {
960 my $self = shift;
961  
962 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
963 my $result = $self->GetKeyPairs(@_);
964 my $next_result = $result;
965  
966 if (not defined $callback) {
967 while ($next_result->nextPageToken) {
968 $next_result = $self->GetKeyPairs(@_, pageToken => $next_result->nextPageToken);
969 push @{ $result->keyPairs }, @{ $next_result->keyPairs };
970 }
971 return $result;
972 } else {
973 while ($result->nextPageToken) {
974 $callback->($_ => 'keyPairs') foreach (@{ $result->keyPairs });
975 $result = $self->GetKeyPairs(@_, pageToken => $result->nextPageToken);
976 }
977 $callback->($_ => 'keyPairs') foreach (@{ $result->keyPairs });
978 }
979  
980 return undef
981 }
982 sub GetAllLoadBalancers {
983 my $self = shift;
984  
985 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
986 my $result = $self->GetLoadBalancers(@_);
987 my $next_result = $result;
988  
989 if (not defined $callback) {
990 while ($next_result->nextPageToken) {
991 $next_result = $self->GetLoadBalancers(@_, pageToken => $next_result->nextPageToken);
992 push @{ $result->loadBalancers }, @{ $next_result->loadBalancers };
993 }
994 return $result;
995 } else {
996 while ($result->nextPageToken) {
997 $callback->($_ => 'loadBalancers') foreach (@{ $result->loadBalancers });
998 $result = $self->GetLoadBalancers(@_, pageToken => $result->nextPageToken);
999 }
1000 $callback->($_ => 'loadBalancers') foreach (@{ $result->loadBalancers });
1001 }
1002  
1003 return undef
1004 }
1005 sub GetAllOperations {
1006 my $self = shift;
1007  
1008 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1009 my $result = $self->GetOperations(@_);
1010 my $next_result = $result;
1011  
1012 if (not defined $callback) {
1013 while ($next_result->nextPageToken) {
1014 $next_result = $self->GetOperations(@_, pageToken => $next_result->nextPageToken);
1015 push @{ $result->operations }, @{ $next_result->operations };
1016 }
1017 return $result;
1018 } else {
1019 while ($result->nextPageToken) {
1020 $callback->($_ => 'operations') foreach (@{ $result->operations });
1021 $result = $self->GetOperations(@_, pageToken => $result->nextPageToken);
1022 }
1023 $callback->($_ => 'operations') foreach (@{ $result->operations });
1024 }
1025  
1026 return undef
1027 }
1028 sub GetAllRelationalDatabaseBlueprints {
1029 my $self = shift;
1030  
1031 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1032 my $result = $self->GetRelationalDatabaseBlueprints(@_);
1033 my $next_result = $result;
1034  
1035 if (not defined $callback) {
1036 while ($next_result->nextPageToken) {
1037 $next_result = $self->GetRelationalDatabaseBlueprints(@_, pageToken => $next_result->nextPageToken);
1038 push @{ $result->blueprints }, @{ $next_result->blueprints };
1039 }
1040 return $result;
1041 } else {
1042 while ($result->nextPageToken) {
1043 $callback->($_ => 'blueprints') foreach (@{ $result->blueprints });
1044 $result = $self->GetRelationalDatabaseBlueprints(@_, pageToken => $result->nextPageToken);
1045 }
1046 $callback->($_ => 'blueprints') foreach (@{ $result->blueprints });
1047 }
1048  
1049 return undef
1050 }
1051 sub GetAllRelationalDatabaseBundles {
1052 my $self = shift;
1053  
1054 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1055 my $result = $self->GetRelationalDatabaseBundles(@_);
1056 my $next_result = $result;
1057  
1058 if (not defined $callback) {
1059 while ($next_result->nextPageToken) {
1060 $next_result = $self->GetRelationalDatabaseBundles(@_, pageToken => $next_result->nextPageToken);
1061 push @{ $result->bundles }, @{ $next_result->bundles };
1062 }
1063 return $result;
1064 } else {
1065 while ($result->nextPageToken) {
1066 $callback->($_ => 'bundles') foreach (@{ $result->bundles });
1067 $result = $self->GetRelationalDatabaseBundles(@_, pageToken => $result->nextPageToken);
1068 }
1069 $callback->($_ => 'bundles') foreach (@{ $result->bundles });
1070 }
1071  
1072 return undef
1073 }
1074 sub GetAllRelationalDatabaseEvents {
1075 my $self = shift;
1076  
1077 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1078 my $result = $self->GetRelationalDatabaseEvents(@_);
1079 my $next_result = $result;
1080  
1081 if (not defined $callback) {
1082 while ($next_result->nextPageToken) {
1083 $next_result = $self->GetRelationalDatabaseEvents(@_, pageToken => $next_result->nextPageToken);
1084 push @{ $result->relationalDatabaseEvents }, @{ $next_result->relationalDatabaseEvents };
1085 }
1086 return $result;
1087 } else {
1088 while ($result->nextPageToken) {
1089 $callback->($_ => 'relationalDatabaseEvents') foreach (@{ $result->relationalDatabaseEvents });
1090 $result = $self->GetRelationalDatabaseEvents(@_, pageToken => $result->nextPageToken);
1091 }
1092 $callback->($_ => 'relationalDatabaseEvents') foreach (@{ $result->relationalDatabaseEvents });
1093 }
1094  
1095 return undef
1096 }
1097 sub GetAllRelationalDatabaseParameters {
1098 my $self = shift;
1099  
1100 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1101 my $result = $self->GetRelationalDatabaseParameters(@_);
1102 my $next_result = $result;
1103  
1104 if (not defined $callback) {
1105 while ($next_result->nextPageToken) {
1106 $next_result = $self->GetRelationalDatabaseParameters(@_, pageToken => $next_result->nextPageToken);
1107 push @{ $result->parameters }, @{ $next_result->parameters };
1108 }
1109 return $result;
1110 } else {
1111 while ($result->nextPageToken) {
1112 $callback->($_ => 'parameters') foreach (@{ $result->parameters });
1113 $result = $self->GetRelationalDatabaseParameters(@_, pageToken => $result->nextPageToken);
1114 }
1115 $callback->($_ => 'parameters') foreach (@{ $result->parameters });
1116 }
1117  
1118 return undef
1119 }
1120 sub GetAllRelationalDatabases {
1121 my $self = shift;
1122  
1123 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1124 my $result = $self->GetRelationalDatabases(@_);
1125 my $next_result = $result;
1126  
1127 if (not defined $callback) {
1128 while ($next_result->nextPageToken) {
1129 $next_result = $self->GetRelationalDatabases(@_, pageToken => $next_result->nextPageToken);
1130 push @{ $result->relationalDatabases }, @{ $next_result->relationalDatabases };
1131 }
1132 return $result;
1133 } else {
1134 while ($result->nextPageToken) {
1135 $callback->($_ => 'relationalDatabases') foreach (@{ $result->relationalDatabases });
1136 $result = $self->GetRelationalDatabases(@_, pageToken => $result->nextPageToken);
1137 }
1138 $callback->($_ => 'relationalDatabases') foreach (@{ $result->relationalDatabases });
1139 }
1140  
1141 return undef
1142 }
1143 sub GetAllRelationalDatabaseSnapshots {
1144 my $self = shift;
1145  
1146 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1147 my $result = $self->GetRelationalDatabaseSnapshots(@_);
1148 my $next_result = $result;
1149  
1150 if (not defined $callback) {
1151 while ($next_result->nextPageToken) {
1152 $next_result = $self->GetRelationalDatabaseSnapshots(@_, pageToken => $next_result->nextPageToken);
1153 push @{ $result->relationalDatabaseSnapshots }, @{ $next_result->relationalDatabaseSnapshots };
1154 }
1155 return $result;
1156 } else {
1157 while ($result->nextPageToken) {
1158 $callback->($_ => 'relationalDatabaseSnapshots') foreach (@{ $result->relationalDatabaseSnapshots });
1159 $result = $self->GetRelationalDatabaseSnapshots(@_, pageToken => $result->nextPageToken);
1160 }
1161 $callback->($_ => 'relationalDatabaseSnapshots') foreach (@{ $result->relationalDatabaseSnapshots });
1162 }
1163  
1164 return undef
1165 }
1166 sub GetAllStaticIps {
1167 my $self = shift;
1168  
1169 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1170 my $result = $self->GetStaticIps(@_);
1171 my $next_result = $result;
1172  
1173 if (not defined $callback) {
1174 while ($next_result->nextPageToken) {
1175 $next_result = $self->GetStaticIps(@_, pageToken => $next_result->nextPageToken);
1176 push @{ $result->staticIps }, @{ $next_result->staticIps };
1177 }
1178 return $result;
1179 } else {
1180 while ($result->nextPageToken) {
1181 $callback->($_ => 'staticIps') foreach (@{ $result->staticIps });
1182 $result = $self->GetStaticIps(@_, pageToken => $result->nextPageToken);
1183 }
1184 $callback->($_ => 'staticIps') foreach (@{ $result->staticIps });
1185 }
1186  
1187 return undef
1188 }
1189  
1190  
1191 sub operations { qw/AllocateStaticIp AttachCertificateToDistribution AttachDisk AttachInstancesToLoadBalancer AttachLoadBalancerTlsCertificate AttachStaticIp CloseInstancePublicPorts CopySnapshot CreateCertificate CreateCloudFormationStack CreateContactMethod CreateContainerService CreateContainerServiceDeployment CreateContainerServiceRegistryLogin CreateDisk CreateDiskFromSnapshot CreateDiskSnapshot CreateDistribution CreateDomain CreateDomainEntry CreateInstances CreateInstancesFromSnapshot CreateInstanceSnapshot CreateKeyPair CreateLoadBalancer CreateLoadBalancerTlsCertificate CreateRelationalDatabase CreateRelationalDatabaseFromSnapshot CreateRelationalDatabaseSnapshot DeleteAlarm DeleteAutoSnapshot DeleteCertificate DeleteContactMethod DeleteContainerImage DeleteContainerService DeleteDisk DeleteDiskSnapshot DeleteDistribution DeleteDomain DeleteDomainEntry DeleteInstance DeleteInstanceSnapshot DeleteKeyPair DeleteKnownHostKeys DeleteLoadBalancer DeleteLoadBalancerTlsCertificate DeleteRelationalDatabase DeleteRelationalDatabaseSnapshot DetachCertificateFromDistribution DetachDisk DetachInstancesFromLoadBalancer DetachStaticIp DisableAddOn DownloadDefaultKeyPair EnableAddOn ExportSnapshot GetActiveNames GetAlarms GetAutoSnapshots GetBlueprints GetBundles GetCertificates GetCloudFormationStackRecords GetContactMethods GetContainerAPIMetadata GetContainerImages GetContainerLog GetContainerServiceDeployments GetContainerServiceMetricData GetContainerServicePowers GetContainerServices GetDisk GetDisks GetDiskSnapshot GetDiskSnapshots GetDistributionBundles GetDistributionLatestCacheReset GetDistributionMetricData GetDistributions GetDomain GetDomains GetExportSnapshotRecords GetInstance GetInstanceAccessDetails GetInstanceMetricData GetInstancePortStates GetInstances GetInstanceSnapshot GetInstanceSnapshots GetInstanceState GetKeyPair GetKeyPairs GetLoadBalancer GetLoadBalancerMetricData GetLoadBalancers GetLoadBalancerTlsCertificates GetOperation GetOperations GetOperationsForResource GetRegions GetRelationalDatabase GetRelationalDatabaseBlueprints GetRelationalDatabaseBundles GetRelationalDatabaseEvents GetRelationalDatabaseLogEvents GetRelationalDatabaseLogStreams GetRelationalDatabaseMasterUserPassword GetRelationalDatabaseMetricData GetRelationalDatabaseParameters GetRelationalDatabases GetRelationalDatabaseSnapshot GetRelationalDatabaseSnapshots GetStaticIp GetStaticIps ImportKeyPair IsVpcPeered OpenInstancePublicPorts PeerVpc PutAlarm PutInstancePublicPorts RebootInstance RebootRelationalDatabase RegisterContainerImage ReleaseStaticIp ResetDistributionCache SendContactMethodVerification SetIpAddressType StartInstance StartRelationalDatabase StopInstance StopRelationalDatabase TagResource TestAlarm UnpeerVpc UntagResource UpdateContainerService UpdateDistribution UpdateDistributionBundle UpdateDomainEntry UpdateLoadBalancerAttribute UpdateRelationalDatabase UpdateRelationalDatabaseParameters / }
1192  
1193 1;
1194  
1195 ### main pod documentation begin ###
1196  
1197 =head1 NAME
1198  
1199 Paws::Lightsail - Perl Interface to AWS Amazon Lightsail
1200  
1201 =head1 SYNOPSIS
1202  
1203 use Paws;
1204  
1205 my $obj = Paws->service('Lightsail');
1206 my $res = $obj->Method(
1207 Arg1 => $val1,
1208 Arg2 => [ 'V1', 'V2' ],
1209 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
1210 # of the arguments type
1211 Arg3 => { Att1 => 'Val1' },
1212 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
1213 # the constructor of the arguments type
1214 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
1215 );
1216  
1217 =head1 DESCRIPTION
1218  
1219 Amazon Lightsail is the easiest way to get started with Amazon Web
1220 Services (AWS) for developers who need to build websites or web
1221 applications. It includes everything you need to launch your project
1222 quickly - instances (virtual private servers), container services,
1223 managed databases, SSD-based block storage, static IP addresses, load
1224 balancers, content delivery network (CDN) distributions, DNS management
1225 of registered domains, and resource snapshots (backups) - for a low,
1226 predictable monthly price.
1227  
1228 You can manage your Lightsail resources using the Lightsail console,
1229 Lightsail API, AWS Command Line Interface (AWS CLI), or SDKs. For more
1230 information about Lightsail concepts and tasks, see the Lightsail Dev
1231 Guide
1232 (http://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-set-up-access-keys-to-use-sdk-api-cli).
1233  
1234 This API Reference provides detailed information about the actions,
1235 data types, parameters, and errors of the Lightsail service. For more
1236 information about the supported AWS Regions, endpoints, and service
1237 quotas of the Lightsail service, see Amazon Lightsail Endpoints and
1238 Quotas (https://docs.aws.amazon.com/general/latest/gr/lightsail.html)
1239 in the I<AWS General Reference>.
1240  
1241 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/lightsail-2016-11-28>
1242  
1243  
1244 =head1 METHODS
1245  
1246 =head2 AllocateStaticIp
1247  
1248 =over
1249  
1250 =item StaticIpName => Str
1251  
1252  
1253 =back
1254  
1255 Each argument is described in detail in: L<Paws::Lightsail::AllocateStaticIp>
1256  
1257 Returns: a L<Paws::Lightsail::AllocateStaticIpResult> instance
1258  
1259 Allocates a static IP address.
1260  
1261  
1262 =head2 AttachCertificateToDistribution
1263  
1264 =over
1265  
1266 =item CertificateName => Str
1267  
1268 =item DistributionName => Str
1269  
1270  
1271 =back
1272  
1273 Each argument is described in detail in: L<Paws::Lightsail::AttachCertificateToDistribution>
1274  
1275 Returns: a L<Paws::Lightsail::AttachCertificateToDistributionResult> instance
1276  
1277 Attaches an SSL/TLS certificate to your Amazon Lightsail content
1278 delivery network (CDN) distribution.
1279  
1280 After the certificate is attached, your distribution accepts HTTPS
1281 traffic for all of the domains that are associated with the
1282 certificate.
1283  
1284 Use the C<CreateCertificate> action to create a certificate that you
1285 can attach to your distribution.
1286  
1287 Only certificates created in the C<us-east-1> AWS Region can be
1288 attached to Lightsail distributions. Lightsail distributions are global
1289 resources that can reference an origin in any AWS Region, and
1290 distribute its content globally. However, all distributions are located
1291 in the C<us-east-1> Region.
1292  
1293  
1294 =head2 AttachDisk
1295  
1296 =over
1297  
1298 =item DiskName => Str
1299  
1300 =item DiskPath => Str
1301  
1302 =item InstanceName => Str
1303  
1304  
1305 =back
1306  
1307 Each argument is described in detail in: L<Paws::Lightsail::AttachDisk>
1308  
1309 Returns: a L<Paws::Lightsail::AttachDiskResult> instance
1310  
1311 Attaches a block storage disk to a running or stopped Lightsail
1312 instance and exposes it to the instance with the specified disk name.
1313  
1314 The C<attach disk> operation supports tag-based access control via
1315 resource tags applied to the resource identified by C<disk name>. For
1316 more information, see the Lightsail Dev Guide
1317 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1318  
1319  
1320 =head2 AttachInstancesToLoadBalancer
1321  
1322 =over
1323  
1324 =item InstanceNames => ArrayRef[Str|Undef]
1325  
1326 =item LoadBalancerName => Str
1327  
1328  
1329 =back
1330  
1331 Each argument is described in detail in: L<Paws::Lightsail::AttachInstancesToLoadBalancer>
1332  
1333 Returns: a L<Paws::Lightsail::AttachInstancesToLoadBalancerResult> instance
1334  
1335 Attaches one or more Lightsail instances to a load balancer.
1336  
1337 After some time, the instances are attached to the load balancer and
1338 the health check status is available.
1339  
1340 The C<attach instances to load balancer> operation supports tag-based
1341 access control via resource tags applied to the resource identified by
1342 C<load balancer name>. For more information, see the Lightsail Dev
1343 Guide
1344 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1345  
1346  
1347 =head2 AttachLoadBalancerTlsCertificate
1348  
1349 =over
1350  
1351 =item CertificateName => Str
1352  
1353 =item LoadBalancerName => Str
1354  
1355  
1356 =back
1357  
1358 Each argument is described in detail in: L<Paws::Lightsail::AttachLoadBalancerTlsCertificate>
1359  
1360 Returns: a L<Paws::Lightsail::AttachLoadBalancerTlsCertificateResult> instance
1361  
1362 Attaches a Transport Layer Security (TLS) certificate to your load
1363 balancer. TLS is just an updated, more secure version of Secure Socket
1364 Layer (SSL).
1365  
1366 Once you create and validate your certificate, you can attach it to
1367 your load balancer. You can also use this API to rotate the
1368 certificates on your account. Use the
1369 C<AttachLoadBalancerTlsCertificate> action with the non-attached
1370 certificate, and it will replace the existing one and become the
1371 attached certificate.
1372  
1373 The C<AttachLoadBalancerTlsCertificate> operation supports tag-based
1374 access control via resource tags applied to the resource identified by
1375 C<load balancer name>. For more information, see the Lightsail Dev
1376 Guide
1377 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1378  
1379  
1380 =head2 AttachStaticIp
1381  
1382 =over
1383  
1384 =item InstanceName => Str
1385  
1386 =item StaticIpName => Str
1387  
1388  
1389 =back
1390  
1391 Each argument is described in detail in: L<Paws::Lightsail::AttachStaticIp>
1392  
1393 Returns: a L<Paws::Lightsail::AttachStaticIpResult> instance
1394  
1395 Attaches a static IP address to a specific Amazon Lightsail instance.
1396  
1397  
1398 =head2 CloseInstancePublicPorts
1399  
1400 =over
1401  
1402 =item InstanceName => Str
1403  
1404 =item PortInfo => L<Paws::Lightsail::PortInfo>
1405  
1406  
1407 =back
1408  
1409 Each argument is described in detail in: L<Paws::Lightsail::CloseInstancePublicPorts>
1410  
1411 Returns: a L<Paws::Lightsail::CloseInstancePublicPortsResult> instance
1412  
1413 Closes ports for a specific Amazon Lightsail instance.
1414  
1415 The C<CloseInstancePublicPorts> action supports tag-based access
1416 control via resource tags applied to the resource identified by
1417 C<instanceName>. For more information, see the Lightsail Dev Guide
1418 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1419  
1420  
1421 =head2 CopySnapshot
1422  
1423 =over
1424  
1425 =item SourceRegion => Str
1426  
1427 =item TargetSnapshotName => Str
1428  
1429 =item [RestoreDate => Str]
1430  
1431 =item [SourceResourceName => Str]
1432  
1433 =item [SourceSnapshotName => Str]
1434  
1435 =item [UseLatestRestorableAutoSnapshot => Bool]
1436  
1437  
1438 =back
1439  
1440 Each argument is described in detail in: L<Paws::Lightsail::CopySnapshot>
1441  
1442 Returns: a L<Paws::Lightsail::CopySnapshotResult> instance
1443  
1444 Copies a manual snapshot of an instance or disk as another manual
1445 snapshot, or copies an automatic snapshot of an instance or disk as a
1446 manual snapshot. This operation can also be used to copy a manual or
1447 automatic snapshot of an instance or a disk from one AWS Region to
1448 another in Amazon Lightsail.
1449  
1450 When copying a I<manual snapshot>, be sure to define the C<source
1451 region>, C<source snapshot name>, and C<target snapshot name>
1452 parameters.
1453  
1454 When copying an I<automatic snapshot>, be sure to define the C<source
1455 region>, C<source resource name>, C<target snapshot name>, and either
1456 the C<restore date> or the C<use latest restorable auto snapshot>
1457 parameters.
1458  
1459  
1460 =head2 CreateCertificate
1461  
1462 =over
1463  
1464 =item CertificateName => Str
1465  
1466 =item DomainName => Str
1467  
1468 =item [SubjectAlternativeNames => ArrayRef[Str|Undef]]
1469  
1470 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1471  
1472  
1473 =back
1474  
1475 Each argument is described in detail in: L<Paws::Lightsail::CreateCertificate>
1476  
1477 Returns: a L<Paws::Lightsail::CreateCertificateResult> instance
1478  
1479 Creates an SSL/TLS certificate for an Amazon Lightsail content delivery
1480 network (CDN) distribution and a container service.
1481  
1482 After the certificate is valid, use the
1483 C<AttachCertificateToDistribution> action to use the certificate and
1484 its domains with your distribution. Or use the
1485 C<UpdateContainerService> action to use the certificate and its domains
1486 with your container service.
1487  
1488 Only certificates created in the C<us-east-1> AWS Region can be
1489 attached to Lightsail distributions. Lightsail distributions are global
1490 resources that can reference an origin in any AWS Region, and
1491 distribute its content globally. However, all distributions are located
1492 in the C<us-east-1> Region.
1493  
1494  
1495 =head2 CreateCloudFormationStack
1496  
1497 =over
1498  
1499 =item Instances => ArrayRef[L<Paws::Lightsail::InstanceEntry>]
1500  
1501  
1502 =back
1503  
1504 Each argument is described in detail in: L<Paws::Lightsail::CreateCloudFormationStack>
1505  
1506 Returns: a L<Paws::Lightsail::CreateCloudFormationStackResult> instance
1507  
1508 Creates an AWS CloudFormation stack, which creates a new Amazon EC2
1509 instance from an exported Amazon Lightsail snapshot. This operation
1510 results in a CloudFormation stack record that can be used to track the
1511 AWS CloudFormation stack created. Use the C<get cloud formation stack
1512 records> operation to get a list of the CloudFormation stacks created.
1513  
1514 Wait until after your new Amazon EC2 instance is created before running
1515 the C<create cloud formation stack> operation again with the same
1516 export snapshot record.
1517  
1518  
1519 =head2 CreateContactMethod
1520  
1521 =over
1522  
1523 =item ContactEndpoint => Str
1524  
1525 =item Protocol => Str
1526  
1527  
1528 =back
1529  
1530 Each argument is described in detail in: L<Paws::Lightsail::CreateContactMethod>
1531  
1532 Returns: a L<Paws::Lightsail::CreateContactMethodResult> instance
1533  
1534 Creates an email or SMS text message contact method.
1535  
1536 A contact method is used to send you notifications about your Amazon
1537 Lightsail resources. You can add one email address and one mobile phone
1538 number contact method in each AWS Region. However, SMS text messaging
1539 is not supported in some AWS Regions, and SMS text messages cannot be
1540 sent to some countries/regions. For more information, see Notifications
1541 in Amazon Lightsail
1542 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications).
1543  
1544  
1545 =head2 CreateContainerService
1546  
1547 =over
1548  
1549 =item Power => Str
1550  
1551 =item Scale => Int
1552  
1553 =item ServiceName => Str
1554  
1555 =item [Deployment => L<Paws::Lightsail::ContainerServiceDeploymentRequest>]
1556  
1557 =item [PublicDomainNames => L<Paws::Lightsail::ContainerServicePublicDomains>]
1558  
1559 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1560  
1561  
1562 =back
1563  
1564 Each argument is described in detail in: L<Paws::Lightsail::CreateContainerService>
1565  
1566 Returns: a L<Paws::Lightsail::CreateContainerServiceResult> instance
1567  
1568 Creates an Amazon Lightsail container service.
1569  
1570 A Lightsail container service is a compute resource to which you can
1571 deploy containers. For more information, see Container services in
1572 Amazon Lightsail
1573 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-container-services)
1574 in the I<Lightsail Dev Guide>.
1575  
1576  
1577 =head2 CreateContainerServiceDeployment
1578  
1579 =over
1580  
1581 =item ServiceName => Str
1582  
1583 =item [Containers => L<Paws::Lightsail::ContainerMap>]
1584  
1585 =item [PublicEndpoint => L<Paws::Lightsail::EndpointRequest>]
1586  
1587  
1588 =back
1589  
1590 Each argument is described in detail in: L<Paws::Lightsail::CreateContainerServiceDeployment>
1591  
1592 Returns: a L<Paws::Lightsail::CreateContainerServiceDeploymentResult> instance
1593  
1594 Creates a deployment for your Amazon Lightsail container service.
1595  
1596 A deployment specifies the containers that will be launched on the
1597 container service and their settings, such as the ports to open, the
1598 environment variables to apply, and the launch command to run. It also
1599 specifies the container that will serve as the public endpoint of the
1600 deployment and its settings, such as the HTTP or HTTPS port to use, and
1601 the health check configuration.
1602  
1603 You can deploy containers to your container service using container
1604 images from a public registry like Docker Hub, or from your local
1605 machine. For more information, see Creating container images for your
1606 Amazon Lightsail container services
1607 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-creating-container-images)
1608 in the I<Lightsail Dev Guide>.
1609  
1610  
1611 =head2 CreateContainerServiceRegistryLogin
1612  
1613  
1614  
1615  
1616  
1617  
1618 Each argument is described in detail in: L<Paws::Lightsail::CreateContainerServiceRegistryLogin>
1619  
1620 Returns: a L<Paws::Lightsail::CreateContainerServiceRegistryLoginResult> instance
1621  
1622 Creates a temporary set of log in credentials that you can use to log
1623 in to the Docker process on your local machine. After you're logged in,
1624 you can use the native Docker commands to push your local container
1625 images to the container image registry of your Amazon Lightsail account
1626 so that you can use them with your Lightsail container service. The log
1627 in credentials expire 12 hours after they are created, at which point
1628 you will need to create a new set of log in credentials.
1629  
1630 You can only push container images to the container service registry of
1631 your Lightsail account. You cannot pull container images or perform any
1632 other container image management actions on the container service
1633 registry.
1634  
1635 After you push your container images to the container image registry of
1636 your Lightsail account, use the C<RegisterContainerImage> action to
1637 register the pushed images to a specific Lightsail container service.
1638  
1639 This action is not required if you install and use the Lightsail
1640 Control (lightsailctl) plugin to push container images to your
1641 Lightsail container service. For more information, see Pushing and
1642 managing container images on your Amazon Lightsail container services
1643 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-pushing-container-images)
1644 in the I<Lightsail Dev Guide>.
1645  
1646  
1647 =head2 CreateDisk
1648  
1649 =over
1650  
1651 =item AvailabilityZone => Str
1652  
1653 =item DiskName => Str
1654  
1655 =item SizeInGb => Int
1656  
1657 =item [AddOns => ArrayRef[L<Paws::Lightsail::AddOnRequest>]]
1658  
1659 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1660  
1661  
1662 =back
1663  
1664 Each argument is described in detail in: L<Paws::Lightsail::CreateDisk>
1665  
1666 Returns: a L<Paws::Lightsail::CreateDiskResult> instance
1667  
1668 Creates a block storage disk that can be attached to an Amazon
1669 Lightsail instance in the same Availability Zone (e.g., C<us-east-2a>).
1670  
1671 The C<create disk> operation supports tag-based access control via
1672 request tags. For more information, see the Lightsail Dev Guide
1673 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1674  
1675  
1676 =head2 CreateDiskFromSnapshot
1677  
1678 =over
1679  
1680 =item AvailabilityZone => Str
1681  
1682 =item DiskName => Str
1683  
1684 =item SizeInGb => Int
1685  
1686 =item [AddOns => ArrayRef[L<Paws::Lightsail::AddOnRequest>]]
1687  
1688 =item [DiskSnapshotName => Str]
1689  
1690 =item [RestoreDate => Str]
1691  
1692 =item [SourceDiskName => Str]
1693  
1694 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1695  
1696 =item [UseLatestRestorableAutoSnapshot => Bool]
1697  
1698  
1699 =back
1700  
1701 Each argument is described in detail in: L<Paws::Lightsail::CreateDiskFromSnapshot>
1702  
1703 Returns: a L<Paws::Lightsail::CreateDiskFromSnapshotResult> instance
1704  
1705 Creates a block storage disk from a manual or automatic snapshot of a
1706 disk. The resulting disk can be attached to an Amazon Lightsail
1707 instance in the same Availability Zone (e.g., C<us-east-2a>).
1708  
1709 The C<create disk from snapshot> operation supports tag-based access
1710 control via request tags and resource tags applied to the resource
1711 identified by C<disk snapshot name>. For more information, see the
1712 Lightsail Dev Guide
1713 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1714  
1715  
1716 =head2 CreateDiskSnapshot
1717  
1718 =over
1719  
1720 =item DiskSnapshotName => Str
1721  
1722 =item [DiskName => Str]
1723  
1724 =item [InstanceName => Str]
1725  
1726 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1727  
1728  
1729 =back
1730  
1731 Each argument is described in detail in: L<Paws::Lightsail::CreateDiskSnapshot>
1732  
1733 Returns: a L<Paws::Lightsail::CreateDiskSnapshotResult> instance
1734  
1735 Creates a snapshot of a block storage disk. You can use snapshots for
1736 backups, to make copies of disks, and to save data before shutting down
1737 a Lightsail instance.
1738  
1739 You can take a snapshot of an attached disk that is in use; however,
1740 snapshots only capture data that has been written to your disk at the
1741 time the snapshot command is issued. This may exclude any data that has
1742 been cached by any applications or the operating system. If you can
1743 pause any file systems on the disk long enough to take a snapshot, your
1744 snapshot should be complete. Nevertheless, if you cannot pause all file
1745 writes to the disk, you should unmount the disk from within the
1746 Lightsail instance, issue the create disk snapshot command, and then
1747 remount the disk to ensure a consistent and complete snapshot. You may
1748 remount and use your disk while the snapshot status is pending.
1749  
1750 You can also use this operation to create a snapshot of an instance's
1751 system volume. You might want to do this, for example, to recover data
1752 from the system volume of a botched instance or to create a backup of
1753 the system volume like you would for a block storage disk. To create a
1754 snapshot of a system volume, just define the C<instance name> parameter
1755 when issuing the snapshot command, and a snapshot of the defined
1756 instance's system volume will be created. After the snapshot is
1757 available, you can create a block storage disk from the snapshot and
1758 attach it to a running instance to access the data on the disk.
1759  
1760 The C<create disk snapshot> operation supports tag-based access control
1761 via request tags. For more information, see the Lightsail Dev Guide
1762 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1763  
1764  
1765 =head2 CreateDistribution
1766  
1767 =over
1768  
1769 =item BundleId => Str
1770  
1771 =item DefaultCacheBehavior => L<Paws::Lightsail::CacheBehavior>
1772  
1773 =item DistributionName => Str
1774  
1775 =item Origin => L<Paws::Lightsail::InputOrigin>
1776  
1777 =item [CacheBehaviors => ArrayRef[L<Paws::Lightsail::CacheBehaviorPerPath>]]
1778  
1779 =item [CacheBehaviorSettings => L<Paws::Lightsail::CacheSettings>]
1780  
1781 =item [IpAddressType => Str]
1782  
1783 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1784  
1785  
1786 =back
1787  
1788 Each argument is described in detail in: L<Paws::Lightsail::CreateDistribution>
1789  
1790 Returns: a L<Paws::Lightsail::CreateDistributionResult> instance
1791  
1792 Creates an Amazon Lightsail content delivery network (CDN)
1793 distribution.
1794  
1795 A distribution is a globally distributed network of caching servers
1796 that improve the performance of your website or web application hosted
1797 on a Lightsail instance. For more information, see Content delivery
1798 networks in Amazon Lightsail
1799 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-content-delivery-network-distributions).
1800  
1801  
1802 =head2 CreateDomain
1803  
1804 =over
1805  
1806 =item DomainName => Str
1807  
1808 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1809  
1810  
1811 =back
1812  
1813 Each argument is described in detail in: L<Paws::Lightsail::CreateDomain>
1814  
1815 Returns: a L<Paws::Lightsail::CreateDomainResult> instance
1816  
1817 Creates a domain resource for the specified domain (e.g., example.com).
1818  
1819 The C<create domain> operation supports tag-based access control via
1820 request tags. For more information, see the Lightsail Dev Guide
1821 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1822  
1823  
1824 =head2 CreateDomainEntry
1825  
1826 =over
1827  
1828 =item DomainEntry => L<Paws::Lightsail::DomainEntry>
1829  
1830 =item DomainName => Str
1831  
1832  
1833 =back
1834  
1835 Each argument is described in detail in: L<Paws::Lightsail::CreateDomainEntry>
1836  
1837 Returns: a L<Paws::Lightsail::CreateDomainEntryResult> instance
1838  
1839 Creates one of the following domain name system (DNS) records in a
1840 domain DNS zone: Address (A), canonical name (CNAME), mail exchanger
1841 (MX), name server (NS), start of authority (SOA), service locator
1842 (SRV), or text (TXT).
1843  
1844 The C<create domain entry> operation supports tag-based access control
1845 via resource tags applied to the resource identified by C<domain name>.
1846 For more information, see the Lightsail Dev Guide
1847 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1848  
1849  
1850 =head2 CreateInstances
1851  
1852 =over
1853  
1854 =item AvailabilityZone => Str
1855  
1856 =item BlueprintId => Str
1857  
1858 =item BundleId => Str
1859  
1860 =item InstanceNames => ArrayRef[Str|Undef]
1861  
1862 =item [AddOns => ArrayRef[L<Paws::Lightsail::AddOnRequest>]]
1863  
1864 =item [CustomImageName => Str]
1865  
1866 =item [IpAddressType => Str]
1867  
1868 =item [KeyPairName => Str]
1869  
1870 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1871  
1872 =item [UserData => Str]
1873  
1874  
1875 =back
1876  
1877 Each argument is described in detail in: L<Paws::Lightsail::CreateInstances>
1878  
1879 Returns: a L<Paws::Lightsail::CreateInstancesResult> instance
1880  
1881 Creates one or more Amazon Lightsail instances.
1882  
1883 The C<create instances> operation supports tag-based access control via
1884 request tags. For more information, see the Lightsail Dev Guide
1885 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1886  
1887  
1888 =head2 CreateInstancesFromSnapshot
1889  
1890 =over
1891  
1892 =item AvailabilityZone => Str
1893  
1894 =item BundleId => Str
1895  
1896 =item InstanceNames => ArrayRef[Str|Undef]
1897  
1898 =item [AddOns => ArrayRef[L<Paws::Lightsail::AddOnRequest>]]
1899  
1900 =item [AttachedDiskMapping => L<Paws::Lightsail::AttachedDiskMap>]
1901  
1902 =item [InstanceSnapshotName => Str]
1903  
1904 =item [IpAddressType => Str]
1905  
1906 =item [KeyPairName => Str]
1907  
1908 =item [RestoreDate => Str]
1909  
1910 =item [SourceInstanceName => Str]
1911  
1912 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1913  
1914 =item [UseLatestRestorableAutoSnapshot => Bool]
1915  
1916 =item [UserData => Str]
1917  
1918  
1919 =back
1920  
1921 Each argument is described in detail in: L<Paws::Lightsail::CreateInstancesFromSnapshot>
1922  
1923 Returns: a L<Paws::Lightsail::CreateInstancesFromSnapshotResult> instance
1924  
1925 Creates one or more new instances from a manual or automatic snapshot
1926 of an instance.
1927  
1928 The C<create instances from snapshot> operation supports tag-based
1929 access control via request tags and resource tags applied to the
1930 resource identified by C<instance snapshot name>. For more information,
1931 see the Lightsail Dev Guide
1932 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1933  
1934  
1935 =head2 CreateInstanceSnapshot
1936  
1937 =over
1938  
1939 =item InstanceName => Str
1940  
1941 =item InstanceSnapshotName => Str
1942  
1943 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1944  
1945  
1946 =back
1947  
1948 Each argument is described in detail in: L<Paws::Lightsail::CreateInstanceSnapshot>
1949  
1950 Returns: a L<Paws::Lightsail::CreateInstanceSnapshotResult> instance
1951  
1952 Creates a snapshot of a specific virtual private server, or
1953 I<instance>. You can use a snapshot to create a new instance that is
1954 based on that snapshot.
1955  
1956 The C<create instance snapshot> operation supports tag-based access
1957 control via request tags. For more information, see the Lightsail Dev
1958 Guide
1959 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1960  
1961  
1962 =head2 CreateKeyPair
1963  
1964 =over
1965  
1966 =item KeyPairName => Str
1967  
1968 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
1969  
1970  
1971 =back
1972  
1973 Each argument is described in detail in: L<Paws::Lightsail::CreateKeyPair>
1974  
1975 Returns: a L<Paws::Lightsail::CreateKeyPairResult> instance
1976  
1977 Creates an SSH key pair.
1978  
1979 The C<create key pair> operation supports tag-based access control via
1980 request tags. For more information, see the Lightsail Dev Guide
1981 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
1982  
1983  
1984 =head2 CreateLoadBalancer
1985  
1986 =over
1987  
1988 =item InstancePort => Int
1989  
1990 =item LoadBalancerName => Str
1991  
1992 =item [CertificateAlternativeNames => ArrayRef[Str|Undef]]
1993  
1994 =item [CertificateDomainName => Str]
1995  
1996 =item [CertificateName => Str]
1997  
1998 =item [HealthCheckPath => Str]
1999  
2000 =item [IpAddressType => Str]
2001  
2002 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
2003  
2004  
2005 =back
2006  
2007 Each argument is described in detail in: L<Paws::Lightsail::CreateLoadBalancer>
2008  
2009 Returns: a L<Paws::Lightsail::CreateLoadBalancerResult> instance
2010  
2011 Creates a Lightsail load balancer. To learn more about deciding whether
2012 to load balance your application, see Configure your Lightsail
2013 instances for load balancing
2014 (https://lightsail.aws.amazon.com/ls/docs/how-to/article/configure-lightsail-instances-for-load-balancing).
2015 You can create up to 5 load balancers per AWS Region in your account.
2016  
2017 When you create a load balancer, you can specify a unique name and port
2018 settings. To change additional load balancer settings, use the
2019 C<UpdateLoadBalancerAttribute> operation.
2020  
2021 The C<create load balancer> operation supports tag-based access control
2022 via request tags. For more information, see the Lightsail Dev Guide
2023 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2024  
2025  
2026 =head2 CreateLoadBalancerTlsCertificate
2027  
2028 =over
2029  
2030 =item CertificateDomainName => Str
2031  
2032 =item CertificateName => Str
2033  
2034 =item LoadBalancerName => Str
2035  
2036 =item [CertificateAlternativeNames => ArrayRef[Str|Undef]]
2037  
2038 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
2039  
2040  
2041 =back
2042  
2043 Each argument is described in detail in: L<Paws::Lightsail::CreateLoadBalancerTlsCertificate>
2044  
2045 Returns: a L<Paws::Lightsail::CreateLoadBalancerTlsCertificateResult> instance
2046  
2047 Creates an SSL/TLS certificate for an Amazon Lightsail load balancer.
2048  
2049 TLS is just an updated, more secure version of Secure Socket Layer
2050 (SSL).
2051  
2052 The C<CreateLoadBalancerTlsCertificate> operation supports tag-based
2053 access control via resource tags applied to the resource identified by
2054 C<load balancer name>. For more information, see the Lightsail Dev
2055 Guide
2056 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2057  
2058  
2059 =head2 CreateRelationalDatabase
2060  
2061 =over
2062  
2063 =item MasterDatabaseName => Str
2064  
2065 =item MasterUsername => Str
2066  
2067 =item RelationalDatabaseBlueprintId => Str
2068  
2069 =item RelationalDatabaseBundleId => Str
2070  
2071 =item RelationalDatabaseName => Str
2072  
2073 =item [AvailabilityZone => Str]
2074  
2075 =item [MasterUserPassword => Str]
2076  
2077 =item [PreferredBackupWindow => Str]
2078  
2079 =item [PreferredMaintenanceWindow => Str]
2080  
2081 =item [PubliclyAccessible => Bool]
2082  
2083 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
2084  
2085  
2086 =back
2087  
2088 Each argument is described in detail in: L<Paws::Lightsail::CreateRelationalDatabase>
2089  
2090 Returns: a L<Paws::Lightsail::CreateRelationalDatabaseResult> instance
2091  
2092 Creates a new database in Amazon Lightsail.
2093  
2094 The C<create relational database> operation supports tag-based access
2095 control via request tags. For more information, see the Lightsail Dev
2096 Guide
2097 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2098  
2099  
2100 =head2 CreateRelationalDatabaseFromSnapshot
2101  
2102 =over
2103  
2104 =item RelationalDatabaseName => Str
2105  
2106 =item [AvailabilityZone => Str]
2107  
2108 =item [PubliclyAccessible => Bool]
2109  
2110 =item [RelationalDatabaseBundleId => Str]
2111  
2112 =item [RelationalDatabaseSnapshotName => Str]
2113  
2114 =item [RestoreTime => Str]
2115  
2116 =item [SourceRelationalDatabaseName => Str]
2117  
2118 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
2119  
2120 =item [UseLatestRestorableTime => Bool]
2121  
2122  
2123 =back
2124  
2125 Each argument is described in detail in: L<Paws::Lightsail::CreateRelationalDatabaseFromSnapshot>
2126  
2127 Returns: a L<Paws::Lightsail::CreateRelationalDatabaseFromSnapshotResult> instance
2128  
2129 Creates a new database from an existing database snapshot in Amazon
2130 Lightsail.
2131  
2132 You can create a new database from a snapshot in if something goes
2133 wrong with your original database, or to change it to a different plan,
2134 such as a high availability or standard plan.
2135  
2136 The C<create relational database from snapshot> operation supports
2137 tag-based access control via request tags and resource tags applied to
2138 the resource identified by relationalDatabaseSnapshotName. For more
2139 information, see the Lightsail Dev Guide
2140 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2141  
2142  
2143 =head2 CreateRelationalDatabaseSnapshot
2144  
2145 =over
2146  
2147 =item RelationalDatabaseName => Str
2148  
2149 =item RelationalDatabaseSnapshotName => Str
2150  
2151 =item [Tags => ArrayRef[L<Paws::Lightsail::Tag>]]
2152  
2153  
2154 =back
2155  
2156 Each argument is described in detail in: L<Paws::Lightsail::CreateRelationalDatabaseSnapshot>
2157  
2158 Returns: a L<Paws::Lightsail::CreateRelationalDatabaseSnapshotResult> instance
2159  
2160 Creates a snapshot of your database in Amazon Lightsail. You can use
2161 snapshots for backups, to make copies of a database, and to save data
2162 before deleting a database.
2163  
2164 The C<create relational database snapshot> operation supports tag-based
2165 access control via request tags. For more information, see the
2166 Lightsail Dev Guide
2167 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2168  
2169  
2170 =head2 DeleteAlarm
2171  
2172 =over
2173  
2174 =item AlarmName => Str
2175  
2176  
2177 =back
2178  
2179 Each argument is described in detail in: L<Paws::Lightsail::DeleteAlarm>
2180  
2181 Returns: a L<Paws::Lightsail::DeleteAlarmResult> instance
2182  
2183 Deletes an alarm.
2184  
2185 An alarm is used to monitor a single metric for one of your resources.
2186 When a metric condition is met, the alarm can notify you by email, SMS
2187 text message, and a banner displayed on the Amazon Lightsail console.
2188 For more information, see Alarms in Amazon Lightsail
2189 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).
2190  
2191  
2192 =head2 DeleteAutoSnapshot
2193  
2194 =over
2195  
2196 =item Date => Str
2197  
2198 =item ResourceName => Str
2199  
2200  
2201 =back
2202  
2203 Each argument is described in detail in: L<Paws::Lightsail::DeleteAutoSnapshot>
2204  
2205 Returns: a L<Paws::Lightsail::DeleteAutoSnapshotResult> instance
2206  
2207 Deletes an automatic snapshot of an instance or disk. For more
2208 information, see the Lightsail Dev Guide
2209 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots).
2210  
2211  
2212 =head2 DeleteCertificate
2213  
2214 =over
2215  
2216 =item CertificateName => Str
2217  
2218  
2219 =back
2220  
2221 Each argument is described in detail in: L<Paws::Lightsail::DeleteCertificate>
2222  
2223 Returns: a L<Paws::Lightsail::DeleteCertificateResult> instance
2224  
2225 Deletes an SSL/TLS certificate for your Amazon Lightsail content
2226 delivery network (CDN) distribution.
2227  
2228 Certificates that are currently attached to a distribution cannot be
2229 deleted. Use the C<DetachCertificateFromDistribution> action to detach
2230 a certificate from a distribution.
2231  
2232  
2233 =head2 DeleteContactMethod
2234  
2235 =over
2236  
2237 =item Protocol => Str
2238  
2239  
2240 =back
2241  
2242 Each argument is described in detail in: L<Paws::Lightsail::DeleteContactMethod>
2243  
2244 Returns: a L<Paws::Lightsail::DeleteContactMethodResult> instance
2245  
2246 Deletes a contact method.
2247  
2248 A contact method is used to send you notifications about your Amazon
2249 Lightsail resources. You can add one email address and one mobile phone
2250 number contact method in each AWS Region. However, SMS text messaging
2251 is not supported in some AWS Regions, and SMS text messages cannot be
2252 sent to some countries/regions. For more information, see Notifications
2253 in Amazon Lightsail
2254 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications).
2255  
2256  
2257 =head2 DeleteContainerImage
2258  
2259 =over
2260  
2261 =item Image => Str
2262  
2263 =item ServiceName => Str
2264  
2265  
2266 =back
2267  
2268 Each argument is described in detail in: L<Paws::Lightsail::DeleteContainerImage>
2269  
2270 Returns: a L<Paws::Lightsail::DeleteContainerImageResult> instance
2271  
2272 Deletes a container image that is registered to your Amazon Lightsail
2273 container service.
2274  
2275  
2276 =head2 DeleteContainerService
2277  
2278 =over
2279  
2280 =item ServiceName => Str
2281  
2282  
2283 =back
2284  
2285 Each argument is described in detail in: L<Paws::Lightsail::DeleteContainerService>
2286  
2287 Returns: a L<Paws::Lightsail::DeleteContainerServiceResult> instance
2288  
2289 Deletes your Amazon Lightsail container service.
2290  
2291  
2292 =head2 DeleteDisk
2293  
2294 =over
2295  
2296 =item DiskName => Str
2297  
2298 =item [ForceDeleteAddOns => Bool]
2299  
2300  
2301 =back
2302  
2303 Each argument is described in detail in: L<Paws::Lightsail::DeleteDisk>
2304  
2305 Returns: a L<Paws::Lightsail::DeleteDiskResult> instance
2306  
2307 Deletes the specified block storage disk. The disk must be in the
2308 C<available> state (not attached to a Lightsail instance).
2309  
2310 The disk may remain in the C<deleting> state for several minutes.
2311  
2312 The C<delete disk> operation supports tag-based access control via
2313 resource tags applied to the resource identified by C<disk name>. For
2314 more information, see the Lightsail Dev Guide
2315 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2316  
2317  
2318 =head2 DeleteDiskSnapshot
2319  
2320 =over
2321  
2322 =item DiskSnapshotName => Str
2323  
2324  
2325 =back
2326  
2327 Each argument is described in detail in: L<Paws::Lightsail::DeleteDiskSnapshot>
2328  
2329 Returns: a L<Paws::Lightsail::DeleteDiskSnapshotResult> instance
2330  
2331 Deletes the specified disk snapshot.
2332  
2333 When you make periodic snapshots of a disk, the snapshots are
2334 incremental, and only the blocks on the device that have changed since
2335 your last snapshot are saved in the new snapshot. When you delete a
2336 snapshot, only the data not needed for any other snapshot is removed.
2337 So regardless of which prior snapshots have been deleted, all active
2338 snapshots will have access to all the information needed to restore the
2339 disk.
2340  
2341 The C<delete disk snapshot> operation supports tag-based access control
2342 via resource tags applied to the resource identified by C<disk snapshot
2343 name>. For more information, see the Lightsail Dev Guide
2344 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2345  
2346  
2347 =head2 DeleteDistribution
2348  
2349 =over
2350  
2351 =item [DistributionName => Str]
2352  
2353  
2354 =back
2355  
2356 Each argument is described in detail in: L<Paws::Lightsail::DeleteDistribution>
2357  
2358 Returns: a L<Paws::Lightsail::DeleteDistributionResult> instance
2359  
2360 Deletes your Amazon Lightsail content delivery network (CDN)
2361 distribution.
2362  
2363  
2364 =head2 DeleteDomain
2365  
2366 =over
2367  
2368 =item DomainName => Str
2369  
2370  
2371 =back
2372  
2373 Each argument is described in detail in: L<Paws::Lightsail::DeleteDomain>
2374  
2375 Returns: a L<Paws::Lightsail::DeleteDomainResult> instance
2376  
2377 Deletes the specified domain recordset and all of its domain records.
2378  
2379 The C<delete domain> operation supports tag-based access control via
2380 resource tags applied to the resource identified by C<domain name>. For
2381 more information, see the Lightsail Dev Guide
2382 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2383  
2384  
2385 =head2 DeleteDomainEntry
2386  
2387 =over
2388  
2389 =item DomainEntry => L<Paws::Lightsail::DomainEntry>
2390  
2391 =item DomainName => Str
2392  
2393  
2394 =back
2395  
2396 Each argument is described in detail in: L<Paws::Lightsail::DeleteDomainEntry>
2397  
2398 Returns: a L<Paws::Lightsail::DeleteDomainEntryResult> instance
2399  
2400 Deletes a specific domain entry.
2401  
2402 The C<delete domain entry> operation supports tag-based access control
2403 via resource tags applied to the resource identified by C<domain name>.
2404 For more information, see the Lightsail Dev Guide
2405 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2406  
2407  
2408 =head2 DeleteInstance
2409  
2410 =over
2411  
2412 =item InstanceName => Str
2413  
2414 =item [ForceDeleteAddOns => Bool]
2415  
2416  
2417 =back
2418  
2419 Each argument is described in detail in: L<Paws::Lightsail::DeleteInstance>
2420  
2421 Returns: a L<Paws::Lightsail::DeleteInstanceResult> instance
2422  
2423 Deletes an Amazon Lightsail instance.
2424  
2425 The C<delete instance> operation supports tag-based access control via
2426 resource tags applied to the resource identified by C<instance name>.
2427 For more information, see the Lightsail Dev Guide
2428 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2429  
2430  
2431 =head2 DeleteInstanceSnapshot
2432  
2433 =over
2434  
2435 =item InstanceSnapshotName => Str
2436  
2437  
2438 =back
2439  
2440 Each argument is described in detail in: L<Paws::Lightsail::DeleteInstanceSnapshot>
2441  
2442 Returns: a L<Paws::Lightsail::DeleteInstanceSnapshotResult> instance
2443  
2444 Deletes a specific snapshot of a virtual private server (or
2445 I<instance>).
2446  
2447 The C<delete instance snapshot> operation supports tag-based access
2448 control via resource tags applied to the resource identified by
2449 C<instance snapshot name>. For more information, see the Lightsail Dev
2450 Guide
2451 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2452  
2453  
2454 =head2 DeleteKeyPair
2455  
2456 =over
2457  
2458 =item KeyPairName => Str
2459  
2460  
2461 =back
2462  
2463 Each argument is described in detail in: L<Paws::Lightsail::DeleteKeyPair>
2464  
2465 Returns: a L<Paws::Lightsail::DeleteKeyPairResult> instance
2466  
2467 Deletes a specific SSH key pair.
2468  
2469 The C<delete key pair> operation supports tag-based access control via
2470 resource tags applied to the resource identified by C<key pair name>.
2471 For more information, see the Lightsail Dev Guide
2472 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2473  
2474  
2475 =head2 DeleteKnownHostKeys
2476  
2477 =over
2478  
2479 =item InstanceName => Str
2480  
2481  
2482 =back
2483  
2484 Each argument is described in detail in: L<Paws::Lightsail::DeleteKnownHostKeys>
2485  
2486 Returns: a L<Paws::Lightsail::DeleteKnownHostKeysResult> instance
2487  
2488 Deletes the known host key or certificate used by the Amazon Lightsail
2489 browser-based SSH or RDP clients to authenticate an instance. This
2490 operation enables the Lightsail browser-based SSH or RDP clients to
2491 connect to the instance after a host key mismatch.
2492  
2493 Perform this operation only if you were expecting the host key or
2494 certificate mismatch or if you are familiar with the new host key or
2495 certificate on the instance. For more information, see Troubleshooting
2496 connection issues when using the Amazon Lightsail browser-based SSH or
2497 RDP client
2498 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-troubleshooting-browser-based-ssh-rdp-client-connection).
2499  
2500  
2501 =head2 DeleteLoadBalancer
2502  
2503 =over
2504  
2505 =item LoadBalancerName => Str
2506  
2507  
2508 =back
2509  
2510 Each argument is described in detail in: L<Paws::Lightsail::DeleteLoadBalancer>
2511  
2512 Returns: a L<Paws::Lightsail::DeleteLoadBalancerResult> instance
2513  
2514 Deletes a Lightsail load balancer and all its associated SSL/TLS
2515 certificates. Once the load balancer is deleted, you will need to
2516 create a new load balancer, create a new certificate, and verify domain
2517 ownership again.
2518  
2519 The C<delete load balancer> operation supports tag-based access control
2520 via resource tags applied to the resource identified by C<load balancer
2521 name>. For more information, see the Lightsail Dev Guide
2522 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2523  
2524  
2525 =head2 DeleteLoadBalancerTlsCertificate
2526  
2527 =over
2528  
2529 =item CertificateName => Str
2530  
2531 =item LoadBalancerName => Str
2532  
2533 =item [Force => Bool]
2534  
2535  
2536 =back
2537  
2538 Each argument is described in detail in: L<Paws::Lightsail::DeleteLoadBalancerTlsCertificate>
2539  
2540 Returns: a L<Paws::Lightsail::DeleteLoadBalancerTlsCertificateResult> instance
2541  
2542 Deletes an SSL/TLS certificate associated with a Lightsail load
2543 balancer.
2544  
2545 The C<DeleteLoadBalancerTlsCertificate> operation supports tag-based
2546 access control via resource tags applied to the resource identified by
2547 C<load balancer name>. For more information, see the Lightsail Dev
2548 Guide
2549 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2550  
2551  
2552 =head2 DeleteRelationalDatabase
2553  
2554 =over
2555  
2556 =item RelationalDatabaseName => Str
2557  
2558 =item [FinalRelationalDatabaseSnapshotName => Str]
2559  
2560 =item [SkipFinalSnapshot => Bool]
2561  
2562  
2563 =back
2564  
2565 Each argument is described in detail in: L<Paws::Lightsail::DeleteRelationalDatabase>
2566  
2567 Returns: a L<Paws::Lightsail::DeleteRelationalDatabaseResult> instance
2568  
2569 Deletes a database in Amazon Lightsail.
2570  
2571 The C<delete relational database> operation supports tag-based access
2572 control via resource tags applied to the resource identified by
2573 relationalDatabaseName. For more information, see the Lightsail Dev
2574 Guide
2575 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2576  
2577  
2578 =head2 DeleteRelationalDatabaseSnapshot
2579  
2580 =over
2581  
2582 =item RelationalDatabaseSnapshotName => Str
2583  
2584  
2585 =back
2586  
2587 Each argument is described in detail in: L<Paws::Lightsail::DeleteRelationalDatabaseSnapshot>
2588  
2589 Returns: a L<Paws::Lightsail::DeleteRelationalDatabaseSnapshotResult> instance
2590  
2591 Deletes a database snapshot in Amazon Lightsail.
2592  
2593 The C<delete relational database snapshot> operation supports tag-based
2594 access control via resource tags applied to the resource identified by
2595 relationalDatabaseName. For more information, see the Lightsail Dev
2596 Guide
2597 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2598  
2599  
2600 =head2 DetachCertificateFromDistribution
2601  
2602 =over
2603  
2604 =item DistributionName => Str
2605  
2606  
2607 =back
2608  
2609 Each argument is described in detail in: L<Paws::Lightsail::DetachCertificateFromDistribution>
2610  
2611 Returns: a L<Paws::Lightsail::DetachCertificateFromDistributionResult> instance
2612  
2613 Detaches an SSL/TLS certificate from your Amazon Lightsail content
2614 delivery network (CDN) distribution.
2615  
2616 After the certificate is detached, your distribution stops accepting
2617 traffic for all of the domains that are associated with the
2618 certificate.
2619  
2620  
2621 =head2 DetachDisk
2622  
2623 =over
2624  
2625 =item DiskName => Str
2626  
2627  
2628 =back
2629  
2630 Each argument is described in detail in: L<Paws::Lightsail::DetachDisk>
2631  
2632 Returns: a L<Paws::Lightsail::DetachDiskResult> instance
2633  
2634 Detaches a stopped block storage disk from a Lightsail instance. Make
2635 sure to unmount any file systems on the device within your operating
2636 system before stopping the instance and detaching the disk.
2637  
2638 The C<detach disk> operation supports tag-based access control via
2639 resource tags applied to the resource identified by C<disk name>. For
2640 more information, see the Lightsail Dev Guide
2641 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2642  
2643  
2644 =head2 DetachInstancesFromLoadBalancer
2645  
2646 =over
2647  
2648 =item InstanceNames => ArrayRef[Str|Undef]
2649  
2650 =item LoadBalancerName => Str
2651  
2652  
2653 =back
2654  
2655 Each argument is described in detail in: L<Paws::Lightsail::DetachInstancesFromLoadBalancer>
2656  
2657 Returns: a L<Paws::Lightsail::DetachInstancesFromLoadBalancerResult> instance
2658  
2659 Detaches the specified instances from a Lightsail load balancer.
2660  
2661 This operation waits until the instances are no longer needed before
2662 they are detached from the load balancer.
2663  
2664 The C<detach instances from load balancer> operation supports tag-based
2665 access control via resource tags applied to the resource identified by
2666 C<load balancer name>. For more information, see the Lightsail Dev
2667 Guide
2668 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2669  
2670  
2671 =head2 DetachStaticIp
2672  
2673 =over
2674  
2675 =item StaticIpName => Str
2676  
2677  
2678 =back
2679  
2680 Each argument is described in detail in: L<Paws::Lightsail::DetachStaticIp>
2681  
2682 Returns: a L<Paws::Lightsail::DetachStaticIpResult> instance
2683  
2684 Detaches a static IP from the Amazon Lightsail instance to which it is
2685 attached.
2686  
2687  
2688 =head2 DisableAddOn
2689  
2690 =over
2691  
2692 =item AddOnType => Str
2693  
2694 =item ResourceName => Str
2695  
2696  
2697 =back
2698  
2699 Each argument is described in detail in: L<Paws::Lightsail::DisableAddOn>
2700  
2701 Returns: a L<Paws::Lightsail::DisableAddOnResult> instance
2702  
2703 Disables an add-on for an Amazon Lightsail resource. For more
2704 information, see the Lightsail Dev Guide
2705 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots).
2706  
2707  
2708 =head2 DownloadDefaultKeyPair
2709  
2710  
2711  
2712  
2713  
2714  
2715 Each argument is described in detail in: L<Paws::Lightsail::DownloadDefaultKeyPair>
2716  
2717 Returns: a L<Paws::Lightsail::DownloadDefaultKeyPairResult> instance
2718  
2719 Downloads the default SSH key pair from the user's account.
2720  
2721  
2722 =head2 EnableAddOn
2723  
2724 =over
2725  
2726 =item AddOnRequest => L<Paws::Lightsail::AddOnRequest>
2727  
2728 =item ResourceName => Str
2729  
2730  
2731 =back
2732  
2733 Each argument is described in detail in: L<Paws::Lightsail::EnableAddOn>
2734  
2735 Returns: a L<Paws::Lightsail::EnableAddOnResult> instance
2736  
2737 Enables or modifies an add-on for an Amazon Lightsail resource. For
2738 more information, see the Lightsail Dev Guide
2739 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots).
2740  
2741  
2742 =head2 ExportSnapshot
2743  
2744 =over
2745  
2746 =item SourceSnapshotName => Str
2747  
2748  
2749 =back
2750  
2751 Each argument is described in detail in: L<Paws::Lightsail::ExportSnapshot>
2752  
2753 Returns: a L<Paws::Lightsail::ExportSnapshotResult> instance
2754  
2755 Exports an Amazon Lightsail instance or block storage disk snapshot to
2756 Amazon Elastic Compute Cloud (Amazon EC2). This operation results in an
2757 export snapshot record that can be used with the C<create cloud
2758 formation stack> operation to create new Amazon EC2 instances.
2759  
2760 Exported instance snapshots appear in Amazon EC2 as Amazon Machine
2761 Images (AMIs), and the instance system disk appears as an Amazon
2762 Elastic Block Store (Amazon EBS) volume. Exported disk snapshots appear
2763 in Amazon EC2 as Amazon EBS volumes. Snapshots are exported to the same
2764 Amazon Web Services Region in Amazon EC2 as the source Lightsail
2765 snapshot.
2766  
2767 The C<export snapshot> operation supports tag-based access control via
2768 resource tags applied to the resource identified by C<source snapshot
2769 name>. For more information, see the Lightsail Dev Guide
2770 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
2771  
2772 Use the C<get instance snapshots> or C<get disk snapshots> operations
2773 to get a list of snapshots that you can export to Amazon EC2.
2774  
2775  
2776 =head2 GetActiveNames
2777  
2778 =over
2779  
2780 =item [PageToken => Str]
2781  
2782  
2783 =back
2784  
2785 Each argument is described in detail in: L<Paws::Lightsail::GetActiveNames>
2786  
2787 Returns: a L<Paws::Lightsail::GetActiveNamesResult> instance
2788  
2789 Returns the names of all active (not deleted) resources.
2790  
2791  
2792 =head2 GetAlarms
2793  
2794 =over
2795  
2796 =item [AlarmName => Str]
2797  
2798 =item [MonitoredResourceName => Str]
2799  
2800 =item [PageToken => Str]
2801  
2802  
2803 =back
2804  
2805 Each argument is described in detail in: L<Paws::Lightsail::GetAlarms>
2806  
2807 Returns: a L<Paws::Lightsail::GetAlarmsResult> instance
2808  
2809 Returns information about the configured alarms. Specify an alarm name
2810 in your request to return information about a specific alarm, or
2811 specify a monitored resource name to return information about all
2812 alarms for a specific resource.
2813  
2814 An alarm is used to monitor a single metric for one of your resources.
2815 When a metric condition is met, the alarm can notify you by email, SMS
2816 text message, and a banner displayed on the Amazon Lightsail console.
2817 For more information, see Alarms in Amazon Lightsail
2818 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).
2819  
2820  
2821 =head2 GetAutoSnapshots
2822  
2823 =over
2824  
2825 =item ResourceName => Str
2826  
2827  
2828 =back
2829  
2830 Each argument is described in detail in: L<Paws::Lightsail::GetAutoSnapshots>
2831  
2832 Returns: a L<Paws::Lightsail::GetAutoSnapshotsResult> instance
2833  
2834 Returns the available automatic snapshots for an instance or disk. For
2835 more information, see the Lightsail Dev Guide
2836 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots).
2837  
2838  
2839 =head2 GetBlueprints
2840  
2841 =over
2842  
2843 =item [IncludeInactive => Bool]
2844  
2845 =item [PageToken => Str]
2846  
2847  
2848 =back
2849  
2850 Each argument is described in detail in: L<Paws::Lightsail::GetBlueprints>
2851  
2852 Returns: a L<Paws::Lightsail::GetBlueprintsResult> instance
2853  
2854 Returns the list of available instance images, or I<blueprints>. You
2855 can use a blueprint to create a new instance already running a specific
2856 operating system, as well as a preinstalled app or development stack.
2857 The software each instance is running depends on the blueprint image
2858 you choose.
2859  
2860 Use active blueprints when creating new instances. Inactive blueprints
2861 are listed to support customers with existing instances and are not
2862 necessarily available to create new instances. Blueprints are marked
2863 inactive when they become outdated due to operating system updates or
2864 new application releases.
2865  
2866  
2867 =head2 GetBundles
2868  
2869 =over
2870  
2871 =item [IncludeInactive => Bool]
2872  
2873 =item [PageToken => Str]
2874  
2875  
2876 =back
2877  
2878 Each argument is described in detail in: L<Paws::Lightsail::GetBundles>
2879  
2880 Returns: a L<Paws::Lightsail::GetBundlesResult> instance
2881  
2882 Returns the list of bundles that are available for purchase. A bundle
2883 describes the specs for your virtual private server (or I<instance>).
2884  
2885  
2886 =head2 GetCertificates
2887  
2888 =over
2889  
2890 =item [CertificateName => Str]
2891  
2892 =item [CertificateStatuses => ArrayRef[Str|Undef]]
2893  
2894 =item [IncludeCertificateDetails => Bool]
2895  
2896  
2897 =back
2898  
2899 Each argument is described in detail in: L<Paws::Lightsail::GetCertificates>
2900  
2901 Returns: a L<Paws::Lightsail::GetCertificatesResult> instance
2902  
2903 Returns information about one or more Amazon Lightsail SSL/TLS
2904 certificates.
2905  
2906 To get a summary of a certificate, ommit C<includeCertificateDetails>
2907 from your request. The response will include only the certificate
2908 Amazon Resource Name (ARN), certificate name, domain name, and tags.
2909  
2910  
2911 =head2 GetCloudFormationStackRecords
2912  
2913 =over
2914  
2915 =item [PageToken => Str]
2916  
2917  
2918 =back
2919  
2920 Each argument is described in detail in: L<Paws::Lightsail::GetCloudFormationStackRecords>
2921  
2922 Returns: a L<Paws::Lightsail::GetCloudFormationStackRecordsResult> instance
2923  
2924 Returns the CloudFormation stack record created as a result of the
2925 C<create cloud formation stack> operation.
2926  
2927 An AWS CloudFormation stack is used to create a new Amazon EC2 instance
2928 from an exported Lightsail snapshot.
2929  
2930  
2931 =head2 GetContactMethods
2932  
2933 =over
2934  
2935 =item [Protocols => ArrayRef[Str|Undef]]
2936  
2937  
2938 =back
2939  
2940 Each argument is described in detail in: L<Paws::Lightsail::GetContactMethods>
2941  
2942 Returns: a L<Paws::Lightsail::GetContactMethodsResult> instance
2943  
2944 Returns information about the configured contact methods. Specify a
2945 protocol in your request to return information about a specific contact
2946 method.
2947  
2948 A contact method is used to send you notifications about your Amazon
2949 Lightsail resources. You can add one email address and one mobile phone
2950 number contact method in each AWS Region. However, SMS text messaging
2951 is not supported in some AWS Regions, and SMS text messages cannot be
2952 sent to some countries/regions. For more information, see Notifications
2953 in Amazon Lightsail
2954 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications).
2955  
2956  
2957 =head2 GetContainerAPIMetadata
2958  
2959  
2960  
2961  
2962  
2963  
2964 Each argument is described in detail in: L<Paws::Lightsail::GetContainerAPIMetadata>
2965  
2966 Returns: a L<Paws::Lightsail::GetContainerAPIMetadataResult> instance
2967  
2968 Returns information about Amazon Lightsail containers, such as the
2969 current version of the Lightsail Control (lightsailctl) plugin.
2970  
2971  
2972 =head2 GetContainerImages
2973  
2974 =over
2975  
2976 =item ServiceName => Str
2977  
2978  
2979 =back
2980  
2981 Each argument is described in detail in: L<Paws::Lightsail::GetContainerImages>
2982  
2983 Returns: a L<Paws::Lightsail::GetContainerImagesResult> instance
2984  
2985 Returns the container images that are registered to your Amazon
2986 Lightsail container service.
2987  
2988 If you created a deployment on your Lightsail container service that
2989 uses container images from a public registry like Docker Hub, those
2990 images are not returned as part of this action. Those images are not
2991 registered to your Lightsail container service.
2992  
2993  
2994 =head2 GetContainerLog
2995  
2996 =over
2997  
2998 =item ContainerName => Str
2999  
3000 =item ServiceName => Str
3001  
3002 =item [EndTime => Str]
3003  
3004 =item [FilterPattern => Str]
3005  
3006 =item [PageToken => Str]
3007  
3008 =item [StartTime => Str]
3009  
3010  
3011 =back
3012  
3013 Each argument is described in detail in: L<Paws::Lightsail::GetContainerLog>
3014  
3015 Returns: a L<Paws::Lightsail::GetContainerLogResult> instance
3016  
3017 Returns the log events of a container of your Amazon Lightsail
3018 container service.
3019  
3020 If your container service has more than one node (i.e., a scale greater
3021 than 1), then the log events that are returned for the specified
3022 container are merged from all nodes on your container service.
3023  
3024 Container logs are retained for a certain amount of time. For more
3025 information, see Amazon Lightsail endpoints and quotas
3026 (https://docs.aws.amazon.com/general/latest/gr/lightsail.html) in the
3027 I<AWS General Reference>.
3028  
3029  
3030 =head2 GetContainerServiceDeployments
3031  
3032 =over
3033  
3034 =item ServiceName => Str
3035  
3036  
3037 =back
3038  
3039 Each argument is described in detail in: L<Paws::Lightsail::GetContainerServiceDeployments>
3040  
3041 Returns: a L<Paws::Lightsail::GetContainerServiceDeploymentsResult> instance
3042  
3043 Returns the deployments for your Amazon Lightsail container service
3044  
3045 A deployment specifies the settings, such as the ports and launch
3046 command, of containers that are deployed to your container service.
3047  
3048 The deployments are ordered by version in ascending order. The newest
3049 version is listed at the top of the response.
3050  
3051 A set number of deployments are kept before the oldest one is replaced
3052 with the newest one. For more information, see Amazon Lightsail
3053 endpoints and quotas
3054 (https://docs.aws.amazon.com/general/latest/gr/lightsail.html) in the
3055 I<AWS General Reference>.
3056  
3057  
3058 =head2 GetContainerServiceMetricData
3059  
3060 =over
3061  
3062 =item EndTime => Str
3063  
3064 =item MetricName => Str
3065  
3066 =item Period => Int
3067  
3068 =item ServiceName => Str
3069  
3070 =item StartTime => Str
3071  
3072 =item Statistics => ArrayRef[Str|Undef]
3073  
3074  
3075 =back
3076  
3077 Each argument is described in detail in: L<Paws::Lightsail::GetContainerServiceMetricData>
3078  
3079 Returns: a L<Paws::Lightsail::GetContainerServiceMetricDataResult> instance
3080  
3081 Returns the data points of a specific metric of your Amazon Lightsail
3082 container service.
3083  
3084 Metrics report the utilization of your resources. Monitor and collect
3085 metric data regularly to maintain the reliability, availability, and
3086 performance of your resources.
3087  
3088  
3089 =head2 GetContainerServicePowers
3090  
3091  
3092  
3093  
3094  
3095  
3096 Each argument is described in detail in: L<Paws::Lightsail::GetContainerServicePowers>
3097  
3098 Returns: a L<Paws::Lightsail::GetContainerServicePowersResult> instance
3099  
3100 Returns the list of powers that can be specified for your Amazon
3101 Lightsail container services.
3102  
3103 The power specifies the amount of memory, the number of vCPUs, and the
3104 base price of the container service.
3105  
3106  
3107 =head2 GetContainerServices
3108  
3109 =over
3110  
3111 =item [ServiceName => Str]
3112  
3113  
3114 =back
3115  
3116 Each argument is described in detail in: L<Paws::Lightsail::GetContainerServices>
3117  
3118 Returns: a L<Paws::Lightsail::ContainerServicesListResult> instance
3119  
3120 Returns information about one or more of your Amazon Lightsail
3121 container services.
3122  
3123  
3124 =head2 GetDisk
3125  
3126 =over
3127  
3128 =item DiskName => Str
3129  
3130  
3131 =back
3132  
3133 Each argument is described in detail in: L<Paws::Lightsail::GetDisk>
3134  
3135 Returns: a L<Paws::Lightsail::GetDiskResult> instance
3136  
3137 Returns information about a specific block storage disk.
3138  
3139  
3140 =head2 GetDisks
3141  
3142 =over
3143  
3144 =item [PageToken => Str]
3145  
3146  
3147 =back
3148  
3149 Each argument is described in detail in: L<Paws::Lightsail::GetDisks>
3150  
3151 Returns: a L<Paws::Lightsail::GetDisksResult> instance
3152  
3153 Returns information about all block storage disks in your AWS account
3154 and region.
3155  
3156  
3157 =head2 GetDiskSnapshot
3158  
3159 =over
3160  
3161 =item DiskSnapshotName => Str
3162  
3163  
3164 =back
3165  
3166 Each argument is described in detail in: L<Paws::Lightsail::GetDiskSnapshot>
3167  
3168 Returns: a L<Paws::Lightsail::GetDiskSnapshotResult> instance
3169  
3170 Returns information about a specific block storage disk snapshot.
3171  
3172  
3173 =head2 GetDiskSnapshots
3174  
3175 =over
3176  
3177 =item [PageToken => Str]
3178  
3179  
3180 =back
3181  
3182 Each argument is described in detail in: L<Paws::Lightsail::GetDiskSnapshots>
3183  
3184 Returns: a L<Paws::Lightsail::GetDiskSnapshotsResult> instance
3185  
3186 Returns information about all block storage disk snapshots in your AWS
3187 account and region.
3188  
3189  
3190 =head2 GetDistributionBundles
3191  
3192  
3193  
3194  
3195  
3196  
3197 Each argument is described in detail in: L<Paws::Lightsail::GetDistributionBundles>
3198  
3199 Returns: a L<Paws::Lightsail::GetDistributionBundlesResult> instance
3200  
3201 Returns the list bundles that can be applied to you Amazon Lightsail
3202 content delivery network (CDN) distributions.
3203  
3204 A distribution bundle specifies the monthly network transfer quota and
3205 monthly cost of your dsitribution.
3206  
3207  
3208 =head2 GetDistributionLatestCacheReset
3209  
3210 =over
3211  
3212 =item [DistributionName => Str]
3213  
3214  
3215 =back
3216  
3217 Each argument is described in detail in: L<Paws::Lightsail::GetDistributionLatestCacheReset>
3218  
3219 Returns: a L<Paws::Lightsail::GetDistributionLatestCacheResetResult> instance
3220  
3221 Returns the timestamp and status of the last cache reset of a specific
3222 Amazon Lightsail content delivery network (CDN) distribution.
3223  
3224  
3225 =head2 GetDistributionMetricData
3226  
3227 =over
3228  
3229 =item DistributionName => Str
3230  
3231 =item EndTime => Str
3232  
3233 =item MetricName => Str
3234  
3235 =item Period => Int
3236  
3237 =item StartTime => Str
3238  
3239 =item Statistics => ArrayRef[Str|Undef]
3240  
3241 =item Unit => Str
3242  
3243  
3244 =back
3245  
3246 Each argument is described in detail in: L<Paws::Lightsail::GetDistributionMetricData>
3247  
3248 Returns: a L<Paws::Lightsail::GetDistributionMetricDataResult> instance
3249  
3250 Returns the data points of a specific metric for an Amazon Lightsail
3251 content delivery network (CDN) distribution.
3252  
3253 Metrics report the utilization of your resources, and the error counts
3254 generated by them. Monitor and collect metric data regularly to
3255 maintain the reliability, availability, and performance of your
3256 resources.
3257  
3258  
3259 =head2 GetDistributions
3260  
3261 =over
3262  
3263 =item [DistributionName => Str]
3264  
3265 =item [PageToken => Str]
3266  
3267  
3268 =back
3269  
3270 Each argument is described in detail in: L<Paws::Lightsail::GetDistributions>
3271  
3272 Returns: a L<Paws::Lightsail::GetDistributionsResult> instance
3273  
3274 Returns information about one or more of your Amazon Lightsail content
3275 delivery network (CDN) distributions.
3276  
3277  
3278 =head2 GetDomain
3279  
3280 =over
3281  
3282 =item DomainName => Str
3283  
3284  
3285 =back
3286  
3287 Each argument is described in detail in: L<Paws::Lightsail::GetDomain>
3288  
3289 Returns: a L<Paws::Lightsail::GetDomainResult> instance
3290  
3291 Returns information about a specific domain recordset.
3292  
3293  
3294 =head2 GetDomains
3295  
3296 =over
3297  
3298 =item [PageToken => Str]
3299  
3300  
3301 =back
3302  
3303 Each argument is described in detail in: L<Paws::Lightsail::GetDomains>
3304  
3305 Returns: a L<Paws::Lightsail::GetDomainsResult> instance
3306  
3307 Returns a list of all domains in the user's account.
3308  
3309  
3310 =head2 GetExportSnapshotRecords
3311  
3312 =over
3313  
3314 =item [PageToken => Str]
3315  
3316  
3317 =back
3318  
3319 Each argument is described in detail in: L<Paws::Lightsail::GetExportSnapshotRecords>
3320  
3321 Returns: a L<Paws::Lightsail::GetExportSnapshotRecordsResult> instance
3322  
3323 Returns the export snapshot record created as a result of the C<export
3324 snapshot> operation.
3325  
3326 An export snapshot record can be used to create a new Amazon EC2
3327 instance and its related resources with the C<create cloud formation
3328 stack> operation.
3329  
3330  
3331 =head2 GetInstance
3332  
3333 =over
3334  
3335 =item InstanceName => Str
3336  
3337  
3338 =back
3339  
3340 Each argument is described in detail in: L<Paws::Lightsail::GetInstance>
3341  
3342 Returns: a L<Paws::Lightsail::GetInstanceResult> instance
3343  
3344 Returns information about a specific Amazon Lightsail instance, which
3345 is a virtual private server.
3346  
3347  
3348 =head2 GetInstanceAccessDetails
3349  
3350 =over
3351  
3352 =item InstanceName => Str
3353  
3354 =item [Protocol => Str]
3355  
3356  
3357 =back
3358  
3359 Each argument is described in detail in: L<Paws::Lightsail::GetInstanceAccessDetails>
3360  
3361 Returns: a L<Paws::Lightsail::GetInstanceAccessDetailsResult> instance
3362  
3363 Returns temporary SSH keys you can use to connect to a specific virtual
3364 private server, or I<instance>.
3365  
3366 The C<get instance access details> operation supports tag-based access
3367 control via resource tags applied to the resource identified by
3368 C<instance name>. For more information, see the Lightsail Dev Guide
3369 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
3370  
3371  
3372 =head2 GetInstanceMetricData
3373  
3374 =over
3375  
3376 =item EndTime => Str
3377  
3378 =item InstanceName => Str
3379  
3380 =item MetricName => Str
3381  
3382 =item Period => Int
3383  
3384 =item StartTime => Str
3385  
3386 =item Statistics => ArrayRef[Str|Undef]
3387  
3388 =item Unit => Str
3389  
3390  
3391 =back
3392  
3393 Each argument is described in detail in: L<Paws::Lightsail::GetInstanceMetricData>
3394  
3395 Returns: a L<Paws::Lightsail::GetInstanceMetricDataResult> instance
3396  
3397 Returns the data points for the specified Amazon Lightsail instance
3398 metric, given an instance name.
3399  
3400 Metrics report the utilization of your resources, and the error counts
3401 generated by them. Monitor and collect metric data regularly to
3402 maintain the reliability, availability, and performance of your
3403 resources.
3404  
3405  
3406 =head2 GetInstancePortStates
3407  
3408 =over
3409  
3410 =item InstanceName => Str
3411  
3412  
3413 =back
3414  
3415 Each argument is described in detail in: L<Paws::Lightsail::GetInstancePortStates>
3416  
3417 Returns: a L<Paws::Lightsail::GetInstancePortStatesResult> instance
3418  
3419 Returns the firewall port states for a specific Amazon Lightsail
3420 instance, the IP addresses allowed to connect to the instance through
3421 the ports, and the protocol.
3422  
3423  
3424 =head2 GetInstances
3425  
3426 =over
3427  
3428 =item [PageToken => Str]
3429  
3430  
3431 =back
3432  
3433 Each argument is described in detail in: L<Paws::Lightsail::GetInstances>
3434  
3435 Returns: a L<Paws::Lightsail::GetInstancesResult> instance
3436  
3437 Returns information about all Amazon Lightsail virtual private servers,
3438 or I<instances>.
3439  
3440  
3441 =head2 GetInstanceSnapshot
3442  
3443 =over
3444  
3445 =item InstanceSnapshotName => Str
3446  
3447  
3448 =back
3449  
3450 Each argument is described in detail in: L<Paws::Lightsail::GetInstanceSnapshot>
3451  
3452 Returns: a L<Paws::Lightsail::GetInstanceSnapshotResult> instance
3453  
3454 Returns information about a specific instance snapshot.
3455  
3456  
3457 =head2 GetInstanceSnapshots
3458  
3459 =over
3460  
3461 =item [PageToken => Str]
3462  
3463  
3464 =back
3465  
3466 Each argument is described in detail in: L<Paws::Lightsail::GetInstanceSnapshots>
3467  
3468 Returns: a L<Paws::Lightsail::GetInstanceSnapshotsResult> instance
3469  
3470 Returns all instance snapshots for the user's account.
3471  
3472  
3473 =head2 GetInstanceState
3474  
3475 =over
3476  
3477 =item InstanceName => Str
3478  
3479  
3480 =back
3481  
3482 Each argument is described in detail in: L<Paws::Lightsail::GetInstanceState>
3483  
3484 Returns: a L<Paws::Lightsail::GetInstanceStateResult> instance
3485  
3486 Returns the state of a specific instance. Works on one instance at a
3487 time.
3488  
3489  
3490 =head2 GetKeyPair
3491  
3492 =over
3493  
3494 =item KeyPairName => Str
3495  
3496  
3497 =back
3498  
3499 Each argument is described in detail in: L<Paws::Lightsail::GetKeyPair>
3500  
3501 Returns: a L<Paws::Lightsail::GetKeyPairResult> instance
3502  
3503 Returns information about a specific key pair.
3504  
3505  
3506 =head2 GetKeyPairs
3507  
3508 =over
3509  
3510 =item [PageToken => Str]
3511  
3512  
3513 =back
3514  
3515 Each argument is described in detail in: L<Paws::Lightsail::GetKeyPairs>
3516  
3517 Returns: a L<Paws::Lightsail::GetKeyPairsResult> instance
3518  
3519 Returns information about all key pairs in the user's account.
3520  
3521  
3522 =head2 GetLoadBalancer
3523  
3524 =over
3525  
3526 =item LoadBalancerName => Str
3527  
3528  
3529 =back
3530  
3531 Each argument is described in detail in: L<Paws::Lightsail::GetLoadBalancer>
3532  
3533 Returns: a L<Paws::Lightsail::GetLoadBalancerResult> instance
3534  
3535 Returns information about the specified Lightsail load balancer.
3536  
3537  
3538 =head2 GetLoadBalancerMetricData
3539  
3540 =over
3541  
3542 =item EndTime => Str
3543  
3544 =item LoadBalancerName => Str
3545  
3546 =item MetricName => Str
3547  
3548 =item Period => Int
3549  
3550 =item StartTime => Str
3551  
3552 =item Statistics => ArrayRef[Str|Undef]
3553  
3554 =item Unit => Str
3555  
3556  
3557 =back
3558  
3559 Each argument is described in detail in: L<Paws::Lightsail::GetLoadBalancerMetricData>
3560  
3561 Returns: a L<Paws::Lightsail::GetLoadBalancerMetricDataResult> instance
3562  
3563 Returns information about health metrics for your Lightsail load
3564 balancer.
3565  
3566 Metrics report the utilization of your resources, and the error counts
3567 generated by them. Monitor and collect metric data regularly to
3568 maintain the reliability, availability, and performance of your
3569 resources.
3570  
3571  
3572 =head2 GetLoadBalancers
3573  
3574 =over
3575  
3576 =item [PageToken => Str]
3577  
3578  
3579 =back
3580  
3581 Each argument is described in detail in: L<Paws::Lightsail::GetLoadBalancers>
3582  
3583 Returns: a L<Paws::Lightsail::GetLoadBalancersResult> instance
3584  
3585 Returns information about all load balancers in an account.
3586  
3587  
3588 =head2 GetLoadBalancerTlsCertificates
3589  
3590 =over
3591  
3592 =item LoadBalancerName => Str
3593  
3594  
3595 =back
3596  
3597 Each argument is described in detail in: L<Paws::Lightsail::GetLoadBalancerTlsCertificates>
3598  
3599 Returns: a L<Paws::Lightsail::GetLoadBalancerTlsCertificatesResult> instance
3600  
3601 Returns information about the TLS certificates that are associated with
3602 the specified Lightsail load balancer.
3603  
3604 TLS is just an updated, more secure version of Secure Socket Layer
3605 (SSL).
3606  
3607 You can have a maximum of 2 certificates associated with a Lightsail
3608 load balancer. One is active and the other is inactive.
3609  
3610  
3611 =head2 GetOperation
3612  
3613 =over
3614  
3615 =item OperationId => Str
3616  
3617  
3618 =back
3619  
3620 Each argument is described in detail in: L<Paws::Lightsail::GetOperation>
3621  
3622 Returns: a L<Paws::Lightsail::GetOperationResult> instance
3623  
3624 Returns information about a specific operation. Operations include
3625 events such as when you create an instance, allocate a static IP,
3626 attach a static IP, and so on.
3627  
3628  
3629 =head2 GetOperations
3630  
3631 =over
3632  
3633 =item [PageToken => Str]
3634  
3635  
3636 =back
3637  
3638 Each argument is described in detail in: L<Paws::Lightsail::GetOperations>
3639  
3640 Returns: a L<Paws::Lightsail::GetOperationsResult> instance
3641  
3642 Returns information about all operations.
3643  
3644 Results are returned from oldest to newest, up to a maximum of 200.
3645 Results can be paged by making each subsequent call to C<GetOperations>
3646 use the maximum (last) C<statusChangedAt> value from the previous
3647 request.
3648  
3649  
3650 =head2 GetOperationsForResource
3651  
3652 =over
3653  
3654 =item ResourceName => Str
3655  
3656 =item [PageToken => Str]
3657  
3658  
3659 =back
3660  
3661 Each argument is described in detail in: L<Paws::Lightsail::GetOperationsForResource>
3662  
3663 Returns: a L<Paws::Lightsail::GetOperationsForResourceResult> instance
3664  
3665 Gets operations for a specific resource (e.g., an instance or a static
3666 IP).
3667  
3668  
3669 =head2 GetRegions
3670  
3671 =over
3672  
3673 =item [IncludeAvailabilityZones => Bool]
3674  
3675 =item [IncludeRelationalDatabaseAvailabilityZones => Bool]
3676  
3677  
3678 =back
3679  
3680 Each argument is described in detail in: L<Paws::Lightsail::GetRegions>
3681  
3682 Returns: a L<Paws::Lightsail::GetRegionsResult> instance
3683  
3684 Returns a list of all valid regions for Amazon Lightsail. Use the
3685 C<include availability zones> parameter to also return the Availability
3686 Zones in a region.
3687  
3688  
3689 =head2 GetRelationalDatabase
3690  
3691 =over
3692  
3693 =item RelationalDatabaseName => Str
3694  
3695  
3696 =back
3697  
3698 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabase>
3699  
3700 Returns: a L<Paws::Lightsail::GetRelationalDatabaseResult> instance
3701  
3702 Returns information about a specific database in Amazon Lightsail.
3703  
3704  
3705 =head2 GetRelationalDatabaseBlueprints
3706  
3707 =over
3708  
3709 =item [PageToken => Str]
3710  
3711  
3712 =back
3713  
3714 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseBlueprints>
3715  
3716 Returns: a L<Paws::Lightsail::GetRelationalDatabaseBlueprintsResult> instance
3717  
3718 Returns a list of available database blueprints in Amazon Lightsail. A
3719 blueprint describes the major engine version of a database.
3720  
3721 You can use a blueprint ID to create a new database that runs a
3722 specific database engine.
3723  
3724  
3725 =head2 GetRelationalDatabaseBundles
3726  
3727 =over
3728  
3729 =item [PageToken => Str]
3730  
3731  
3732 =back
3733  
3734 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseBundles>
3735  
3736 Returns: a L<Paws::Lightsail::GetRelationalDatabaseBundlesResult> instance
3737  
3738 Returns the list of bundles that are available in Amazon Lightsail. A
3739 bundle describes the performance specifications for a database.
3740  
3741 You can use a bundle ID to create a new database with explicit
3742 performance specifications.
3743  
3744  
3745 =head2 GetRelationalDatabaseEvents
3746  
3747 =over
3748  
3749 =item RelationalDatabaseName => Str
3750  
3751 =item [DurationInMinutes => Int]
3752  
3753 =item [PageToken => Str]
3754  
3755  
3756 =back
3757  
3758 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseEvents>
3759  
3760 Returns: a L<Paws::Lightsail::GetRelationalDatabaseEventsResult> instance
3761  
3762 Returns a list of events for a specific database in Amazon Lightsail.
3763  
3764  
3765 =head2 GetRelationalDatabaseLogEvents
3766  
3767 =over
3768  
3769 =item LogStreamName => Str
3770  
3771 =item RelationalDatabaseName => Str
3772  
3773 =item [EndTime => Str]
3774  
3775 =item [PageToken => Str]
3776  
3777 =item [StartFromHead => Bool]
3778  
3779 =item [StartTime => Str]
3780  
3781  
3782 =back
3783  
3784 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseLogEvents>
3785  
3786 Returns: a L<Paws::Lightsail::GetRelationalDatabaseLogEventsResult> instance
3787  
3788 Returns a list of log events for a database in Amazon Lightsail.
3789  
3790  
3791 =head2 GetRelationalDatabaseLogStreams
3792  
3793 =over
3794  
3795 =item RelationalDatabaseName => Str
3796  
3797  
3798 =back
3799  
3800 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseLogStreams>
3801  
3802 Returns: a L<Paws::Lightsail::GetRelationalDatabaseLogStreamsResult> instance
3803  
3804 Returns a list of available log streams for a specific database in
3805 Amazon Lightsail.
3806  
3807  
3808 =head2 GetRelationalDatabaseMasterUserPassword
3809  
3810 =over
3811  
3812 =item RelationalDatabaseName => Str
3813  
3814 =item [PasswordVersion => Str]
3815  
3816  
3817 =back
3818  
3819 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseMasterUserPassword>
3820  
3821 Returns: a L<Paws::Lightsail::GetRelationalDatabaseMasterUserPasswordResult> instance
3822  
3823 Returns the current, previous, or pending versions of the master user
3824 password for a Lightsail database.
3825  
3826 The C<GetRelationalDatabaseMasterUserPassword> operation supports
3827 tag-based access control via resource tags applied to the resource
3828 identified by relationalDatabaseName.
3829  
3830  
3831 =head2 GetRelationalDatabaseMetricData
3832  
3833 =over
3834  
3835 =item EndTime => Str
3836  
3837 =item MetricName => Str
3838  
3839 =item Period => Int
3840  
3841 =item RelationalDatabaseName => Str
3842  
3843 =item StartTime => Str
3844  
3845 =item Statistics => ArrayRef[Str|Undef]
3846  
3847 =item Unit => Str
3848  
3849  
3850 =back
3851  
3852 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseMetricData>
3853  
3854 Returns: a L<Paws::Lightsail::GetRelationalDatabaseMetricDataResult> instance
3855  
3856 Returns the data points of the specified metric for a database in
3857 Amazon Lightsail.
3858  
3859 Metrics report the utilization of your resources, and the error counts
3860 generated by them. Monitor and collect metric data regularly to
3861 maintain the reliability, availability, and performance of your
3862 resources.
3863  
3864  
3865 =head2 GetRelationalDatabaseParameters
3866  
3867 =over
3868  
3869 =item RelationalDatabaseName => Str
3870  
3871 =item [PageToken => Str]
3872  
3873  
3874 =back
3875  
3876 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseParameters>
3877  
3878 Returns: a L<Paws::Lightsail::GetRelationalDatabaseParametersResult> instance
3879  
3880 Returns all of the runtime parameters offered by the underlying
3881 database software, or engine, for a specific database in Amazon
3882 Lightsail.
3883  
3884 In addition to the parameter names and values, this operation returns
3885 other information about each parameter. This information includes
3886 whether changes require a reboot, whether the parameter is modifiable,
3887 the allowed values, and the data types.
3888  
3889  
3890 =head2 GetRelationalDatabases
3891  
3892 =over
3893  
3894 =item [PageToken => Str]
3895  
3896  
3897 =back
3898  
3899 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabases>
3900  
3901 Returns: a L<Paws::Lightsail::GetRelationalDatabasesResult> instance
3902  
3903 Returns information about all of your databases in Amazon Lightsail.
3904  
3905  
3906 =head2 GetRelationalDatabaseSnapshot
3907  
3908 =over
3909  
3910 =item RelationalDatabaseSnapshotName => Str
3911  
3912  
3913 =back
3914  
3915 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseSnapshot>
3916  
3917 Returns: a L<Paws::Lightsail::GetRelationalDatabaseSnapshotResult> instance
3918  
3919 Returns information about a specific database snapshot in Amazon
3920 Lightsail.
3921  
3922  
3923 =head2 GetRelationalDatabaseSnapshots
3924  
3925 =over
3926  
3927 =item [PageToken => Str]
3928  
3929  
3930 =back
3931  
3932 Each argument is described in detail in: L<Paws::Lightsail::GetRelationalDatabaseSnapshots>
3933  
3934 Returns: a L<Paws::Lightsail::GetRelationalDatabaseSnapshotsResult> instance
3935  
3936 Returns information about all of your database snapshots in Amazon
3937 Lightsail.
3938  
3939  
3940 =head2 GetStaticIp
3941  
3942 =over
3943  
3944 =item StaticIpName => Str
3945  
3946  
3947 =back
3948  
3949 Each argument is described in detail in: L<Paws::Lightsail::GetStaticIp>
3950  
3951 Returns: a L<Paws::Lightsail::GetStaticIpResult> instance
3952  
3953 Returns information about an Amazon Lightsail static IP.
3954  
3955  
3956 =head2 GetStaticIps
3957  
3958 =over
3959  
3960 =item [PageToken => Str]
3961  
3962  
3963 =back
3964  
3965 Each argument is described in detail in: L<Paws::Lightsail::GetStaticIps>
3966  
3967 Returns: a L<Paws::Lightsail::GetStaticIpsResult> instance
3968  
3969 Returns information about all static IPs in the user's account.
3970  
3971  
3972 =head2 ImportKeyPair
3973  
3974 =over
3975  
3976 =item KeyPairName => Str
3977  
3978 =item PublicKeyBase64 => Str
3979  
3980  
3981 =back
3982  
3983 Each argument is described in detail in: L<Paws::Lightsail::ImportKeyPair>
3984  
3985 Returns: a L<Paws::Lightsail::ImportKeyPairResult> instance
3986  
3987 Imports a public SSH key from a specific key pair.
3988  
3989  
3990 =head2 IsVpcPeered
3991  
3992  
3993  
3994  
3995  
3996  
3997 Each argument is described in detail in: L<Paws::Lightsail::IsVpcPeered>
3998  
3999 Returns: a L<Paws::Lightsail::IsVpcPeeredResult> instance
4000  
4001 Returns a Boolean value indicating whether your Lightsail VPC is
4002 peered.
4003  
4004  
4005 =head2 OpenInstancePublicPorts
4006  
4007 =over
4008  
4009 =item InstanceName => Str
4010  
4011 =item PortInfo => L<Paws::Lightsail::PortInfo>
4012  
4013  
4014 =back
4015  
4016 Each argument is described in detail in: L<Paws::Lightsail::OpenInstancePublicPorts>
4017  
4018 Returns: a L<Paws::Lightsail::OpenInstancePublicPortsResult> instance
4019  
4020 Opens ports for a specific Amazon Lightsail instance, and specifies the
4021 IP addresses allowed to connect to the instance through the ports, and
4022 the protocol.
4023  
4024 The C<OpenInstancePublicPorts> action supports tag-based access control
4025 via resource tags applied to the resource identified by
4026 C<instanceName>. For more information, see the Lightsail Dev Guide
4027 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4028  
4029  
4030 =head2 PeerVpc
4031  
4032  
4033  
4034  
4035  
4036  
4037 Each argument is described in detail in: L<Paws::Lightsail::PeerVpc>
4038  
4039 Returns: a L<Paws::Lightsail::PeerVpcResult> instance
4040  
4041 Tries to peer the Lightsail VPC with the user's default VPC.
4042  
4043  
4044 =head2 PutAlarm
4045  
4046 =over
4047  
4048 =item AlarmName => Str
4049  
4050 =item ComparisonOperator => Str
4051  
4052 =item EvaluationPeriods => Int
4053  
4054 =item MetricName => Str
4055  
4056 =item MonitoredResourceName => Str
4057  
4058 =item Threshold => Num
4059  
4060 =item [ContactProtocols => ArrayRef[Str|Undef]]
4061  
4062 =item [DatapointsToAlarm => Int]
4063  
4064 =item [NotificationEnabled => Bool]
4065  
4066 =item [NotificationTriggers => ArrayRef[Str|Undef]]
4067  
4068 =item [TreatMissingData => Str]
4069  
4070  
4071 =back
4072  
4073 Each argument is described in detail in: L<Paws::Lightsail::PutAlarm>
4074  
4075 Returns: a L<Paws::Lightsail::PutAlarmResult> instance
4076  
4077 Creates or updates an alarm, and associates it with the specified
4078 metric.
4079  
4080 An alarm is used to monitor a single metric for one of your resources.
4081 When a metric condition is met, the alarm can notify you by email, SMS
4082 text message, and a banner displayed on the Amazon Lightsail console.
4083 For more information, see Alarms in Amazon Lightsail
4084 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).
4085  
4086 When this action creates an alarm, the alarm state is immediately set
4087 to C<INSUFFICIENT_DATA>. The alarm is then evaluated and its state is
4088 set appropriately. Any actions associated with the new state are then
4089 executed.
4090  
4091 When you update an existing alarm, its state is left unchanged, but the
4092 update completely overwrites the previous configuration of the alarm.
4093 The alarm is then evaluated with the updated configuration.
4094  
4095  
4096 =head2 PutInstancePublicPorts
4097  
4098 =over
4099  
4100 =item InstanceName => Str
4101  
4102 =item PortInfos => ArrayRef[L<Paws::Lightsail::PortInfo>]
4103  
4104  
4105 =back
4106  
4107 Each argument is described in detail in: L<Paws::Lightsail::PutInstancePublicPorts>
4108  
4109 Returns: a L<Paws::Lightsail::PutInstancePublicPortsResult> instance
4110  
4111 Opens ports for a specific Amazon Lightsail instance, and specifies the
4112 IP addresses allowed to connect to the instance through the ports, and
4113 the protocol. This action also closes all currently open ports that are
4114 not included in the request. Include all of the ports and the protocols
4115 you want to open in your C<PutInstancePublicPorts>request. Or use the
4116 C<OpenInstancePublicPorts> action to open ports without closing
4117 currently open ports.
4118  
4119 The C<PutInstancePublicPorts> action supports tag-based access control
4120 via resource tags applied to the resource identified by
4121 C<instanceName>. For more information, see the Lightsail Dev Guide
4122 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4123  
4124  
4125 =head2 RebootInstance
4126  
4127 =over
4128  
4129 =item InstanceName => Str
4130  
4131  
4132 =back
4133  
4134 Each argument is described in detail in: L<Paws::Lightsail::RebootInstance>
4135  
4136 Returns: a L<Paws::Lightsail::RebootInstanceResult> instance
4137  
4138 Restarts a specific instance.
4139  
4140 The C<reboot instance> operation supports tag-based access control via
4141 resource tags applied to the resource identified by C<instance name>.
4142 For more information, see the Lightsail Dev Guide
4143 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4144  
4145  
4146 =head2 RebootRelationalDatabase
4147  
4148 =over
4149  
4150 =item RelationalDatabaseName => Str
4151  
4152  
4153 =back
4154  
4155 Each argument is described in detail in: L<Paws::Lightsail::RebootRelationalDatabase>
4156  
4157 Returns: a L<Paws::Lightsail::RebootRelationalDatabaseResult> instance
4158  
4159 Restarts a specific database in Amazon Lightsail.
4160  
4161 The C<reboot relational database> operation supports tag-based access
4162 control via resource tags applied to the resource identified by
4163 relationalDatabaseName. For more information, see the Lightsail Dev
4164 Guide
4165 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4166  
4167  
4168 =head2 RegisterContainerImage
4169  
4170 =over
4171  
4172 =item Digest => Str
4173  
4174 =item Label => Str
4175  
4176 =item ServiceName => Str
4177  
4178  
4179 =back
4180  
4181 Each argument is described in detail in: L<Paws::Lightsail::RegisterContainerImage>
4182  
4183 Returns: a L<Paws::Lightsail::RegisterContainerImageResult> instance
4184  
4185 Registers a container image to your Amazon Lightsail container service.
4186  
4187 This action is not required if you install and use the Lightsail
4188 Control (lightsailctl) plugin to push container images to your
4189 Lightsail container service. For more information, see Pushing and
4190 managing container images on your Amazon Lightsail container services
4191 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-pushing-container-images)
4192 in the I<Lightsail Dev Guide>.
4193  
4194  
4195 =head2 ReleaseStaticIp
4196  
4197 =over
4198  
4199 =item StaticIpName => Str
4200  
4201  
4202 =back
4203  
4204 Each argument is described in detail in: L<Paws::Lightsail::ReleaseStaticIp>
4205  
4206 Returns: a L<Paws::Lightsail::ReleaseStaticIpResult> instance
4207  
4208 Deletes a specific static IP from your account.
4209  
4210  
4211 =head2 ResetDistributionCache
4212  
4213 =over
4214  
4215 =item [DistributionName => Str]
4216  
4217  
4218 =back
4219  
4220 Each argument is described in detail in: L<Paws::Lightsail::ResetDistributionCache>
4221  
4222 Returns: a L<Paws::Lightsail::ResetDistributionCacheResult> instance
4223  
4224 Deletes currently cached content from your Amazon Lightsail content
4225 delivery network (CDN) distribution.
4226  
4227 After resetting the cache, the next time a content request is made,
4228 your distribution pulls, serves, and caches it from the origin.
4229  
4230  
4231 =head2 SendContactMethodVerification
4232  
4233 =over
4234  
4235 =item Protocol => Str
4236  
4237  
4238 =back
4239  
4240 Each argument is described in detail in: L<Paws::Lightsail::SendContactMethodVerification>
4241  
4242 Returns: a L<Paws::Lightsail::SendContactMethodVerificationResult> instance
4243  
4244 Sends a verification request to an email contact method to ensure it's
4245 owned by the requester. SMS contact methods don't need to be verified.
4246  
4247 A contact method is used to send you notifications about your Amazon
4248 Lightsail resources. You can add one email address and one mobile phone
4249 number contact method in each AWS Region. However, SMS text messaging
4250 is not supported in some AWS Regions, and SMS text messages cannot be
4251 sent to some countries/regions. For more information, see Notifications
4252 in Amazon Lightsail
4253 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications).
4254  
4255 A verification request is sent to the contact method when you initially
4256 create it. Use this action to send another verification request if a
4257 previous verification request was deleted, or has expired.
4258  
4259 Notifications are not sent to an email contact method until after it is
4260 verified, and confirmed as valid.
4261  
4262  
4263 =head2 SetIpAddressType
4264  
4265 =over
4266  
4267 =item IpAddressType => Str
4268  
4269 =item ResourceName => Str
4270  
4271 =item ResourceType => Str
4272  
4273  
4274 =back
4275  
4276 Each argument is described in detail in: L<Paws::Lightsail::SetIpAddressType>
4277  
4278 Returns: a L<Paws::Lightsail::SetIpAddressTypeResult> instance
4279  
4280 Sets the IP address type for an Amazon Lightsail resource.
4281  
4282 Use this action to enable dual-stack for a resource, which enables IPv4
4283 and IPv6 for the specified resource. Alternately, you can use this
4284 action to disable dual-stack, and enable IPv4 only.
4285  
4286  
4287 =head2 StartInstance
4288  
4289 =over
4290  
4291 =item InstanceName => Str
4292  
4293  
4294 =back
4295  
4296 Each argument is described in detail in: L<Paws::Lightsail::StartInstance>
4297  
4298 Returns: a L<Paws::Lightsail::StartInstanceResult> instance
4299  
4300 Starts a specific Amazon Lightsail instance from a stopped state. To
4301 restart an instance, use the C<reboot instance> operation.
4302  
4303 When you start a stopped instance, Lightsail assigns a new public IP
4304 address to the instance. To use the same IP address after stopping and
4305 starting an instance, create a static IP address and attach it to the
4306 instance. For more information, see the Lightsail Dev Guide
4307 (https://lightsail.aws.amazon.com/ls/docs/en/articles/lightsail-create-static-ip).
4308  
4309 The C<start instance> operation supports tag-based access control via
4310 resource tags applied to the resource identified by C<instance name>.
4311 For more information, see the Lightsail Dev Guide
4312 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4313  
4314  
4315 =head2 StartRelationalDatabase
4316  
4317 =over
4318  
4319 =item RelationalDatabaseName => Str
4320  
4321  
4322 =back
4323  
4324 Each argument is described in detail in: L<Paws::Lightsail::StartRelationalDatabase>
4325  
4326 Returns: a L<Paws::Lightsail::StartRelationalDatabaseResult> instance
4327  
4328 Starts a specific database from a stopped state in Amazon Lightsail. To
4329 restart a database, use the C<reboot relational database> operation.
4330  
4331 The C<start relational database> operation supports tag-based access
4332 control via resource tags applied to the resource identified by
4333 relationalDatabaseName. For more information, see the Lightsail Dev
4334 Guide
4335 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4336  
4337  
4338 =head2 StopInstance
4339  
4340 =over
4341  
4342 =item InstanceName => Str
4343  
4344 =item [Force => Bool]
4345  
4346  
4347 =back
4348  
4349 Each argument is described in detail in: L<Paws::Lightsail::StopInstance>
4350  
4351 Returns: a L<Paws::Lightsail::StopInstanceResult> instance
4352  
4353 Stops a specific Amazon Lightsail instance that is currently running.
4354  
4355 When you start a stopped instance, Lightsail assigns a new public IP
4356 address to the instance. To use the same IP address after stopping and
4357 starting an instance, create a static IP address and attach it to the
4358 instance. For more information, see the Lightsail Dev Guide
4359 (https://lightsail.aws.amazon.com/ls/docs/en/articles/lightsail-create-static-ip).
4360  
4361 The C<stop instance> operation supports tag-based access control via
4362 resource tags applied to the resource identified by C<instance name>.
4363 For more information, see the Lightsail Dev Guide
4364 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4365  
4366  
4367 =head2 StopRelationalDatabase
4368  
4369 =over
4370  
4371 =item RelationalDatabaseName => Str
4372  
4373 =item [RelationalDatabaseSnapshotName => Str]
4374  
4375  
4376 =back
4377  
4378 Each argument is described in detail in: L<Paws::Lightsail::StopRelationalDatabase>
4379  
4380 Returns: a L<Paws::Lightsail::StopRelationalDatabaseResult> instance
4381  
4382 Stops a specific database that is currently running in Amazon
4383 Lightsail.
4384  
4385 The C<stop relational database> operation supports tag-based access
4386 control via resource tags applied to the resource identified by
4387 relationalDatabaseName. For more information, see the Lightsail Dev
4388 Guide
4389 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4390  
4391  
4392 =head2 TagResource
4393  
4394 =over
4395  
4396 =item ResourceName => Str
4397  
4398 =item Tags => ArrayRef[L<Paws::Lightsail::Tag>]
4399  
4400 =item [ResourceArn => Str]
4401  
4402  
4403 =back
4404  
4405 Each argument is described in detail in: L<Paws::Lightsail::TagResource>
4406  
4407 Returns: a L<Paws::Lightsail::TagResourceResult> instance
4408  
4409 Adds one or more tags to the specified Amazon Lightsail resource. Each
4410 resource can have a maximum of 50 tags. Each tag consists of a key and
4411 an optional value. Tag keys must be unique per resource. For more
4412 information about tags, see the Lightsail Dev Guide
4413 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-tags).
4414  
4415 The C<tag resource> operation supports tag-based access control via
4416 request tags and resource tags applied to the resource identified by
4417 C<resource name>. For more information, see the Lightsail Dev Guide
4418 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4419  
4420  
4421 =head2 TestAlarm
4422  
4423 =over
4424  
4425 =item AlarmName => Str
4426  
4427 =item State => Str
4428  
4429  
4430 =back
4431  
4432 Each argument is described in detail in: L<Paws::Lightsail::TestAlarm>
4433  
4434 Returns: a L<Paws::Lightsail::TestAlarmResult> instance
4435  
4436 Tests an alarm by displaying a banner on the Amazon Lightsail console.
4437 If a notification trigger is configured for the specified alarm, the
4438 test also sends a notification to the notification protocol (C<Email>
4439 and/or C<SMS>) configured for the alarm.
4440  
4441 An alarm is used to monitor a single metric for one of your resources.
4442 When a metric condition is met, the alarm can notify you by email, SMS
4443 text message, and a banner displayed on the Amazon Lightsail console.
4444 For more information, see Alarms in Amazon Lightsail
4445 (https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms).
4446  
4447  
4448 =head2 UnpeerVpc
4449  
4450  
4451  
4452  
4453  
4454  
4455 Each argument is described in detail in: L<Paws::Lightsail::UnpeerVpc>
4456  
4457 Returns: a L<Paws::Lightsail::UnpeerVpcResult> instance
4458  
4459 Attempts to unpeer the Lightsail VPC from the user's default VPC.
4460  
4461  
4462 =head2 UntagResource
4463  
4464 =over
4465  
4466 =item ResourceName => Str
4467  
4468 =item TagKeys => ArrayRef[Str|Undef]
4469  
4470 =item [ResourceArn => Str]
4471  
4472  
4473 =back
4474  
4475 Each argument is described in detail in: L<Paws::Lightsail::UntagResource>
4476  
4477 Returns: a L<Paws::Lightsail::UntagResourceResult> instance
4478  
4479 Deletes the specified set of tag keys and their values from the
4480 specified Amazon Lightsail resource.
4481  
4482 The C<untag resource> operation supports tag-based access control via
4483 request tags and resource tags applied to the resource identified by
4484 C<resource name>. For more information, see the Lightsail Dev Guide
4485 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4486  
4487  
4488 =head2 UpdateContainerService
4489  
4490 =over
4491  
4492 =item ServiceName => Str
4493  
4494 =item [IsDisabled => Bool]
4495  
4496 =item [Power => Str]
4497  
4498 =item [PublicDomainNames => L<Paws::Lightsail::ContainerServicePublicDomains>]
4499  
4500 =item [Scale => Int]
4501  
4502  
4503 =back
4504  
4505 Each argument is described in detail in: L<Paws::Lightsail::UpdateContainerService>
4506  
4507 Returns: a L<Paws::Lightsail::UpdateContainerServiceResult> instance
4508  
4509 Updates the configuration of your Amazon Lightsail container service,
4510 such as its power, scale, and public domain names.
4511  
4512  
4513 =head2 UpdateDistribution
4514  
4515 =over
4516  
4517 =item DistributionName => Str
4518  
4519 =item [CacheBehaviors => ArrayRef[L<Paws::Lightsail::CacheBehaviorPerPath>]]
4520  
4521 =item [CacheBehaviorSettings => L<Paws::Lightsail::CacheSettings>]
4522  
4523 =item [DefaultCacheBehavior => L<Paws::Lightsail::CacheBehavior>]
4524  
4525 =item [IsEnabled => Bool]
4526  
4527 =item [Origin => L<Paws::Lightsail::InputOrigin>]
4528  
4529  
4530 =back
4531  
4532 Each argument is described in detail in: L<Paws::Lightsail::UpdateDistribution>
4533  
4534 Returns: a L<Paws::Lightsail::UpdateDistributionResult> instance
4535  
4536 Updates an existing Amazon Lightsail content delivery network (CDN)
4537 distribution.
4538  
4539 Use this action to update the configuration of your existing
4540 distribution
4541  
4542  
4543 =head2 UpdateDistributionBundle
4544  
4545 =over
4546  
4547 =item [BundleId => Str]
4548  
4549 =item [DistributionName => Str]
4550  
4551  
4552 =back
4553  
4554 Each argument is described in detail in: L<Paws::Lightsail::UpdateDistributionBundle>
4555  
4556 Returns: a L<Paws::Lightsail::UpdateDistributionBundleResult> instance
4557  
4558 Updates the bundle of your Amazon Lightsail content delivery network
4559 (CDN) distribution.
4560  
4561 A distribution bundle specifies the monthly network transfer quota and
4562 monthly cost of your dsitribution.
4563  
4564 Update your distribution's bundle if your distribution is going over
4565 its monthly network transfer quota and is incurring an overage fee.
4566  
4567 You can update your distribution's bundle only one time within your
4568 monthly AWS billing cycle. To determine if you can update your
4569 distribution's bundle, use the C<GetDistributions> action. The
4570 C<ableToUpdateBundle> parameter in the result will indicate whether you
4571 can currently update your distribution's bundle.
4572  
4573  
4574 =head2 UpdateDomainEntry
4575  
4576 =over
4577  
4578 =item DomainEntry => L<Paws::Lightsail::DomainEntry>
4579  
4580 =item DomainName => Str
4581  
4582  
4583 =back
4584  
4585 Each argument is described in detail in: L<Paws::Lightsail::UpdateDomainEntry>
4586  
4587 Returns: a L<Paws::Lightsail::UpdateDomainEntryResult> instance
4588  
4589 Updates a domain recordset after it is created.
4590  
4591 The C<update domain entry> operation supports tag-based access control
4592 via resource tags applied to the resource identified by C<domain name>.
4593 For more information, see the Lightsail Dev Guide
4594 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4595  
4596  
4597 =head2 UpdateLoadBalancerAttribute
4598  
4599 =over
4600  
4601 =item AttributeName => Str
4602  
4603 =item AttributeValue => Str
4604  
4605 =item LoadBalancerName => Str
4606  
4607  
4608 =back
4609  
4610 Each argument is described in detail in: L<Paws::Lightsail::UpdateLoadBalancerAttribute>
4611  
4612 Returns: a L<Paws::Lightsail::UpdateLoadBalancerAttributeResult> instance
4613  
4614 Updates the specified attribute for a load balancer. You can only
4615 update one attribute at a time.
4616  
4617 The C<update load balancer attribute> operation supports tag-based
4618 access control via resource tags applied to the resource identified by
4619 C<load balancer name>. For more information, see the Lightsail Dev
4620 Guide
4621 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4622  
4623  
4624 =head2 UpdateRelationalDatabase
4625  
4626 =over
4627  
4628 =item RelationalDatabaseName => Str
4629  
4630 =item [ApplyImmediately => Bool]
4631  
4632 =item [CaCertificateIdentifier => Str]
4633  
4634 =item [DisableBackupRetention => Bool]
4635  
4636 =item [EnableBackupRetention => Bool]
4637  
4638 =item [MasterUserPassword => Str]
4639  
4640 =item [PreferredBackupWindow => Str]
4641  
4642 =item [PreferredMaintenanceWindow => Str]
4643  
4644 =item [PubliclyAccessible => Bool]
4645  
4646 =item [RotateMasterUserPassword => Bool]
4647  
4648  
4649 =back
4650  
4651 Each argument is described in detail in: L<Paws::Lightsail::UpdateRelationalDatabase>
4652  
4653 Returns: a L<Paws::Lightsail::UpdateRelationalDatabaseResult> instance
4654  
4655 Allows the update of one or more attributes of a database in Amazon
4656 Lightsail.
4657  
4658 Updates are applied immediately, or in cases where the updates could
4659 result in an outage, are applied during the database's predefined
4660 maintenance window.
4661  
4662 The C<update relational database> operation supports tag-based access
4663 control via resource tags applied to the resource identified by
4664 relationalDatabaseName. For more information, see the Lightsail Dev
4665 Guide
4666 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4667  
4668  
4669 =head2 UpdateRelationalDatabaseParameters
4670  
4671 =over
4672  
4673 =item Parameters => ArrayRef[L<Paws::Lightsail::RelationalDatabaseParameter>]
4674  
4675 =item RelationalDatabaseName => Str
4676  
4677  
4678 =back
4679  
4680 Each argument is described in detail in: L<Paws::Lightsail::UpdateRelationalDatabaseParameters>
4681  
4682 Returns: a L<Paws::Lightsail::UpdateRelationalDatabaseParametersResult> instance
4683  
4684 Allows the update of one or more parameters of a database in Amazon
4685 Lightsail.
4686  
4687 Parameter updates don't cause outages; therefore, their application is
4688 not subject to the preferred maintenance window. However, there are two
4689 ways in which parameter updates are applied: C<dynamic> or
4690 C<pending-reboot>. Parameters marked with a C<dynamic> apply type are
4691 applied immediately. Parameters marked with a C<pending-reboot> apply
4692 type are applied only after the database is rebooted using the C<reboot
4693 relational database> operation.
4694  
4695 The C<update relational database parameters> operation supports
4696 tag-based access control via resource tags applied to the resource
4697 identified by relationalDatabaseName. For more information, see the
4698 Lightsail Dev Guide
4699 (https://lightsail.aws.amazon.com/ls/docs/en/articles/amazon-lightsail-controlling-access-using-tags).
4700  
4701  
4702  
4703  
4704 =head1 PAGINATORS
4705  
4706 Paginator methods are helpers that repetively call methods that return partial results
4707  
4708 =head2 GetAllActiveNames(sub { },[PageToken => Str])
4709  
4710 =head2 GetAllActiveNames([PageToken => Str])
4711  
4712  
4713 If passed a sub as first parameter, it will call the sub for each element found in :
4714  
4715 - activeNames, passing the object as the first parameter, and the string 'activeNames' as the second parameter
4716  
4717 If not, it will return a a L<Paws::Lightsail::GetActiveNamesResult> 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.
4718  
4719  
4720 =head2 GetAllBlueprints(sub { },[IncludeInactive => Bool, PageToken => Str])
4721  
4722 =head2 GetAllBlueprints([IncludeInactive => Bool, PageToken => Str])
4723  
4724  
4725 If passed a sub as first parameter, it will call the sub for each element found in :
4726  
4727 - blueprints, passing the object as the first parameter, and the string 'blueprints' as the second parameter
4728  
4729 If not, it will return a a L<Paws::Lightsail::GetBlueprintsResult> 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.
4730  
4731  
4732 =head2 GetAllBundles(sub { },[IncludeInactive => Bool, PageToken => Str])
4733  
4734 =head2 GetAllBundles([IncludeInactive => Bool, PageToken => Str])
4735  
4736  
4737 If passed a sub as first parameter, it will call the sub for each element found in :
4738  
4739 - bundles, passing the object as the first parameter, and the string 'bundles' as the second parameter
4740  
4741 If not, it will return a a L<Paws::Lightsail::GetBundlesResult> 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.
4742  
4743  
4744 =head2 GetAllCloudFormationStackRecords(sub { },[PageToken => Str])
4745  
4746 =head2 GetAllCloudFormationStackRecords([PageToken => Str])
4747  
4748  
4749 If passed a sub as first parameter, it will call the sub for each element found in :
4750  
4751 - cloudFormationStackRecords, passing the object as the first parameter, and the string 'cloudFormationStackRecords' as the second parameter
4752  
4753 If not, it will return a a L<Paws::Lightsail::GetCloudFormationStackRecordsResult> 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.
4754  
4755  
4756 =head2 GetAllDisks(sub { },[PageToken => Str])
4757  
4758 =head2 GetAllDisks([PageToken => Str])
4759  
4760  
4761 If passed a sub as first parameter, it will call the sub for each element found in :
4762  
4763 - disks, passing the object as the first parameter, and the string 'disks' as the second parameter
4764  
4765 If not, it will return a a L<Paws::Lightsail::GetDisksResult> 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.
4766  
4767  
4768 =head2 GetAllDiskSnapshots(sub { },[PageToken => Str])
4769  
4770 =head2 GetAllDiskSnapshots([PageToken => Str])
4771  
4772  
4773 If passed a sub as first parameter, it will call the sub for each element found in :
4774  
4775 - diskSnapshots, passing the object as the first parameter, and the string 'diskSnapshots' as the second parameter
4776  
4777 If not, it will return a a L<Paws::Lightsail::GetDiskSnapshotsResult> 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.
4778  
4779  
4780 =head2 GetAllDomains(sub { },[PageToken => Str])
4781  
4782 =head2 GetAllDomains([PageToken => Str])
4783  
4784  
4785 If passed a sub as first parameter, it will call the sub for each element found in :
4786  
4787 - domains, passing the object as the first parameter, and the string 'domains' as the second parameter
4788  
4789 If not, it will return a a L<Paws::Lightsail::GetDomainsResult> 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.
4790  
4791  
4792 =head2 GetAllExportSnapshotRecords(sub { },[PageToken => Str])
4793  
4794 =head2 GetAllExportSnapshotRecords([PageToken => Str])
4795  
4796  
4797 If passed a sub as first parameter, it will call the sub for each element found in :
4798  
4799 - exportSnapshotRecords, passing the object as the first parameter, and the string 'exportSnapshotRecords' as the second parameter
4800  
4801 If not, it will return a a L<Paws::Lightsail::GetExportSnapshotRecordsResult> 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.
4802  
4803  
4804 =head2 GetAllInstances(sub { },[PageToken => Str])
4805  
4806 =head2 GetAllInstances([PageToken => Str])
4807  
4808  
4809 If passed a sub as first parameter, it will call the sub for each element found in :
4810  
4811 - instances, passing the object as the first parameter, and the string 'instances' as the second parameter
4812  
4813 If not, it will return a a L<Paws::Lightsail::GetInstancesResult> 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.
4814  
4815  
4816 =head2 GetAllInstanceSnapshots(sub { },[PageToken => Str])
4817  
4818 =head2 GetAllInstanceSnapshots([PageToken => Str])
4819  
4820  
4821 If passed a sub as first parameter, it will call the sub for each element found in :
4822  
4823 - instanceSnapshots, passing the object as the first parameter, and the string 'instanceSnapshots' as the second parameter
4824  
4825 If not, it will return a a L<Paws::Lightsail::GetInstanceSnapshotsResult> 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.
4826  
4827  
4828 =head2 GetAllKeyPairs(sub { },[PageToken => Str])
4829  
4830 =head2 GetAllKeyPairs([PageToken => Str])
4831  
4832  
4833 If passed a sub as first parameter, it will call the sub for each element found in :
4834  
4835 - keyPairs, passing the object as the first parameter, and the string 'keyPairs' as the second parameter
4836  
4837 If not, it will return a a L<Paws::Lightsail::GetKeyPairsResult> 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.
4838  
4839  
4840 =head2 GetAllLoadBalancers(sub { },[PageToken => Str])
4841  
4842 =head2 GetAllLoadBalancers([PageToken => Str])
4843  
4844  
4845 If passed a sub as first parameter, it will call the sub for each element found in :
4846  
4847 - loadBalancers, passing the object as the first parameter, and the string 'loadBalancers' as the second parameter
4848  
4849 If not, it will return a a L<Paws::Lightsail::GetLoadBalancersResult> 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.
4850  
4851  
4852 =head2 GetAllOperations(sub { },[PageToken => Str])
4853  
4854 =head2 GetAllOperations([PageToken => Str])
4855  
4856  
4857 If passed a sub as first parameter, it will call the sub for each element found in :
4858  
4859 - operations, passing the object as the first parameter, and the string 'operations' as the second parameter
4860  
4861 If not, it will return a a L<Paws::Lightsail::GetOperationsResult> 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.
4862  
4863  
4864 =head2 GetAllRelationalDatabaseBlueprints(sub { },[PageToken => Str])
4865  
4866 =head2 GetAllRelationalDatabaseBlueprints([PageToken => Str])
4867  
4868  
4869 If passed a sub as first parameter, it will call the sub for each element found in :
4870  
4871 - blueprints, passing the object as the first parameter, and the string 'blueprints' as the second parameter
4872  
4873 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabaseBlueprintsResult> 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.
4874  
4875  
4876 =head2 GetAllRelationalDatabaseBundles(sub { },[PageToken => Str])
4877  
4878 =head2 GetAllRelationalDatabaseBundles([PageToken => Str])
4879  
4880  
4881 If passed a sub as first parameter, it will call the sub for each element found in :
4882  
4883 - bundles, passing the object as the first parameter, and the string 'bundles' as the second parameter
4884  
4885 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabaseBundlesResult> 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.
4886  
4887  
4888 =head2 GetAllRelationalDatabaseEvents(sub { },RelationalDatabaseName => Str, [DurationInMinutes => Int, PageToken => Str])
4889  
4890 =head2 GetAllRelationalDatabaseEvents(RelationalDatabaseName => Str, [DurationInMinutes => Int, PageToken => Str])
4891  
4892  
4893 If passed a sub as first parameter, it will call the sub for each element found in :
4894  
4895 - relationalDatabaseEvents, passing the object as the first parameter, and the string 'relationalDatabaseEvents' as the second parameter
4896  
4897 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabaseEventsResult> 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.
4898  
4899  
4900 =head2 GetAllRelationalDatabaseParameters(sub { },RelationalDatabaseName => Str, [PageToken => Str])
4901  
4902 =head2 GetAllRelationalDatabaseParameters(RelationalDatabaseName => Str, [PageToken => Str])
4903  
4904  
4905 If passed a sub as first parameter, it will call the sub for each element found in :
4906  
4907 - parameters, passing the object as the first parameter, and the string 'parameters' as the second parameter
4908  
4909 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabaseParametersResult> 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.
4910  
4911  
4912 =head2 GetAllRelationalDatabases(sub { },[PageToken => Str])
4913  
4914 =head2 GetAllRelationalDatabases([PageToken => Str])
4915  
4916  
4917 If passed a sub as first parameter, it will call the sub for each element found in :
4918  
4919 - relationalDatabases, passing the object as the first parameter, and the string 'relationalDatabases' as the second parameter
4920  
4921 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabasesResult> 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.
4922  
4923  
4924 =head2 GetAllRelationalDatabaseSnapshots(sub { },[PageToken => Str])
4925  
4926 =head2 GetAllRelationalDatabaseSnapshots([PageToken => Str])
4927  
4928  
4929 If passed a sub as first parameter, it will call the sub for each element found in :
4930  
4931 - relationalDatabaseSnapshots, passing the object as the first parameter, and the string 'relationalDatabaseSnapshots' as the second parameter
4932  
4933 If not, it will return a a L<Paws::Lightsail::GetRelationalDatabaseSnapshotsResult> 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.
4934  
4935  
4936 =head2 GetAllStaticIps(sub { },[PageToken => Str])
4937  
4938 =head2 GetAllStaticIps([PageToken => Str])
4939  
4940  
4941 If passed a sub as first parameter, it will call the sub for each element found in :
4942  
4943 - staticIps, passing the object as the first parameter, and the string 'staticIps' as the second parameter
4944  
4945 If not, it will return a a L<Paws::Lightsail::GetStaticIpsResult> 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.
4946  
4947  
4948  
4949  
4950  
4951 =head1 SEE ALSO
4952  
4953 This service class forms part of L<Paws>
4954  
4955 =head1 BUGS and CONTRIBUTIONS
4956  
4957 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
4958  
4959 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
4960  
4961 =cut
4962