blib/lib/Paws/ECRPublic.pm untested

filter: Statementstmt 0.0% 0 / 164 Branchbran 0.0% 0 / 16 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 34 Podpod 0.0% 0 / 33 totaltotal 0.0% 0 / 247 CC 9 SCAR 15.8
CC
9
Cov
0%
DescribeAllImages
12.0
DescribeAllImageTags
12.0
DescribeAllRegistries
12.0
CRAP 4.9
1 package Paws::ECRPublic;
2 use Moose;
3 sub service { 'api.ecr-public' }
4 sub signing_name { 'ecr-public' }
5 sub version { '2020-10-30' }
6 sub target_prefix { 'SpencerFrontendService' }
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::ECRPublic::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::ECRPublic::BatchDeleteImage', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CompleteLayerUpload {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::ECRPublic::CompleteLayerUpload', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateRepository {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::ECRPublic::CreateRepository', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub DeleteRepository {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DeleteRepository', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DeleteRepositoryPolicy {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DeleteRepositoryPolicy', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DescribeImages {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DescribeImages', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DescribeImageTags {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DescribeImageTags', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DescribeRegistries {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DescribeRegistries', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DescribeRepositories {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::ECRPublic::DescribeRepositories', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub GetAuthorizationToken {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::ECRPublic::GetAuthorizationToken', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub GetRegistryCatalogData {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::ECRPublic::GetRegistryCatalogData', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub GetRepositoryCatalogData {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::ECRPublic::GetRepositoryCatalogData', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub GetRepositoryPolicy {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::ECRPublic::GetRepositoryPolicy', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub InitiateLayerUpload {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::ECRPublic::InitiateLayerUpload', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub ListTagsForResource {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::ECRPublic::ListTagsForResource', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub PutImage {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::ECRPublic::PutImage', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub PutRegistryCatalogData {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::ECRPublic::PutRegistryCatalogData', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub PutRepositoryCatalogData {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::ECRPublic::PutRepositoryCatalogData', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub SetRepositoryPolicy {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::ECRPublic::SetRepositoryPolicy', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub TagResource {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::ECRPublic::TagResource', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub UntagResource {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::ECRPublic::UntagResource', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub UploadLayerPart {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::ECRPublic::UploadLayerPart', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133
134 sub DescribeAllImages {
135 my $self = shift;
136  
137 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
138 my $result = $self->DescribeImages(@_);
139 my $next_result = $result;
140  
141 if (not defined $callback) {
142 while ($next_result->nextToken) {
143 $next_result = $self->DescribeImages(@_, nextToken => $next_result->nextToken);
144 push @{ $result->imageDetails }, @{ $next_result->imageDetails };
145 }
146 return $result;
147 } else {
148 while ($result->nextToken) {
149 $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
150 $result = $self->DescribeImages(@_, nextToken => $result->nextToken);
151 }
152 $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
153 }
154  
155 return undef
156 }
157 sub DescribeAllImageTags {
158 my $self = shift;
159  
160 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
161 my $result = $self->DescribeImageTags(@_);
162 my $next_result = $result;
163  
164 if (not defined $callback) {
165 while ($next_result->nextToken) {
166 $next_result = $self->DescribeImageTags(@_, nextToken => $next_result->nextToken);
167 push @{ $result->imageTagDetails }, @{ $next_result->imageTagDetails };
168 }
169 return $result;
170 } else {
171 while ($result->nextToken) {
172 $callback->($_ => 'imageTagDetails') foreach (@{ $result->imageTagDetails });
173 $result = $self->DescribeImageTags(@_, nextToken => $result->nextToken);
174 }
175 $callback->($_ => 'imageTagDetails') foreach (@{ $result->imageTagDetails });
176 }
177  
178 return undef
179 }
180 sub DescribeAllRegistries {
181 my $self = shift;
182  
183 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
184 my $result = $self->DescribeRegistries(@_);
185 my $next_result = $result;
186  
187 if (not defined $callback) {
188 while ($next_result->nextToken) {
189 $next_result = $self->DescribeRegistries(@_, nextToken => $next_result->nextToken);
190 push @{ $result->registries }, @{ $next_result->registries };
191 }
192 return $result;
193 } else {
194 while ($result->nextToken) {
195 $callback->($_ => 'registries') foreach (@{ $result->registries });
196 $result = $self->DescribeRegistries(@_, nextToken => $result->nextToken);
197 }
198 $callback->($_ => 'registries') foreach (@{ $result->registries });
199 }
200  
201 return undef
202 }
203 sub DescribeAllRepositories {
204 my $self = shift;
205  
206 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
207 my $result = $self->DescribeRepositories(@_);
208 my $next_result = $result;
209  
210 if (not defined $callback) {
211 while ($next_result->nextToken) {
212 $next_result = $self->DescribeRepositories(@_, nextToken => $next_result->nextToken);
213 push @{ $result->repositories }, @{ $next_result->repositories };
214 }
215 return $result;
216 } else {
217 while ($result->nextToken) {
218 $callback->($_ => 'repositories') foreach (@{ $result->repositories });
219 $result = $self->DescribeRepositories(@_, nextToken => $result->nextToken);
220 }
221 $callback->($_ => 'repositories') foreach (@{ $result->repositories });
222 }
223  
224 return undef
225 }
226  
227  
228 sub operations { qw/BatchCheckLayerAvailability BatchDeleteImage CompleteLayerUpload CreateRepository DeleteRepository DeleteRepositoryPolicy DescribeImages DescribeImageTags DescribeRegistries DescribeRepositories GetAuthorizationToken GetRegistryCatalogData GetRepositoryCatalogData GetRepositoryPolicy InitiateLayerUpload ListTagsForResource PutImage PutRegistryCatalogData PutRepositoryCatalogData SetRepositoryPolicy TagResource UntagResource UploadLayerPart / }
229  
230 1;
231  
232 ### main pod documentation begin ###
233  
234 =head1 NAME
235  
236 Paws::ECRPublic - Perl Interface to AWS Amazon Elastic Container Registry Public
237  
238 =head1 SYNOPSIS
239  
240 use Paws;
241  
242 my $obj = Paws->service('ECRPublic');
243 my $res = $obj->Method(
244 Arg1 => $val1,
245 Arg2 => [ 'V1', 'V2' ],
246 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
247 # of the arguments type
248 Arg3 => { Att1 => 'Val1' },
249 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
250 # the constructor of the arguments type
251 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
252 );
253  
254 =head1 DESCRIPTION
255  
256 Amazon Elastic Container Registry Public
257  
258 Amazon Elastic Container Registry (Amazon ECR) is a managed container
259 image registry service. Amazon ECR provides both public and private
260 registries to host your container images. You can use the familiar
261 Docker CLI, or their preferred client, to push, pull, and manage
262 images. Amazon ECR provides a secure, scalable, and reliable registry
263 for your Docker or Open Container Initiative (OCI) images. Amazon ECR
264 supports public repositories with this API. For information about the
265 Amazon ECR API for private repositories, see Amazon Elastic Container
266 Registry API Reference
267 (https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html).
268  
269 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/api.ecr-public-2020-10-30>
270  
271  
272 =head1 METHODS
273  
274 =head2 BatchCheckLayerAvailability
275  
276 =over
277  
278 =item LayerDigests => ArrayRef[Str|Undef]
279  
280 =item RepositoryName => Str
281  
282 =item [RegistryId => Str]
283  
284  
285 =back
286  
287 Each argument is described in detail in: L<Paws::ECRPublic::BatchCheckLayerAvailability>
288  
289 Returns: a L<Paws::ECRPublic::BatchCheckLayerAvailabilityResponse> instance
290  
291 Checks the availability of one or more image layers within a repository
292 in a public registry. When an image is pushed to a repository, each
293 image layer is checked to verify if it has been uploaded before. If it
294 has been uploaded, then the image layer is skipped.
295  
296 This operation is used by the Amazon ECR proxy and is not generally
297 used by customers for pulling and pushing images. In most cases, you
298 should use the C<docker> CLI to pull, tag, and push images.
299  
300  
301 =head2 BatchDeleteImage
302  
303 =over
304  
305 =item ImageIds => ArrayRef[L<Paws::ECRPublic::ImageIdentifier>]
306  
307 =item RepositoryName => Str
308  
309 =item [RegistryId => Str]
310  
311  
312 =back
313  
314 Each argument is described in detail in: L<Paws::ECRPublic::BatchDeleteImage>
315  
316 Returns: a L<Paws::ECRPublic::BatchDeleteImageResponse> instance
317  
318 Deletes a list of specified images within a repository in a public
319 registry. Images are specified with either an C<imageTag> or
320 C<imageDigest>.
321  
322 You can remove a tag from an image by specifying the image's tag in
323 your request. When you remove the last tag from an image, the image is
324 deleted from your repository.
325  
326 You can completely delete an image (and all of its tags) by specifying
327 the image's digest in your request.
328  
329  
330 =head2 CompleteLayerUpload
331  
332 =over
333  
334 =item LayerDigests => ArrayRef[Str|Undef]
335  
336 =item RepositoryName => Str
337  
338 =item UploadId => Str
339  
340 =item [RegistryId => Str]
341  
342  
343 =back
344  
345 Each argument is described in detail in: L<Paws::ECRPublic::CompleteLayerUpload>
346  
347 Returns: a L<Paws::ECRPublic::CompleteLayerUploadResponse> instance
348  
349 Informs Amazon ECR that the image layer upload has completed for a
350 specified public registry, repository name, and upload ID. You can
351 optionally provide a C<sha256> digest of the image layer for data
352 validation purposes.
353  
354 When an image is pushed, the CompleteLayerUpload API is called once per
355 each new image layer to verify that the upload has completed.
356  
357 This operation is used by the Amazon ECR proxy and is not generally
358 used by customers for pulling and pushing images. In most cases, you
359 should use the C<docker> CLI to pull, tag, and push images.
360  
361  
362 =head2 CreateRepository
363  
364 =over
365  
366 =item RepositoryName => Str
367  
368 =item [CatalogData => L<Paws::ECRPublic::RepositoryCatalogDataInput>]
369  
370 =item [Tags => ArrayRef[L<Paws::ECRPublic::Tag>]]
371  
372  
373 =back
374  
375 Each argument is described in detail in: L<Paws::ECRPublic::CreateRepository>
376  
377 Returns: a L<Paws::ECRPublic::CreateRepositoryResponse> instance
378  
379 Creates a repository in a public registry. For more information, see
380 Amazon ECR repositories
381 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html)
382 in the I<Amazon Elastic Container Registry User Guide>.
383  
384  
385 =head2 DeleteRepository
386  
387 =over
388  
389 =item RepositoryName => Str
390  
391 =item [Force => Bool]
392  
393 =item [RegistryId => Str]
394  
395  
396 =back
397  
398 Each argument is described in detail in: L<Paws::ECRPublic::DeleteRepository>
399  
400 Returns: a L<Paws::ECRPublic::DeleteRepositoryResponse> instance
401  
402 Deletes a repository in a public registry. If the repository contains
403 images, you must either delete all images in the repository or use the
404 C<force> option which deletes all images on your behalf before deleting
405 the repository.
406  
407  
408 =head2 DeleteRepositoryPolicy
409  
410 =over
411  
412 =item RepositoryName => Str
413  
414 =item [RegistryId => Str]
415  
416  
417 =back
418  
419 Each argument is described in detail in: L<Paws::ECRPublic::DeleteRepositoryPolicy>
420  
421 Returns: a L<Paws::ECRPublic::DeleteRepositoryPolicyResponse> instance
422  
423 Deletes the repository policy associated with the specified repository.
424  
425  
426 =head2 DescribeImages
427  
428 =over
429  
430 =item RepositoryName => Str
431  
432 =item [ImageIds => ArrayRef[L<Paws::ECRPublic::ImageIdentifier>]]
433  
434 =item [MaxResults => Int]
435  
436 =item [NextToken => Str]
437  
438 =item [RegistryId => Str]
439  
440  
441 =back
442  
443 Each argument is described in detail in: L<Paws::ECRPublic::DescribeImages>
444  
445 Returns: a L<Paws::ECRPublic::DescribeImagesResponse> instance
446  
447 Returns metadata about the images in a repository in a public registry.
448  
449 Beginning with Docker version 1.9, the Docker client compresses image
450 layers before pushing them to a V2 Docker registry. The output of the
451 C<docker images> command shows the uncompressed image size, so it may
452 return a larger image size than the image sizes returned by
453 DescribeImages.
454  
455  
456 =head2 DescribeImageTags
457  
458 =over
459  
460 =item RepositoryName => Str
461  
462 =item [MaxResults => Int]
463  
464 =item [NextToken => Str]
465  
466 =item [RegistryId => Str]
467  
468  
469 =back
470  
471 Each argument is described in detail in: L<Paws::ECRPublic::DescribeImageTags>
472  
473 Returns: a L<Paws::ECRPublic::DescribeImageTagsResponse> instance
474  
475 Returns the image tag details for a repository in a public registry.
476  
477  
478 =head2 DescribeRegistries
479  
480 =over
481  
482 =item [MaxResults => Int]
483  
484 =item [NextToken => Str]
485  
486  
487 =back
488  
489 Each argument is described in detail in: L<Paws::ECRPublic::DescribeRegistries>
490  
491 Returns: a L<Paws::ECRPublic::DescribeRegistriesResponse> instance
492  
493 Returns details for a public registry.
494  
495  
496 =head2 DescribeRepositories
497  
498 =over
499  
500 =item [MaxResults => Int]
501  
502 =item [NextToken => Str]
503  
504 =item [RegistryId => Str]
505  
506 =item [RepositoryNames => ArrayRef[Str|Undef]]
507  
508  
509 =back
510  
511 Each argument is described in detail in: L<Paws::ECRPublic::DescribeRepositories>
512  
513 Returns: a L<Paws::ECRPublic::DescribeRepositoriesResponse> instance
514  
515 Describes repositories in a public registry.
516  
517  
518 =head2 GetAuthorizationToken
519  
520  
521  
522  
523  
524  
525 Each argument is described in detail in: L<Paws::ECRPublic::GetAuthorizationToken>
526  
527 Returns: a L<Paws::ECRPublic::GetAuthorizationTokenResponse> instance
528  
529 Retrieves an authorization token. An authorization token represents
530 your IAM authentication credentials and can be used to access any
531 Amazon ECR registry that your IAM principal has access to. The
532 authorization token is valid for 12 hours. This API requires the
533 C<ecr-public:GetAuthorizationToken> and C<sts:GetServiceBearerToken>
534 permissions.
535  
536  
537 =head2 GetRegistryCatalogData
538  
539  
540  
541  
542  
543  
544 Each argument is described in detail in: L<Paws::ECRPublic::GetRegistryCatalogData>
545  
546 Returns: a L<Paws::ECRPublic::GetRegistryCatalogDataResponse> instance
547  
548 Retrieves catalog metadata for a public registry.
549  
550  
551 =head2 GetRepositoryCatalogData
552  
553 =over
554  
555 =item RepositoryName => Str
556  
557 =item [RegistryId => Str]
558  
559  
560 =back
561  
562 Each argument is described in detail in: L<Paws::ECRPublic::GetRepositoryCatalogData>
563  
564 Returns: a L<Paws::ECRPublic::GetRepositoryCatalogDataResponse> instance
565  
566 Retrieve catalog metadata for a repository in a public registry. This
567 metadata is displayed publicly in the Amazon ECR Public Gallery.
568  
569  
570 =head2 GetRepositoryPolicy
571  
572 =over
573  
574 =item RepositoryName => Str
575  
576 =item [RegistryId => Str]
577  
578  
579 =back
580  
581 Each argument is described in detail in: L<Paws::ECRPublic::GetRepositoryPolicy>
582  
583 Returns: a L<Paws::ECRPublic::GetRepositoryPolicyResponse> instance
584  
585 Retrieves the repository policy for the specified repository.
586  
587  
588 =head2 InitiateLayerUpload
589  
590 =over
591  
592 =item RepositoryName => Str
593  
594 =item [RegistryId => Str]
595  
596  
597 =back
598  
599 Each argument is described in detail in: L<Paws::ECRPublic::InitiateLayerUpload>
600  
601 Returns: a L<Paws::ECRPublic::InitiateLayerUploadResponse> instance
602  
603 Notifies Amazon ECR that you intend to upload an image layer.
604  
605 When an image is pushed, the InitiateLayerUpload API is called once per
606 image layer that has not already been uploaded. Whether or not an image
607 layer has been uploaded is determined by the
608 BatchCheckLayerAvailability API action.
609  
610 This operation is used by the Amazon ECR proxy and is not generally
611 used by customers for pulling and pushing images. In most cases, you
612 should use the C<docker> CLI to pull, tag, and push images.
613  
614  
615 =head2 ListTagsForResource
616  
617 =over
618  
619 =item ResourceArn => Str
620  
621  
622 =back
623  
624 Each argument is described in detail in: L<Paws::ECRPublic::ListTagsForResource>
625  
626 Returns: a L<Paws::ECRPublic::ListTagsForResourceResponse> instance
627  
628 List the tags for an Amazon ECR Public resource.
629  
630  
631 =head2 PutImage
632  
633 =over
634  
635 =item ImageManifest => Str
636  
637 =item RepositoryName => Str
638  
639 =item [ImageDigest => Str]
640  
641 =item [ImageManifestMediaType => Str]
642  
643 =item [ImageTag => Str]
644  
645 =item [RegistryId => Str]
646  
647  
648 =back
649  
650 Each argument is described in detail in: L<Paws::ECRPublic::PutImage>
651  
652 Returns: a L<Paws::ECRPublic::PutImageResponse> instance
653  
654 Creates or updates the image manifest and tags associated with an
655 image.
656  
657 When an image is pushed and all new image layers have been uploaded,
658 the PutImage API is called once to create or update the image manifest
659 and the tags associated with the image.
660  
661 This operation is used by the Amazon ECR proxy and is not generally
662 used by customers for pulling and pushing images. In most cases, you
663 should use the C<docker> CLI to pull, tag, and push images.
664  
665  
666 =head2 PutRegistryCatalogData
667  
668 =over
669  
670 =item [DisplayName => Str]
671  
672  
673 =back
674  
675 Each argument is described in detail in: L<Paws::ECRPublic::PutRegistryCatalogData>
676  
677 Returns: a L<Paws::ECRPublic::PutRegistryCatalogDataResponse> instance
678  
679 Create or updates the catalog data for a public registry.
680  
681  
682 =head2 PutRepositoryCatalogData
683  
684 =over
685  
686 =item CatalogData => L<Paws::ECRPublic::RepositoryCatalogDataInput>
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::ECRPublic::PutRepositoryCatalogData>
696  
697 Returns: a L<Paws::ECRPublic::PutRepositoryCatalogDataResponse> instance
698  
699 Creates or updates the catalog data for a repository in a public
700 registry.
701  
702  
703 =head2 SetRepositoryPolicy
704  
705 =over
706  
707 =item PolicyText => Str
708  
709 =item RepositoryName => Str
710  
711 =item [Force => Bool]
712  
713 =item [RegistryId => Str]
714  
715  
716 =back
717  
718 Each argument is described in detail in: L<Paws::ECRPublic::SetRepositoryPolicy>
719  
720 Returns: a L<Paws::ECRPublic::SetRepositoryPolicyResponse> instance
721  
722 Applies a repository policy to the specified public repository to
723 control access permissions. For more information, see Amazon ECR
724 Repository Policies
725 (https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html)
726 in the I<Amazon Elastic Container Registry User Guide>.
727  
728  
729 =head2 TagResource
730  
731 =over
732  
733 =item ResourceArn => Str
734  
735 =item Tags => ArrayRef[L<Paws::ECRPublic::Tag>]
736  
737  
738 =back
739  
740 Each argument is described in detail in: L<Paws::ECRPublic::TagResource>
741  
742 Returns: a L<Paws::ECRPublic::TagResourceResponse> instance
743  
744 Associates the specified tags to a resource with the specified
745 C<resourceArn>. If existing tags on a resource are not specified in the
746 request parameters, they are not changed. When a resource is deleted,
747 the tags associated with that resource are deleted as well.
748  
749  
750 =head2 UntagResource
751  
752 =over
753  
754 =item ResourceArn => Str
755  
756 =item TagKeys => ArrayRef[Str|Undef]
757  
758  
759 =back
760  
761 Each argument is described in detail in: L<Paws::ECRPublic::UntagResource>
762  
763 Returns: a L<Paws::ECRPublic::UntagResourceResponse> instance
764  
765 Deletes specified tags from a resource.
766  
767  
768 =head2 UploadLayerPart
769  
770 =over
771  
772 =item LayerPartBlob => Str
773  
774 =item PartFirstByte => Int
775  
776 =item PartLastByte => Int
777  
778 =item RepositoryName => Str
779  
780 =item UploadId => Str
781  
782 =item [RegistryId => Str]
783  
784  
785 =back
786  
787 Each argument is described in detail in: L<Paws::ECRPublic::UploadLayerPart>
788  
789 Returns: a L<Paws::ECRPublic::UploadLayerPartResponse> instance
790  
791 Uploads an image layer part to Amazon ECR.
792  
793 When an image is pushed, each new image layer is uploaded in parts. The
794 maximum size of each image layer part can be 20971520 bytes (or about
795 20MB). The UploadLayerPart API is called once per each new image layer
796 part.
797  
798 This operation is used by the Amazon ECR proxy and is not generally
799 used by customers for pulling and pushing images. In most cases, you
800 should use the C<docker> CLI to pull, tag, and push images.
801  
802  
803  
804  
805 =head1 PAGINATORS
806  
807 Paginator methods are helpers that repetively call methods that return partial results
808  
809 =head2 DescribeAllImages(sub { },RepositoryName => Str, [ImageIds => ArrayRef[L<Paws::ECRPublic::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
810  
811 =head2 DescribeAllImages(RepositoryName => Str, [ImageIds => ArrayRef[L<Paws::ECRPublic::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
812  
813  
814 If passed a sub as first parameter, it will call the sub for each element found in :
815  
816 - imageDetails, passing the object as the first parameter, and the string 'imageDetails' as the second parameter
817  
818 If not, it will return a a L<Paws::ECRPublic::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.
819  
820  
821 =head2 DescribeAllImageTags(sub { },RepositoryName => Str, [MaxResults => Int, NextToken => Str, RegistryId => Str])
822  
823 =head2 DescribeAllImageTags(RepositoryName => Str, [MaxResults => Int, NextToken => Str, RegistryId => Str])
824  
825  
826 If passed a sub as first parameter, it will call the sub for each element found in :
827  
828 - imageTagDetails, passing the object as the first parameter, and the string 'imageTagDetails' as the second parameter
829  
830 If not, it will return a a L<Paws::ECRPublic::DescribeImageTagsResponse> 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.
831  
832  
833 =head2 DescribeAllRegistries(sub { },[MaxResults => Int, NextToken => Str])
834  
835 =head2 DescribeAllRegistries([MaxResults => Int, NextToken => Str])
836  
837  
838 If passed a sub as first parameter, it will call the sub for each element found in :
839  
840 - registries, passing the object as the first parameter, and the string 'registries' as the second parameter
841  
842 If not, it will return a a L<Paws::ECRPublic::DescribeRegistriesResponse> 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.
843  
844  
845 =head2 DescribeAllRepositories(sub { },[MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
846  
847 =head2 DescribeAllRepositories([MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
848  
849  
850 If passed a sub as first parameter, it will call the sub for each element found in :
851  
852 - repositories, passing the object as the first parameter, and the string 'repositories' as the second parameter
853  
854 If not, it will return a a L<Paws::ECRPublic::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.
855  
856  
857  
858  
859  
860 =head1 SEE ALSO
861  
862 This service class forms part of L<Paws>
863  
864 =head1 BUGS and CONTRIBUTIONS
865  
866 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
867  
868 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
869  
870 =cut
871