blib/lib/Paws/ECR.pm untested

filter: Statementstmt 0.0% 0 / 217 Branchbran 0.0% 0 / 20 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 46 Podpod 0.0% 0 / 45 totaltotal 0.0% 0 / 328 CC 11 SCAR 15.4
CC
11
Cov
0%
DescribeAllImages
12.0
DescribeAllImageScanFindings
12.0
DescribeAllRepositories
12.0
CRAP 4.7
1 package Paws::ECR;
2 use Moose;
3 sub service { 'api.ecr' }
4 sub signing_name { 'ecr' }
5 sub version { '2015-09-21' }
6 sub target_prefix { 'AmazonEC2ContainerRegistry_V20150921' }
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 BatchCheckLayerAvailability {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::ECR::BatchCheckLayerAvailability', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub BatchDeleteImage {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::ECR::BatchDeleteImage', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub BatchGetImage {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::ECR::BatchGetImage', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CompleteLayerUpload {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::ECR::CompleteLayerUpload', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateRepository {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::ECR::CreateRepository', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DeleteLifecyclePolicy {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::ECR::DeleteLifecyclePolicy', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DeleteRegistryPolicy {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::ECR::DeleteRegistryPolicy', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteRepository {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::ECR::DeleteRepository', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeleteRepositoryPolicy {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::ECR::DeleteRepositoryPolicy', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DescribeImages {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::ECR::DescribeImages', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DescribeImageScanFindings {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::ECR::DescribeImageScanFindings', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DescribeRegistry {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::ECR::DescribeRegistry', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DescribeRepositories {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::ECR::DescribeRepositories', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub GetAuthorizationToken {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::ECR::GetAuthorizationToken', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub GetDownloadUrlForLayer {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::ECR::GetDownloadUrlForLayer', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub GetLifecyclePolicy {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::ECR::GetLifecyclePolicy', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub GetLifecyclePolicyPreview {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::ECR::GetLifecyclePolicyPreview', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub GetRegistryPolicy {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::ECR::GetRegistryPolicy', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub GetRepositoryPolicy {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::ECR::GetRepositoryPolicy', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub InitiateLayerUpload {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::ECR::InitiateLayerUpload', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub ListImages {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::ECR::ListImages', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub ListTagsForResource {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::ECR::ListTagsForResource', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub PutImage {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::ECR::PutImage', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub PutImageScanningConfiguration {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::ECR::PutImageScanningConfiguration', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub PutImageTagMutability {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::ECR::PutImageTagMutability', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub PutLifecyclePolicy {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::ECR::PutLifecyclePolicy', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub PutRegistryPolicy {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::ECR::PutRegistryPolicy', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub PutReplicationConfiguration {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::ECR::PutReplicationConfiguration', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub SetRepositoryPolicy {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::ECR::SetRepositoryPolicy', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub StartImageScan {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::ECR::StartImageScan', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub StartLifecyclePolicyPreview {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::ECR::StartLifecyclePolicyPreview', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub TagResource {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::ECR::TagResource', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub UntagResource {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::ECR::UntagResource', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub UploadLayerPart {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::ECR::UploadLayerPart', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188
189 sub DescribeAllImages {
190 my $self = shift;
191  
192 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
193 my $result = $self->DescribeImages(@_);
194 my $next_result = $result;
195  
196 if (not defined $callback) {
197 while ($next_result->nextToken) {
198 $next_result = $self->DescribeImages(@_, nextToken => $next_result->nextToken);
199 push @{ $result->imageDetails }, @{ $next_result->imageDetails };
200 }
201 return $result;
202 } else {
203 while ($result->nextToken) {
204 $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
205 $result = $self->DescribeImages(@_, nextToken => $result->nextToken);
206 }
207 $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
208 }
209  
210 return undef
211 }
212 sub DescribeAllImageScanFindings {
213 my $self = shift;
214  
215 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
216 my $result = $self->DescribeImageScanFindings(@_);
217 my $next_result = $result;
218  
219 if (not defined $callback) {
220 while ($next_result->nextToken) {
221 $next_result = $self->DescribeImageScanFindings(@_, nextToken => $next_result->nextToken);
222 push @{ $result->imageScanFindings->findings }, @{ $next_result->imageScanFindings->findings };
223 }
224 return $result;
225 } else {
226 while ($result->nextToken) {
227 $callback->($_ => 'imageScanFindings.findings') foreach (@{ $result->imageScanFindings->findings });
228 $result = $self->DescribeImageScanFindings(@_, nextToken => $result->nextToken);
229 }
230 $callback->($_ => 'imageScanFindings.findings') foreach (@{ $result->imageScanFindings->findings });
231 }
232  
233 return undef
234 }
235 sub DescribeAllRepositories {
236 my $self = shift;
237  
238 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
239 my $result = $self->DescribeRepositories(@_);
240 my $next_result = $result;
241  
242 if (not defined $callback) {
243 while ($next_result->nextToken) {
244 $next_result = $self->DescribeRepositories(@_, nextToken => $next_result->nextToken);
245 push @{ $result->repositories }, @{ $next_result->repositories };
246 }
247 return $result;
248 } else {
249 while ($result->nextToken) {
250 $callback->($_ => 'repositories') foreach (@{ $result->repositories });
251 $result = $self->DescribeRepositories(@_, nextToken => $result->nextToken);
252 }
253 $callback->($_ => 'repositories') foreach (@{ $result->repositories });
254 }
255  
256 return undef
257 }
258 sub GetAllLifecyclePolicyPreview {
259 my $self = shift;
260  
261 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
262 my $result = $self->GetLifecyclePolicyPreview(@_);
263 my $next_result = $result;
264  
265 if (not defined $callback) {
266 while ($next_result->nextToken) {
267 $next_result = $self->GetLifecyclePolicyPreview(@_, nextToken => $next_result->nextToken);
268 push @{ $result->previewResults }, @{ $next_result->previewResults };
269 }
270 return $result;
271 } else {
272 while ($result->nextToken) {
273 $callback->($_ => 'previewResults') foreach (@{ $result->previewResults });
274 $result = $self->GetLifecyclePolicyPreview(@_, nextToken => $result->nextToken);
275 }
276 $callback->($_ => 'previewResults') foreach (@{ $result->previewResults });
277 }
278  
279 return undef
280 }
281 sub ListAllImages {
282 my $self = shift;
283  
284 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
285 my $result = $self->ListImages(@_);
286 my $next_result = $result;
287  
288 if (not defined $callback) {
289 while ($next_result->nextToken) {
290 $next_result = $self->ListImages(@_, nextToken => $next_result->nextToken);
291 push @{ $result->imageIds }, @{ $next_result->imageIds };
292 }
293 return $result;
294 } else {
295 while ($result->nextToken) {
296 $callback->($_ => 'imageIds') foreach (@{ $result->imageIds });
297 $result = $self->ListImages(@_, nextToken => $result->nextToken);
298 }
299 $callback->($_ => 'imageIds') foreach (@{ $result->imageIds });
300 }
301  
302 return undef
303 }
304  
305  
306 sub operations { qw/BatchCheckLayerAvailability BatchDeleteImage BatchGetImage CompleteLayerUpload CreateRepository DeleteLifecyclePolicy DeleteRegistryPolicy DeleteRepository DeleteRepositoryPolicy DescribeImages DescribeImageScanFindings DescribeRegistry DescribeRepositories GetAuthorizationToken GetDownloadUrlForLayer GetLifecyclePolicy GetLifecyclePolicyPreview GetRegistryPolicy GetRepositoryPolicy InitiateLayerUpload ListImages ListTagsForResource PutImage PutImageScanningConfiguration PutImageTagMutability PutLifecyclePolicy PutRegistryPolicy PutReplicationConfiguration SetRepositoryPolicy StartImageScan StartLifecyclePolicyPreview TagResource UntagResource UploadLayerPart / }
307  
308 1;
309  
310 ### main pod documentation begin ###
311  
312 =head1 NAME
313  
314 Paws::ECR - Perl Interface to AWS Amazon EC2 Container Registry
315  
316 =head1 SYNOPSIS
317  
318 use Paws;
319  
320 my $obj = Paws->service('ECR');
321 my $res = $obj->Method(
322 Arg1 => $val1,
323 Arg2 => [ 'V1', 'V2' ],
324 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
325 # of the arguments type
326 Arg3 => { Att1 => 'Val1' },
327 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
328 # the constructor of the arguments type
329 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
330 );
331  
332 =head1 DESCRIPTION
333  
334 Amazon Elastic Container Registry
335  
336 Amazon Elastic Container Registry (Amazon ECR) is a managed container
337 image registry service. Customers can use the familiar Docker CLI, or
338 their preferred client, to push, pull, and manage images. Amazon ECR
339 provides a secure, scalable, and reliable registry for your Docker or
340 Open Container Initiative (OCI) images. Amazon ECR supports private
341 repositories with resource-based permissions using IAM so that specific
342 users or Amazon EC2 instances can access repositories and images.
343  
344 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/api.ecr-2015-09-21>
345  
346  
347 =head1 METHODS
348  
349 =head2 BatchCheckLayerAvailability
350  
351 =over
352  
353 =item LayerDigests => ArrayRef[Str|Undef]
354  
355 =item RepositoryName => Str
356  
357 =item [RegistryId => Str]
358  
359  
360 =back
361  
362 Each argument is described in detail in: L<Paws::ECR::BatchCheckLayerAvailability>
363  
364 Returns: a L<Paws::ECR::BatchCheckLayerAvailabilityResponse> instance
365  
366 Checks the availability of one or more image layers in a repository.
367  
368 When an image is pushed to a repository, each image layer is checked to
369 verify if it has been uploaded before. If it has been uploaded, then
370 the image layer is skipped.
371  
372 This operation is used by the Amazon ECR proxy and is not generally
373 used by customers for pulling and pushing images. In most cases, you
374 should use the C<docker> CLI to pull, tag, and push images.
375  
376  
377 =head2 BatchDeleteImage
378  
379 =over
380  
381 =item ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>]
382  
383 =item RepositoryName => Str
384  
385 =item [RegistryId => Str]
386  
387  
388 =back
389  
390 Each argument is described in detail in: L<Paws::ECR::BatchDeleteImage>
391  
392 Returns: a L<Paws::ECR::BatchDeleteImageResponse> instance
393  
394 Deletes a list of specified images within a repository. Images are
395 specified with either an C<imageTag> or C<imageDigest>.
396  
397 You can remove a tag from an image by specifying the image's tag in
398 your request. When you remove the last tag from an image, the image is
399 deleted from your repository.
400  
401 You can completely delete an image (and all of its tags) by specifying
402 the image's digest in your request.
403  
404  
405 =head2 BatchGetImage
406  
407 =over
408  
409 =item ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>]
410  
411 =item RepositoryName => Str
412  
413 =item [AcceptedMediaTypes => ArrayRef[Str|Undef]]
414  
415 =item [RegistryId => Str]
416  
417  
418 =back
419  
420 Each argument is described in detail in: L<Paws::ECR::BatchGetImage>
421  
422 Returns: a L<Paws::ECR::BatchGetImageResponse> instance
423  
424 Gets detailed information for an image. Images are specified with
425 either an C<imageTag> or C<imageDigest>.
426  
427 When an image is pulled, the BatchGetImage API is called once to
428 retrieve the image manifest.
429  
430  
431 =head2 CompleteLayerUpload
432  
433 =over
434  
435 =item LayerDigests => ArrayRef[Str|Undef]
436  
437 =item RepositoryName => Str
438  
439 =item UploadId => Str
440  
441 =item [RegistryId => Str]
442  
443  
444 =back
445  
446 Each argument is described in detail in: L<Paws::ECR::CompleteLayerUpload>
447  
448 Returns: a L<Paws::ECR::CompleteLayerUploadResponse> instance
449  
450 Informs Amazon ECR that the image layer upload has completed for a
451 specified registry, repository name, and upload ID. You can optionally
452 provide a C<sha256> digest of the image layer for data validation
453 purposes.
454  
455 When an image is pushed, the CompleteLayerUpload API is called once per
456 each new image layer to verify that the upload has completed.
457  
458 This operation is used by the Amazon ECR proxy and is not generally
459 used by customers for pulling and pushing images. In most cases, you
460 should use the C<docker> CLI to pull, tag, and push images.
461  
462  
463 =head2 CreateRepository
464  
465 =over
466  
467 =item RepositoryName => Str
468  
469 =item [EncryptionConfiguration => L<Paws::ECR::EncryptionConfiguration>]
470  
471 =item [ImageScanningConfiguration => L<Paws::ECR::ImageScanningConfiguration>]
472  
473 =item [ImageTagMutability => Str]
474  
475 =item [Tags => ArrayRef[L<Paws::ECR::Tag>]]
476  
477  
478 =back
479  
480 Each argument is described in detail in: L<Paws::ECR::CreateRepository>
481  
482 Returns: a L<Paws::ECR::CreateRepositoryResponse> instance
483  
484 Creates a repository. For more information, see Amazon ECR Repositories
485 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html)
486 in the I<Amazon Elastic Container Registry User Guide>.
487  
488  
489 =head2 DeleteLifecyclePolicy
490  
491 =over
492  
493 =item RepositoryName => Str
494  
495 =item [RegistryId => Str]
496  
497  
498 =back
499  
500 Each argument is described in detail in: L<Paws::ECR::DeleteLifecyclePolicy>
501  
502 Returns: a L<Paws::ECR::DeleteLifecyclePolicyResponse> instance
503  
504 Deletes the lifecycle policy associated with the specified repository.
505  
506  
507 =head2 DeleteRegistryPolicy
508  
509  
510  
511  
512  
513  
514 Each argument is described in detail in: L<Paws::ECR::DeleteRegistryPolicy>
515  
516 Returns: a L<Paws::ECR::DeleteRegistryPolicyResponse> instance
517  
518 Deletes the registry permissions policy.
519  
520  
521 =head2 DeleteRepository
522  
523 =over
524  
525 =item RepositoryName => Str
526  
527 =item [Force => Bool]
528  
529 =item [RegistryId => Str]
530  
531  
532 =back
533  
534 Each argument is described in detail in: L<Paws::ECR::DeleteRepository>
535  
536 Returns: a L<Paws::ECR::DeleteRepositoryResponse> instance
537  
538 Deletes a repository. If the repository contains images, you must
539 either delete all images in the repository or use the C<force> option
540 to delete the repository.
541  
542  
543 =head2 DeleteRepositoryPolicy
544  
545 =over
546  
547 =item RepositoryName => Str
548  
549 =item [RegistryId => Str]
550  
551  
552 =back
553  
554 Each argument is described in detail in: L<Paws::ECR::DeleteRepositoryPolicy>
555  
556 Returns: a L<Paws::ECR::DeleteRepositoryPolicyResponse> instance
557  
558 Deletes the repository policy associated with the specified repository.
559  
560  
561 =head2 DescribeImages
562  
563 =over
564  
565 =item RepositoryName => Str
566  
567 =item [Filter => L<Paws::ECR::DescribeImagesFilter>]
568  
569 =item [ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>]]
570  
571 =item [MaxResults => Int]
572  
573 =item [NextToken => Str]
574  
575 =item [RegistryId => Str]
576  
577  
578 =back
579  
580 Each argument is described in detail in: L<Paws::ECR::DescribeImages>
581  
582 Returns: a L<Paws::ECR::DescribeImagesResponse> instance
583  
584 Returns metadata about the images in a repository.
585  
586 Beginning with Docker version 1.9, the Docker client compresses image
587 layers before pushing them to a V2 Docker registry. The output of the
588 C<docker images> command shows the uncompressed image size, so it may
589 return a larger image size than the image sizes returned by
590 DescribeImages.
591  
592  
593 =head2 DescribeImageScanFindings
594  
595 =over
596  
597 =item ImageId => L<Paws::ECR::ImageIdentifier>
598  
599 =item RepositoryName => Str
600  
601 =item [MaxResults => Int]
602  
603 =item [NextToken => Str]
604  
605 =item [RegistryId => Str]
606  
607  
608 =back
609  
610 Each argument is described in detail in: L<Paws::ECR::DescribeImageScanFindings>
611  
612 Returns: a L<Paws::ECR::DescribeImageScanFindingsResponse> instance
613  
614 Returns the scan findings for the specified image.
615  
616  
617 =head2 DescribeRegistry
618  
619  
620  
621  
622  
623  
624 Each argument is described in detail in: L<Paws::ECR::DescribeRegistry>
625  
626 Returns: a L<Paws::ECR::DescribeRegistryResponse> instance
627  
628 Describes the settings for a registry. The replication configuration
629 for a repository can be created or updated with the
630 PutReplicationConfiguration API action.
631  
632  
633 =head2 DescribeRepositories
634  
635 =over
636  
637 =item [MaxResults => Int]
638  
639 =item [NextToken => Str]
640  
641 =item [RegistryId => Str]
642  
643 =item [RepositoryNames => ArrayRef[Str|Undef]]
644  
645  
646 =back
647  
648 Each argument is described in detail in: L<Paws::ECR::DescribeRepositories>
649  
650 Returns: a L<Paws::ECR::DescribeRepositoriesResponse> instance
651  
652 Describes image repositories in a registry.
653  
654  
655 =head2 GetAuthorizationToken
656  
657 =over
658  
659 =item [RegistryIds => ArrayRef[Str|Undef]]
660  
661  
662 =back
663  
664 Each argument is described in detail in: L<Paws::ECR::GetAuthorizationToken>
665  
666 Returns: a L<Paws::ECR::GetAuthorizationTokenResponse> instance
667  
668 Retrieves an authorization token. An authorization token represents
669 your IAM authentication credentials and can be used to access any
670 Amazon ECR registry that your IAM principal has access to. The
671 authorization token is valid for 12 hours.
672  
673 The C<authorizationToken> returned is a base64 encoded string that can
674 be decoded and used in a C<docker login> command to authenticate to a
675 registry. The AWS CLI offers an C<get-login-password> command that
676 simplifies the login process. For more information, see Registry
677 Authentication
678 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth)
679 in the I<Amazon Elastic Container Registry User Guide>.
680  
681  
682 =head2 GetDownloadUrlForLayer
683  
684 =over
685  
686 =item LayerDigest => Str
687  
688 =item RepositoryName => Str
689  
690 =item [RegistryId => Str]
691  
692  
693 =back
694  
695 Each argument is described in detail in: L<Paws::ECR::GetDownloadUrlForLayer>
696  
697 Returns: a L<Paws::ECR::GetDownloadUrlForLayerResponse> instance
698  
699 Retrieves the pre-signed Amazon S3 download URL corresponding to an
700 image layer. You can only get URLs for image layers that are referenced
701 in an image.
702  
703 When an image is pulled, the GetDownloadUrlForLayer API is called once
704 per image layer that is not already cached.
705  
706 This operation is used by the Amazon ECR proxy and is not generally
707 used by customers for pulling and pushing images. In most cases, you
708 should use the C<docker> CLI to pull, tag, and push images.
709  
710  
711 =head2 GetLifecyclePolicy
712  
713 =over
714  
715 =item RepositoryName => Str
716  
717 =item [RegistryId => Str]
718  
719  
720 =back
721  
722 Each argument is described in detail in: L<Paws::ECR::GetLifecyclePolicy>
723  
724 Returns: a L<Paws::ECR::GetLifecyclePolicyResponse> instance
725  
726 Retrieves the lifecycle policy for the specified repository.
727  
728  
729 =head2 GetLifecyclePolicyPreview
730  
731 =over
732  
733 =item RepositoryName => Str
734  
735 =item [Filter => L<Paws::ECR::LifecyclePolicyPreviewFilter>]
736  
737 =item [ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>]]
738  
739 =item [MaxResults => Int]
740  
741 =item [NextToken => Str]
742  
743 =item [RegistryId => Str]
744  
745  
746 =back
747  
748 Each argument is described in detail in: L<Paws::ECR::GetLifecyclePolicyPreview>
749  
750 Returns: a L<Paws::ECR::GetLifecyclePolicyPreviewResponse> instance
751  
752 Retrieves the results of the lifecycle policy preview request for the
753 specified repository.
754  
755  
756 =head2 GetRegistryPolicy
757  
758  
759  
760  
761  
762  
763 Each argument is described in detail in: L<Paws::ECR::GetRegistryPolicy>
764  
765 Returns: a L<Paws::ECR::GetRegistryPolicyResponse> instance
766  
767 Retrieves the permissions policy for a registry.
768  
769  
770 =head2 GetRepositoryPolicy
771  
772 =over
773  
774 =item RepositoryName => Str
775  
776 =item [RegistryId => Str]
777  
778  
779 =back
780  
781 Each argument is described in detail in: L<Paws::ECR::GetRepositoryPolicy>
782  
783 Returns: a L<Paws::ECR::GetRepositoryPolicyResponse> instance
784  
785 Retrieves the repository policy for the specified repository.
786  
787  
788 =head2 InitiateLayerUpload
789  
790 =over
791  
792 =item RepositoryName => Str
793  
794 =item [RegistryId => Str]
795  
796  
797 =back
798  
799 Each argument is described in detail in: L<Paws::ECR::InitiateLayerUpload>
800  
801 Returns: a L<Paws::ECR::InitiateLayerUploadResponse> instance
802  
803 Notifies Amazon ECR that you intend to upload an image layer.
804  
805 When an image is pushed, the InitiateLayerUpload API is called once per
806 image layer that has not already been uploaded. Whether or not an image
807 layer has been uploaded is determined by the
808 BatchCheckLayerAvailability API action.
809  
810 This operation is used by the Amazon ECR proxy and is not generally
811 used by customers for pulling and pushing images. In most cases, you
812 should use the C<docker> CLI to pull, tag, and push images.
813  
814  
815 =head2 ListImages
816  
817 =over
818  
819 =item RepositoryName => Str
820  
821 =item [Filter => L<Paws::ECR::ListImagesFilter>]
822  
823 =item [MaxResults => Int]
824  
825 =item [NextToken => Str]
826  
827 =item [RegistryId => Str]
828  
829  
830 =back
831  
832 Each argument is described in detail in: L<Paws::ECR::ListImages>
833  
834 Returns: a L<Paws::ECR::ListImagesResponse> instance
835  
836 Lists all the image IDs for the specified repository.
837  
838 You can filter images based on whether or not they are tagged by using
839 the C<tagStatus> filter and specifying either C<TAGGED>, C<UNTAGGED> or
840 C<ANY>. For example, you can filter your results to return only
841 C<UNTAGGED> images and then pipe that result to a BatchDeleteImage
842 operation to delete them. Or, you can filter your results to return
843 only C<TAGGED> images to list all of the tags in your repository.
844  
845  
846 =head2 ListTagsForResource
847  
848 =over
849  
850 =item ResourceArn => Str
851  
852  
853 =back
854  
855 Each argument is described in detail in: L<Paws::ECR::ListTagsForResource>
856  
857 Returns: a L<Paws::ECR::ListTagsForResourceResponse> instance
858  
859 List the tags for an Amazon ECR resource.
860  
861  
862 =head2 PutImage
863  
864 =over
865  
866 =item ImageManifest => Str
867  
868 =item RepositoryName => Str
869  
870 =item [ImageDigest => Str]
871  
872 =item [ImageManifestMediaType => Str]
873  
874 =item [ImageTag => Str]
875  
876 =item [RegistryId => Str]
877  
878  
879 =back
880  
881 Each argument is described in detail in: L<Paws::ECR::PutImage>
882  
883 Returns: a L<Paws::ECR::PutImageResponse> instance
884  
885 Creates or updates the image manifest and tags associated with an
886 image.
887  
888 When an image is pushed and all new image layers have been uploaded,
889 the PutImage API is called once to create or update the image manifest
890 and the tags associated with the image.
891  
892 This operation is used by the Amazon ECR proxy and is not generally
893 used by customers for pulling and pushing images. In most cases, you
894 should use the C<docker> CLI to pull, tag, and push images.
895  
896  
897 =head2 PutImageScanningConfiguration
898  
899 =over
900  
901 =item ImageScanningConfiguration => L<Paws::ECR::ImageScanningConfiguration>
902  
903 =item RepositoryName => Str
904  
905 =item [RegistryId => Str]
906  
907  
908 =back
909  
910 Each argument is described in detail in: L<Paws::ECR::PutImageScanningConfiguration>
911  
912 Returns: a L<Paws::ECR::PutImageScanningConfigurationResponse> instance
913  
914 Updates the image scanning configuration for the specified repository.
915  
916  
917 =head2 PutImageTagMutability
918  
919 =over
920  
921 =item ImageTagMutability => Str
922  
923 =item RepositoryName => Str
924  
925 =item [RegistryId => Str]
926  
927  
928 =back
929  
930 Each argument is described in detail in: L<Paws::ECR::PutImageTagMutability>
931  
932 Returns: a L<Paws::ECR::PutImageTagMutabilityResponse> instance
933  
934 Updates the image tag mutability settings for the specified repository.
935 For more information, see Image Tag Mutability
936 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-tag-mutability.html)
937 in the I<Amazon Elastic Container Registry User Guide>.
938  
939  
940 =head2 PutLifecyclePolicy
941  
942 =over
943  
944 =item LifecyclePolicyText => Str
945  
946 =item RepositoryName => Str
947  
948 =item [RegistryId => Str]
949  
950  
951 =back
952  
953 Each argument is described in detail in: L<Paws::ECR::PutLifecyclePolicy>
954  
955 Returns: a L<Paws::ECR::PutLifecyclePolicyResponse> instance
956  
957 Creates or updates the lifecycle policy for the specified repository.
958 For more information, see Lifecycle Policy Template
959 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).
960  
961  
962 =head2 PutRegistryPolicy
963  
964 =over
965  
966 =item PolicyText => Str
967  
968  
969 =back
970  
971 Each argument is described in detail in: L<Paws::ECR::PutRegistryPolicy>
972  
973 Returns: a L<Paws::ECR::PutRegistryPolicyResponse> instance
974  
975 Creates or updates the permissions policy for your registry.
976  
977 A registry policy is used to specify permissions for another AWS
978 account and is used when configuring cross-account replication. For
979 more information, see Registry permissions
980 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry-permissions.html)
981 in the I<Amazon Elastic Container Registry User Guide>.
982  
983  
984 =head2 PutReplicationConfiguration
985  
986 =over
987  
988 =item ReplicationConfiguration => L<Paws::ECR::ReplicationConfiguration>
989  
990  
991 =back
992  
993 Each argument is described in detail in: L<Paws::ECR::PutReplicationConfiguration>
994  
995 Returns: a L<Paws::ECR::PutReplicationConfigurationResponse> instance
996  
997 Creates or updates the replication configuration for a registry. The
998 existing replication configuration for a repository can be retrieved
999 with the DescribeRegistry API action. The first time the
1000 PutReplicationConfiguration API is called, a service-linked IAM role is
1001 created in your account for the replication process. For more
1002 information, see Using Service-Linked Roles for Amazon ECR
1003 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/using-service-linked-roles.html)
1004 in the I<Amazon Elastic Container Registry User Guide>.
1005  
1006 When configuring cross-account replication, the destination account
1007 must grant the source account permission to replicate. This permission
1008 is controlled using a registry permissions policy. For more
1009 information, see PutRegistryPolicy.
1010  
1011  
1012 =head2 SetRepositoryPolicy
1013  
1014 =over
1015  
1016 =item PolicyText => Str
1017  
1018 =item RepositoryName => Str
1019  
1020 =item [Force => Bool]
1021  
1022 =item [RegistryId => Str]
1023  
1024  
1025 =back
1026  
1027 Each argument is described in detail in: L<Paws::ECR::SetRepositoryPolicy>
1028  
1029 Returns: a L<Paws::ECR::SetRepositoryPolicyResponse> instance
1030  
1031 Applies a repository policy to the specified repository to control
1032 access permissions. For more information, see Amazon ECR Repository
1033 Policies
1034 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html)
1035 in the I<Amazon Elastic Container Registry User Guide>.
1036  
1037  
1038 =head2 StartImageScan
1039  
1040 =over
1041  
1042 =item ImageId => L<Paws::ECR::ImageIdentifier>
1043  
1044 =item RepositoryName => Str
1045  
1046 =item [RegistryId => Str]
1047  
1048  
1049 =back
1050  
1051 Each argument is described in detail in: L<Paws::ECR::StartImageScan>
1052  
1053 Returns: a L<Paws::ECR::StartImageScanResponse> instance
1054  
1055 Starts an image vulnerability scan. An image scan can only be started
1056 once per day on an individual image. This limit includes if an image
1057 was scanned on initial push. For more information, see Image Scanning
1058 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html)
1059 in the I<Amazon Elastic Container Registry User Guide>.
1060  
1061  
1062 =head2 StartLifecyclePolicyPreview
1063  
1064 =over
1065  
1066 =item RepositoryName => Str
1067  
1068 =item [LifecyclePolicyText => Str]
1069  
1070 =item [RegistryId => Str]
1071  
1072  
1073 =back
1074  
1075 Each argument is described in detail in: L<Paws::ECR::StartLifecyclePolicyPreview>
1076  
1077 Returns: a L<Paws::ECR::StartLifecyclePolicyPreviewResponse> instance
1078  
1079 Starts a preview of a lifecycle policy for the specified repository.
1080 This allows you to see the results before associating the lifecycle
1081 policy with the repository.
1082  
1083  
1084 =head2 TagResource
1085  
1086 =over
1087  
1088 =item ResourceArn => Str
1089  
1090 =item Tags => ArrayRef[L<Paws::ECR::Tag>]
1091  
1092  
1093 =back
1094  
1095 Each argument is described in detail in: L<Paws::ECR::TagResource>
1096  
1097 Returns: a L<Paws::ECR::TagResourceResponse> instance
1098  
1099 Adds specified tags to a resource with the specified ARN. Existing tags
1100 on a resource are not changed if they are not specified in the request
1101 parameters.
1102  
1103  
1104 =head2 UntagResource
1105  
1106 =over
1107  
1108 =item ResourceArn => Str
1109  
1110 =item TagKeys => ArrayRef[Str|Undef]
1111  
1112  
1113 =back
1114  
1115 Each argument is described in detail in: L<Paws::ECR::UntagResource>
1116  
1117 Returns: a L<Paws::ECR::UntagResourceResponse> instance
1118  
1119 Deletes specified tags from a resource.
1120  
1121  
1122 =head2 UploadLayerPart
1123  
1124 =over
1125  
1126 =item LayerPartBlob => Str
1127  
1128 =item PartFirstByte => Int
1129  
1130 =item PartLastByte => Int
1131  
1132 =item RepositoryName => Str
1133  
1134 =item UploadId => Str
1135  
1136 =item [RegistryId => Str]
1137  
1138  
1139 =back
1140  
1141 Each argument is described in detail in: L<Paws::ECR::UploadLayerPart>
1142  
1143 Returns: a L<Paws::ECR::UploadLayerPartResponse> instance
1144  
1145 Uploads an image layer part to Amazon ECR.
1146  
1147 When an image is pushed, each new image layer is uploaded in parts. The
1148 maximum size of each image layer part can be 20971520 bytes (or about
1149 20MB). The UploadLayerPart API is called once per each new image layer
1150 part.
1151  
1152 This operation is used by the Amazon ECR proxy and is not generally
1153 used by customers for pulling and pushing images. In most cases, you
1154 should use the C<docker> CLI to pull, tag, and push images.
1155  
1156  
1157  
1158  
1159 =head1 PAGINATORS
1160  
1161 Paginator methods are helpers that repetively call methods that return partial results
1162  
1163 =head2 DescribeAllImages(sub { },RepositoryName => Str, [Filter => L<Paws::ECR::DescribeImagesFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
1164  
1165 =head2 DescribeAllImages(RepositoryName => Str, [Filter => L<Paws::ECR::DescribeImagesFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
1166  
1167  
1168 If passed a sub as first parameter, it will call the sub for each element found in :
1169  
1170 - imageDetails, passing the object as the first parameter, and the string 'imageDetails' as the second parameter
1171  
1172 If not, it will return a a L<Paws::ECR::DescribeImagesResponse> 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.
1173  
1174  
1175 =head2 DescribeAllImageScanFindings(sub { },ImageId => L<Paws::ECR::ImageIdentifier>, RepositoryName => Str, [MaxResults => Int, NextToken => Str, RegistryId => Str])
1176  
1177 =head2 DescribeAllImageScanFindings(ImageId => L<Paws::ECR::ImageIdentifier>, RepositoryName => Str, [MaxResults => Int, NextToken => Str, RegistryId => Str])
1178  
1179  
1180 If passed a sub as first parameter, it will call the sub for each element found in :
1181  
1182 - imageScanFindings.findings, passing the object as the first parameter, and the string 'imageScanFindings.findings' as the second parameter
1183  
1184 If not, it will return a a L<Paws::ECR::DescribeImageScanFindingsResponse> 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.
1185  
1186  
1187 =head2 DescribeAllRepositories(sub { },[MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
1188  
1189 =head2 DescribeAllRepositories([MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
1190  
1191  
1192 If passed a sub as first parameter, it will call the sub for each element found in :
1193  
1194 - repositories, passing the object as the first parameter, and the string 'repositories' as the second parameter
1195  
1196 If not, it will return a a L<Paws::ECR::DescribeRepositoriesResponse> 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.
1197  
1198  
1199 =head2 GetAllLifecyclePolicyPreview(sub { },RepositoryName => Str, [Filter => L<Paws::ECR::LifecyclePolicyPreviewFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
1200  
1201 =head2 GetAllLifecyclePolicyPreview(RepositoryName => Str, [Filter => L<Paws::ECR::LifecyclePolicyPreviewFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
1202  
1203  
1204 If passed a sub as first parameter, it will call the sub for each element found in :
1205  
1206 - previewResults, passing the object as the first parameter, and the string 'previewResults' as the second parameter
1207  
1208 If not, it will return a a L<Paws::ECR::GetLifecyclePolicyPreviewResponse> 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.
1209  
1210  
1211 =head2 ListAllImages(sub { },RepositoryName => Str, [Filter => L<Paws::ECR::ListImagesFilter>, MaxResults => Int, NextToken => Str, RegistryId => Str])
1212  
1213 =head2 ListAllImages(RepositoryName => Str, [Filter => L<Paws::ECR::ListImagesFilter>, MaxResults => Int, NextToken => Str, RegistryId => Str])
1214  
1215  
1216 If passed a sub as first parameter, it will call the sub for each element found in :
1217  
1218 - imageIds, passing the object as the first parameter, and the string 'imageIds' as the second parameter
1219  
1220 If not, it will return a a L<Paws::ECR::ListImagesResponse> 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.
1221  
1222  
1223  
1224  
1225  
1226 =head1 SEE ALSO
1227  
1228 This service class forms part of L<Paws>
1229  
1230 =head1 BUGS and CONTRIBUTIONS
1231  
1232 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1233  
1234 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1235  
1236 =cut
1237