ecr

package
v0.23.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 25, 2020 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Overview

Package ecr provides the client and types for making API requests to Amazon ECR.

Amazon Elastic Container Registry (Amazon ECR) is a managed Docker registry service. Customers can use the familiar Docker CLI to push, pull, and manage images. Amazon ECR provides a secure, scalable, and reliable registry. Amazon ECR supports private Docker repositories with resource-based permissions using IAM so that specific users or Amazon EC2 instances can access repositories and images. Developers can use the Docker CLI to author and manage images.

See https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21 for more information on this service.

See ecr package documentation for more information. https://docs.aws.amazon.com/sdk-for-go/api/service/ecr/

Using the Client

To use Amazon ECR with the SDK use the New function to create a new service client. With that client you can make API requests to the service. These clients are safe to use concurrently.

See the SDK's documentation for more information on how to use the SDK. https://docs.aws.amazon.com/sdk-for-go/api/

See aws.Config documentation for more information on configuring SDK clients. https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config

See the Amazon ECR client for more information on creating client for this service. https://docs.aws.amazon.com/sdk-for-go/api/service/ecr/#New

Index

Examples

Constants

View Source 
const (
	ServiceName = "Amazon ECR" // Service's name
	ServiceID   = "ECR"        // Service's identifier
	EndpointsID = "api.ecr"    // Service's Endpoint identifier
)
View Source 
const (

	// ErrCodeEmptyUploadException for service response error code
	// "EmptyUploadException".
	//
	// The specified layer upload does not contain any layer parts.
	ErrCodeEmptyUploadException = "EmptyUploadException"

	// ErrCodeImageAlreadyExistsException for service response error code
	// "ImageAlreadyExistsException".
	//
	// The specified image has already been pushed, and there were no changes to
	// the manifest or image tag after the last push.
	ErrCodeImageAlreadyExistsException = "ImageAlreadyExistsException"

	// ErrCodeImageNotFoundException for service response error code
	// "ImageNotFoundException".
	//
	// The image requested does not exist in the specified repository.
	ErrCodeImageNotFoundException = "ImageNotFoundException"

	// ErrCodeImageTagAlreadyExistsException for service response error code
	// "ImageTagAlreadyExistsException".
	//
	// The specified image is tagged with a tag that already exists. The repository
	// is configured for tag immutability.
	ErrCodeImageTagAlreadyExistsException = "ImageTagAlreadyExistsException"

	// ErrCodeInvalidLayerException for service response error code
	// "InvalidLayerException".
	//
	// The layer digest calculation performed by Amazon ECR upon receipt of the
	// image layer does not match the digest specified.
	ErrCodeInvalidLayerException = "InvalidLayerException"

	// ErrCodeInvalidLayerPartException for service response error code
	// "InvalidLayerPartException".
	//
	// The layer part size is not valid, or the first byte specified is not consecutive
	// to the last byte of a previous layer part upload.
	ErrCodeInvalidLayerPartException = "InvalidLayerPartException"

	// ErrCodeInvalidParameterException for service response error code
	// "InvalidParameterException".
	//
	// The specified parameter is invalid. Review the available parameters for the
	// API request.
	ErrCodeInvalidParameterException = "InvalidParameterException"

	// ErrCodeInvalidTagParameterException for service response error code
	// "InvalidTagParameterException".
	//
	// An invalid parameter has been specified. Tag keys can have a maximum character
	// length of 128 characters, and tag values can have a maximum length of 256
	// characters.
	ErrCodeInvalidTagParameterException = "InvalidTagParameterException"

	// ErrCodeLayerAlreadyExistsException for service response error code
	// "LayerAlreadyExistsException".
	//
	// The image layer already exists in the associated repository.
	ErrCodeLayerAlreadyExistsException = "LayerAlreadyExistsException"

	// ErrCodeLayerInaccessibleException for service response error code
	// "LayerInaccessibleException".
	//
	// The specified layer is not available because it is not associated with an
	// image. Unassociated image layers may be cleaned up at any time.
	ErrCodeLayerInaccessibleException = "LayerInaccessibleException"

	// ErrCodeLayerPartTooSmallException for service response error code
	// "LayerPartTooSmallException".
	//
	// Layer parts must be at least 5 MiB in size.
	ErrCodeLayerPartTooSmallException = "LayerPartTooSmallException"

	// ErrCodeLayersNotFoundException for service response error code
	// "LayersNotFoundException".
	//
	// The specified layers could not be found, or the specified layer is not valid
	// for this repository.
	ErrCodeLayersNotFoundException = "LayersNotFoundException"

	// ErrCodeLifecyclePolicyNotFoundException for service response error code
	// "LifecyclePolicyNotFoundException".
	//
	// The lifecycle policy could not be found, and no policy is set to the repository.
	ErrCodeLifecyclePolicyNotFoundException = "LifecyclePolicyNotFoundException"

	// ErrCodeLifecyclePolicyPreviewInProgressException for service response error code
	// "LifecyclePolicyPreviewInProgressException".
	//
	// The previous lifecycle policy preview request has not completed. Please try
	// again later.
	ErrCodeLifecyclePolicyPreviewInProgressException = "LifecyclePolicyPreviewInProgressException"

	// ErrCodeLifecyclePolicyPreviewNotFoundException for service response error code
	// "LifecyclePolicyPreviewNotFoundException".
	//
	// There is no dry run for this repository.
	ErrCodeLifecyclePolicyPreviewNotFoundException = "LifecyclePolicyPreviewNotFoundException"

	// ErrCodeLimitExceededException for service response error code
	// "LimitExceededException".
	//
	// The operation did not succeed because it would have exceeded a service limit
	// for your account. For more information, see Amazon ECR Service Quotas (https://docs.aws.amazon.com/AmazonECR/latest/userguide/service-quotas.html)
	// in the Amazon Elastic Container Registry User Guide.
	ErrCodeLimitExceededException = "LimitExceededException"

	// ErrCodeReferencedImagesNotFoundException for service response error code
	// "ReferencedImagesNotFoundException".
	//
	// The manifest list is referencing an image that does not exist.
	ErrCodeReferencedImagesNotFoundException = "ReferencedImagesNotFoundException"

	// ErrCodeRepositoryAlreadyExistsException for service response error code
	// "RepositoryAlreadyExistsException".
	//
	// The specified repository already exists in the specified registry.
	ErrCodeRepositoryAlreadyExistsException = "RepositoryAlreadyExistsException"

	// ErrCodeRepositoryNotEmptyException for service response error code
	// "RepositoryNotEmptyException".
	//
	// The specified repository contains images. To delete a repository that contains
	// images, you must force the deletion with the force parameter.
	ErrCodeRepositoryNotEmptyException = "RepositoryNotEmptyException"

	// ErrCodeRepositoryNotFoundException for service response error code
	// "RepositoryNotFoundException".
	//
	// The specified repository could not be found. Check the spelling of the specified
	// repository and ensure that you are performing operations on the correct registry.
	ErrCodeRepositoryNotFoundException = "RepositoryNotFoundException"

	// ErrCodeRepositoryPolicyNotFoundException for service response error code
	// "RepositoryPolicyNotFoundException".
	//
	// The specified repository and registry combination does not have an associated
	// repository policy.
	ErrCodeRepositoryPolicyNotFoundException = "RepositoryPolicyNotFoundException"

	// ErrCodeScanNotFoundException for service response error code
	// "ScanNotFoundException".
	//
	// The specified image scan could not be found. Ensure that image scanning is
	// enabled on the repository and try again.
	ErrCodeScanNotFoundException = "ScanNotFoundException"

	// ErrCodeServerException for service response error code
	// "ServerException".
	//
	// These errors are usually caused by a server-side issue.
	ErrCodeServerException = "ServerException"

	// ErrCodeTooManyTagsException for service response error code
	// "TooManyTagsException".
	//
	// The list of tags on the repository is over the limit. The maximum number
	// of tags that can be applied to a repository is 50.
	ErrCodeTooManyTagsException = "TooManyTagsException"

	// ErrCodeUnsupportedImageTypeException for service response error code
	// "UnsupportedImageTypeException".
	//
	// The image is of a type that cannot be scanned.
	ErrCodeUnsupportedImageTypeException = "UnsupportedImageTypeException"

	// ErrCodeUploadNotFoundException for service response error code
	// "UploadNotFoundException".
	//
	// The upload could not be found, or the specified upload id is not valid for
	// this repository.
	ErrCodeUploadNotFoundException = "UploadNotFoundException"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Attribute added in v0.23.2 

type Attribute struct {

	// The attribute key.
	//
	// Key is a required field
	Key *string `locationName:"key" min:"1" type:"string" required:"true"`

	// The value assigned to the attribute key.
	Value *string `locationName:"value" min:"1" type:"string"`
	// contains filtered or unexported fields
}

This data type is used in the ImageScanFinding data type.

func (Attribute) String added in v0.23.2 

func (s Attribute) String() string

String returns the string representation

type AuthorizationData 

type AuthorizationData struct {

	// A base64-encoded string that contains authorization data for the specified
	// Amazon ECR registry. When the string is decoded, it is presented in the format
	// user:password for private registry authentication using docker login.
	AuthorizationToken *string `locationName:"authorizationToken" type:"string"`

	// The Unix time in seconds and milliseconds when the authorization token expires.
	// Authorization tokens are valid for 12 hours.
	ExpiresAt *time.Time `locationName:"expiresAt" type:"timestamp"`

	// The registry URL to use for this authorization token in a docker login command.
	// The Amazon ECR registry URL format is https://aws_account_id.dkr.ecr.region.amazonaws.com.
	// For example, https://012345678910.dkr.ecr.us-east-1.amazonaws.com..
	ProxyEndpoint *string `locationName:"proxyEndpoint" type:"string"`
	// contains filtered or unexported fields
}

An object representing authorization data for an Amazon ECR registry.

func (AuthorizationData) String 

func (s AuthorizationData) String() string

String returns the string representation

type BatchCheckLayerAvailabilityInput 

type BatchCheckLayerAvailabilityInput struct {

	// The digests of the image layers to check.
	//
	// LayerDigests is a required field
	LayerDigests []string `locationName:"layerDigests" min:"1" type:"list" required:"true"`

	// The AWS account ID associated with the registry that contains the image layers
	// to check. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository that is associated with the image layers to check.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (BatchCheckLayerAvailabilityInput) String 

func (s BatchCheckLayerAvailabilityInput) String() string

String returns the string representation

func (*BatchCheckLayerAvailabilityInput) Validate 

func (s *BatchCheckLayerAvailabilityInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type BatchCheckLayerAvailabilityOutput 

type BatchCheckLayerAvailabilityOutput struct {

	// Any failures associated with the call.
	Failures []LayerFailure `locationName:"failures" type:"list"`

	// A list of image layer objects corresponding to the image layer references
	// in the request.
	Layers []Layer `locationName:"layers" type:"list"`
	// contains filtered or unexported fields
}

func (BatchCheckLayerAvailabilityOutput) String 

func (s BatchCheckLayerAvailabilityOutput) String() string

String returns the string representation

type BatchCheckLayerAvailabilityRequest 

type BatchCheckLayerAvailabilityRequest struct {
	*aws.Request
	Input *BatchCheckLayerAvailabilityInput
	Copy  func(*BatchCheckLayerAvailabilityInput) BatchCheckLayerAvailabilityRequest
}

BatchCheckLayerAvailabilityRequest is the request type for the BatchCheckLayerAvailability API operation.

func (BatchCheckLayerAvailabilityRequest) Send 

func (r BatchCheckLayerAvailabilityRequest) Send(ctx context.Context) (*BatchCheckLayerAvailabilityResponse, error)

Send marshals and sends the BatchCheckLayerAvailability API request.

type BatchCheckLayerAvailabilityResponse added in v0.23.2 

type BatchCheckLayerAvailabilityResponse struct {
	*BatchCheckLayerAvailabilityOutput
	// contains filtered or unexported fields
}

BatchCheckLayerAvailabilityResponse is the response type for the BatchCheckLayerAvailability API operation.

func (*BatchCheckLayerAvailabilityResponse) SDKResponseMetdata added in v0.23.2 

func (r *BatchCheckLayerAvailabilityResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the BatchCheckLayerAvailability request.

type BatchDeleteImageInput 

type BatchDeleteImageInput struct {

	// A list of image ID references that correspond to images to delete. The format
	// of the imageIds reference is imageTag=tag or imageDigest=digest.
	//
	// ImageIds is a required field
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list" required:"true"`

	// The AWS account ID associated with the registry that contains the image to
	// delete. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository that contains the image to delete.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

Deletes specified images within a specified repository. Images are specified with either the imageTag or imageDigest.

func (BatchDeleteImageInput) String 

func (s BatchDeleteImageInput) String() string

String returns the string representation

func (*BatchDeleteImageInput) Validate 

func (s *BatchDeleteImageInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type BatchDeleteImageOutput 

type BatchDeleteImageOutput struct {

	// Any failures associated with the call.
	Failures []ImageFailure `locationName:"failures" type:"list"`

	// The image IDs of the deleted images.
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list"`
	// contains filtered or unexported fields
}

func (BatchDeleteImageOutput) String 

func (s BatchDeleteImageOutput) String() string

String returns the string representation

type BatchDeleteImageRequest 

type BatchDeleteImageRequest struct {
	*aws.Request
	Input *BatchDeleteImageInput
	Copy  func(*BatchDeleteImageInput) BatchDeleteImageRequest
}

BatchDeleteImageRequest is the request type for the BatchDeleteImage API operation.

func (BatchDeleteImageRequest) Send 

func (r BatchDeleteImageRequest) Send(ctx context.Context) (*BatchDeleteImageResponse, error)

Send marshals and sends the BatchDeleteImage API request.

type BatchDeleteImageResponse added in v0.23.2 

type BatchDeleteImageResponse struct {
	*BatchDeleteImageOutput
	// contains filtered or unexported fields
}

BatchDeleteImageResponse is the response type for the BatchDeleteImage API operation.

func (*BatchDeleteImageResponse) SDKResponseMetdata added in v0.23.2 

func (r *BatchDeleteImageResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the BatchDeleteImage request.

type BatchGetImageInput 

type BatchGetImageInput struct {

	// The accepted media types for the request.
	//
	// Valid values: application/vnd.docker.distribution.manifest.v1+json | application/vnd.docker.distribution.manifest.v2+json
	// | application/vnd.oci.image.manifest.v1+json
	AcceptedMediaTypes []string `locationName:"acceptedMediaTypes" min:"1" type:"list"`

	// A list of image ID references that correspond to images to describe. The
	// format of the imageIds reference is imageTag=tag or imageDigest=digest.
	//
	// ImageIds is a required field
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list" required:"true"`

	// The AWS account ID associated with the registry that contains the images
	// to describe. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository that contains the images to describe.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (BatchGetImageInput) String 

func (s BatchGetImageInput) String() string

String returns the string representation

func (*BatchGetImageInput) Validate 

func (s *BatchGetImageInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type BatchGetImageOutput 

type BatchGetImageOutput struct {

	// Any failures associated with the call.
	Failures []ImageFailure `locationName:"failures" type:"list"`

	// A list of image objects corresponding to the image references in the request.
	Images []Image `locationName:"images" type:"list"`
	// contains filtered or unexported fields
}

func (BatchGetImageOutput) String 

func (s BatchGetImageOutput) String() string

String returns the string representation

type BatchGetImageRequest 

type BatchGetImageRequest struct {
	*aws.Request
	Input *BatchGetImageInput
	Copy  func(*BatchGetImageInput) BatchGetImageRequest
}

BatchGetImageRequest is the request type for the BatchGetImage API operation.

func (BatchGetImageRequest) Send 

func (r BatchGetImageRequest) Send(ctx context.Context) (*BatchGetImageResponse, error)

Send marshals and sends the BatchGetImage API request.

type BatchGetImageResponse added in v0.23.2 

type BatchGetImageResponse struct {
	*BatchGetImageOutput
	// contains filtered or unexported fields
}

BatchGetImageResponse is the response type for the BatchGetImage API operation.

func (*BatchGetImageResponse) SDKResponseMetdata added in v0.23.2 

func (r *BatchGetImageResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the BatchGetImage request.

type Client added in v0.23.2 

type Client struct {
	*aws.Client
}

Client provides the API operation methods for making requests to Amazon ECR. See this package's package overview docs for details on the service.

The client's methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func New 

func New(config aws.Config) *Client

New creates a new instance of the client from the provided Config.

Example: 

// Create a client from just a config.
svc := ecr.New(myConfig)

func (*Client) BatchCheckLayerAvailabilityRequest added in v0.23.2 

func (c *Client) BatchCheckLayerAvailabilityRequest(input *BatchCheckLayerAvailabilityInput) BatchCheckLayerAvailabilityRequest

BatchCheckLayerAvailabilityRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Checks the availability of one or more image layers in a repository.

When an image is pushed to a repository, each image layer is checked to verify if it has been uploaded before. If it has been uploaded, then the image layer is skipped.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using BatchCheckLayerAvailabilityRequest.
req := client.BatchCheckLayerAvailabilityRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/BatchCheckLayerAvailability

func (*Client) BatchDeleteImageRequest added in v0.23.2 

func (c *Client) BatchDeleteImageRequest(input *BatchDeleteImageInput) BatchDeleteImageRequest

BatchDeleteImageRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Deletes a list of specified images within a repository. Images are specified with either an imageTag or imageDigest.

You can remove a tag from an image by specifying the image's tag in your request. When you remove the last tag from an image, the image is deleted from your repository.

You can completely delete an image (and all of its tags) by specifying the image's digest in your request. 

// Example sending a request using BatchDeleteImageRequest.
req := client.BatchDeleteImageRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/BatchDeleteImage

Example (Shared00)

To delete multiple images

This example deletes images with the tags precise and trusty in a repository called ubuntu in the default registry for an account. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.BatchDeleteImageInput{
		ImageIds: []ecr.ImageIdentifier{
			{
				ImageTag: aws.String("precise"),
			},
		},
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.BatchDeleteImageRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) BatchGetImageRequest added in v0.23.2 

func (c *Client) BatchGetImageRequest(input *BatchGetImageInput) BatchGetImageRequest

BatchGetImageRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Gets detailed information for an image. Images are specified with either an imageTag or imageDigest.

When an image is pulled, the BatchGetImage API is called once to retrieve the image manifest. 

// Example sending a request using BatchGetImageRequest.
req := client.BatchGetImageRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/BatchGetImage

Example (Shared00)

To obtain multiple images in a single request

This example obtains information for an image with a specified image digest ID from the repository named ubuntu in the current account. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.BatchGetImageInput{
		ImageIds: []ecr.ImageIdentifier{
			{
				ImageTag: aws.String("precise"),
			},
		},
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.BatchGetImageRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) CompleteLayerUploadRequest added in v0.23.2 

func (c *Client) CompleteLayerUploadRequest(input *CompleteLayerUploadInput) CompleteLayerUploadRequest

CompleteLayerUploadRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Informs Amazon ECR that the image layer upload has completed for a specified registry, repository name, and upload ID. You can optionally provide a sha256 digest of the image layer for data validation purposes.

When an image is pushed, the CompleteLayerUpload API is called once per each new image layer to verify that the upload has completed.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using CompleteLayerUploadRequest.
req := client.CompleteLayerUploadRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/CompleteLayerUpload

func (*Client) CreateRepositoryRequest added in v0.23.2 

func (c *Client) CreateRepositoryRequest(input *CreateRepositoryInput) CreateRepositoryRequest

CreateRepositoryRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Creates a repository. For more information, see Amazon ECR Repositories (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) in the Amazon Elastic Container Registry User Guide. 

// Example sending a request using CreateRepositoryRequest.
req := client.CreateRepositoryRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/CreateRepository

Example (Shared00)

To create a new repository

This example creates a repository called nginx-web-app inside the project-a namespace in the default registry for an account. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.CreateRepositoryInput{
		RepositoryName: aws.String("project-a/nginx-web-app"),
	}

	req := svc.CreateRepositoryRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeInvalidTagParameterException:
				fmt.Println(ecr.ErrCodeInvalidTagParameterException, aerr.Error())
			case ecr.ErrCodeTooManyTagsException:
				fmt.Println(ecr.ErrCodeTooManyTagsException, aerr.Error())
			case ecr.ErrCodeRepositoryAlreadyExistsException:
				fmt.Println(ecr.ErrCodeRepositoryAlreadyExistsException, aerr.Error())
			case ecr.ErrCodeLimitExceededException:
				fmt.Println(ecr.ErrCodeLimitExceededException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) DeleteLifecyclePolicyRequest added in v0.23.2 

func (c *Client) DeleteLifecyclePolicyRequest(input *DeleteLifecyclePolicyInput) DeleteLifecyclePolicyRequest

DeleteLifecyclePolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Deletes the lifecycle policy associated with the specified repository. 

// Example sending a request using DeleteLifecyclePolicyRequest.
req := client.DeleteLifecyclePolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DeleteLifecyclePolicy

func (*Client) DeleteRepositoryPolicyRequest added in v0.23.2 

func (c *Client) DeleteRepositoryPolicyRequest(input *DeleteRepositoryPolicyInput) DeleteRepositoryPolicyRequest

DeleteRepositoryPolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Deletes the repository policy associated with the specified repository. 

// Example sending a request using DeleteRepositoryPolicyRequest.
req := client.DeleteRepositoryPolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DeleteRepositoryPolicy

Example (Shared00)

To delete the policy associated with a repository

This example deletes the policy associated with the repository named ubuntu in the current account. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.DeleteRepositoryPolicyInput{
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.DeleteRepositoryPolicyRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			case ecr.ErrCodeRepositoryPolicyNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryPolicyNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) DeleteRepositoryRequest added in v0.23.2 

func (c *Client) DeleteRepositoryRequest(input *DeleteRepositoryInput) DeleteRepositoryRequest

DeleteRepositoryRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Deletes a repository. If the repository contains images, you must either delete all images in the repository or use the force option to delete the repository. 

// Example sending a request using DeleteRepositoryRequest.
req := client.DeleteRepositoryRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DeleteRepository

Example (Shared00)

To force delete a repository

This example force deletes a repository named ubuntu in the default registry for an account. The force parameter is required if the repository contains images. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.DeleteRepositoryInput{
		Force:          aws.Bool(true),
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.DeleteRepositoryRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			case ecr.ErrCodeRepositoryNotEmptyException:
				fmt.Println(ecr.ErrCodeRepositoryNotEmptyException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) DescribeImageScanFindingsRequest added in v0.23.2 

func (c *Client) DescribeImageScanFindingsRequest(input *DescribeImageScanFindingsInput) DescribeImageScanFindingsRequest

DescribeImageScanFindingsRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Returns the scan findings for the specified image. 

// Example sending a request using DescribeImageScanFindingsRequest.
req := client.DescribeImageScanFindingsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DescribeImageScanFindings

func (*Client) DescribeImagesRequest added in v0.23.2 

func (c *Client) DescribeImagesRequest(input *DescribeImagesInput) DescribeImagesRequest

DescribeImagesRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Returns metadata about the images in a repository.

Beginning with Docker version 1.9, the Docker client compresses image layers before pushing them to a V2 Docker registry. The output of the docker images command shows the uncompressed image size, so it may return a larger image size than the image sizes returned by DescribeImages. 

// Example sending a request using DescribeImagesRequest.
req := client.DescribeImagesRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DescribeImages

func (*Client) DescribeRepositoriesRequest added in v0.23.2 

func (c *Client) DescribeRepositoriesRequest(input *DescribeRepositoriesInput) DescribeRepositoriesRequest

DescribeRepositoriesRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Describes image repositories in a registry. 

// Example sending a request using DescribeRepositoriesRequest.
req := client.DescribeRepositoriesRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/DescribeRepositories

Example (Shared00)

To describe all repositories in the current account

The following example obtains a list and description of all repositories in the default registry to which the current user has access. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.DescribeRepositoriesInput{}

	req := svc.DescribeRepositoriesRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) GetAuthorizationTokenRequest added in v0.23.2 

func (c *Client) GetAuthorizationTokenRequest(input *GetAuthorizationTokenInput) GetAuthorizationTokenRequest

GetAuthorizationTokenRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Retrieves an authorization token. An authorization token represents your IAM authentication credentials and can be used to access any Amazon ECR registry that your IAM principal has access to. The authorization token is valid for 12 hours.

The authorizationToken returned is a base64 encoded string that can be decoded and used in a docker login command to authenticate to a registry. The AWS CLI offers an get-login-password command that simplifies the login process. For more information, see Registry Authentication (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) in the Amazon Elastic Container Registry User Guide. 

// Example sending a request using GetAuthorizationTokenRequest.
req := client.GetAuthorizationTokenRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/GetAuthorizationToken

Example (Shared00)

To obtain an authorization token

This example gets an authorization token for your default registry. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.GetAuthorizationTokenInput{}

	req := svc.GetAuthorizationTokenRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) GetDownloadUrlForLayerRequest added in v0.23.2 

func (c *Client) GetDownloadUrlForLayerRequest(input *GetDownloadUrlForLayerInput) GetDownloadUrlForLayerRequest

GetDownloadUrlForLayerRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Retrieves the pre-signed Amazon S3 download URL corresponding to an image layer. You can only get URLs for image layers that are referenced in an image.

When an image is pulled, the GetDownloadUrlForLayer API is called once per image layer that is not already cached.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using GetDownloadUrlForLayerRequest.
req := client.GetDownloadUrlForLayerRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/GetDownloadUrlForLayer

func (*Client) GetLifecyclePolicyPreviewRequest added in v0.23.2 

func (c *Client) GetLifecyclePolicyPreviewRequest(input *GetLifecyclePolicyPreviewInput) GetLifecyclePolicyPreviewRequest

GetLifecyclePolicyPreviewRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Retrieves the results of the lifecycle policy preview request for the specified repository. 

// Example sending a request using GetLifecyclePolicyPreviewRequest.
req := client.GetLifecyclePolicyPreviewRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/GetLifecyclePolicyPreview

func (*Client) GetLifecyclePolicyRequest added in v0.23.2 

func (c *Client) GetLifecyclePolicyRequest(input *GetLifecyclePolicyInput) GetLifecyclePolicyRequest

GetLifecyclePolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Retrieves the lifecycle policy for the specified repository. 

// Example sending a request using GetLifecyclePolicyRequest.
req := client.GetLifecyclePolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/GetLifecyclePolicy

func (*Client) GetRepositoryPolicyRequest added in v0.23.2 

func (c *Client) GetRepositoryPolicyRequest(input *GetRepositoryPolicyInput) GetRepositoryPolicyRequest

GetRepositoryPolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Retrieves the repository policy for the specified repository. 

// Example sending a request using GetRepositoryPolicyRequest.
req := client.GetRepositoryPolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/GetRepositoryPolicy

Example (Shared00)

To get the current policy for a repository

This example obtains the repository policy for the repository named ubuntu. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.GetRepositoryPolicyInput{
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.GetRepositoryPolicyRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			case ecr.ErrCodeRepositoryPolicyNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryPolicyNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) InitiateLayerUploadRequest added in v0.23.2 

func (c *Client) InitiateLayerUploadRequest(input *InitiateLayerUploadInput) InitiateLayerUploadRequest

InitiateLayerUploadRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Notifies Amazon ECR that you intend to upload an image layer.

When an image is pushed, the InitiateLayerUpload API is called once per image layer that has not already been uploaded. Whether or not an image layer has been uploaded is determined by the BatchCheckLayerAvailability API action.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using InitiateLayerUploadRequest.
req := client.InitiateLayerUploadRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/InitiateLayerUpload

func (*Client) ListImagesRequest added in v0.23.2 

func (c *Client) ListImagesRequest(input *ListImagesInput) ListImagesRequest

ListImagesRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Lists all the image IDs for the specified repository.

You can filter images based on whether or not they are tagged by using the tagStatus filter and specifying either TAGGED, UNTAGGED or ANY. For example, you can filter your results to return only UNTAGGED images and then pipe that result to a BatchDeleteImage operation to delete them. Or, you can filter your results to return only TAGGED images to list all of the tags in your repository. 

// Example sending a request using ListImagesRequest.
req := client.ListImagesRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/ListImages

Example (Shared00)

To list all images in a repository

This example lists all of the images in the repository named ubuntu in the default registry in the current account. 

package main

import (
	"context"
	"fmt"

	"github.com/jviney/aws-sdk-go-v2/aws"
	"github.com/jviney/aws-sdk-go-v2/aws/awserr"
	"github.com/jviney/aws-sdk-go-v2/aws/external"
	"github.com/jviney/aws-sdk-go-v2/service/ecr"
)

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		panic("failed to load config, " + err.Error())
	}

	svc := ecr.New(cfg)
	input := &ecr.ListImagesInput{
		RepositoryName: aws.String("ubuntu"),
	}

	req := svc.ListImagesRequest(input)
	result, err := req.Send(context.Background())
	if err != nil {
		if aerr, ok := err.(awserr.Error); ok {
			switch aerr.Code() {
			case ecr.ErrCodeServerException:
				fmt.Println(ecr.ErrCodeServerException, aerr.Error())
			case ecr.ErrCodeInvalidParameterException:
				fmt.Println(ecr.ErrCodeInvalidParameterException, aerr.Error())
			case ecr.ErrCodeRepositoryNotFoundException:
				fmt.Println(ecr.ErrCodeRepositoryNotFoundException, aerr.Error())
			default:
				fmt.Println(aerr.Error())
			}
		} else {
			// Print the error, cast err to awserr.Error to get the Code and
			// Message from an error.
			fmt.Println(err.Error())
		}
		return
	}

	fmt.Println(result)
}

Output:

func (*Client) ListTagsForResourceRequest added in v0.23.2 

func (c *Client) ListTagsForResourceRequest(input *ListTagsForResourceInput) ListTagsForResourceRequest

ListTagsForResourceRequest returns a request value for making API operation for Amazon EC2 Container Registry.

List the tags for an Amazon ECR resource. 

// Example sending a request using ListTagsForResourceRequest.
req := client.ListTagsForResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/ListTagsForResource

func (*Client) PutImageRequest added in v0.23.2 

func (c *Client) PutImageRequest(input *PutImageInput) PutImageRequest

PutImageRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Creates or updates the image manifest and tags associated with an image.

When an image is pushed and all new image layers have been uploaded, the PutImage API is called once to create or update the image manifest and the tags associated with the image.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using PutImageRequest.
req := client.PutImageRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/PutImage

func (*Client) PutImageScanningConfigurationRequest added in v0.23.2 

func (c *Client) PutImageScanningConfigurationRequest(input *PutImageScanningConfigurationInput) PutImageScanningConfigurationRequest

PutImageScanningConfigurationRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Updates the image scanning configuration for the specified repository. 

// Example sending a request using PutImageScanningConfigurationRequest.
req := client.PutImageScanningConfigurationRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/PutImageScanningConfiguration

func (*Client) PutImageTagMutabilityRequest added in v0.23.2 

func (c *Client) PutImageTagMutabilityRequest(input *PutImageTagMutabilityInput) PutImageTagMutabilityRequest

PutImageTagMutabilityRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Updates the image tag mutability settings for the specified repository. For more information, see Image Tag Mutability (https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-tag-mutability.html) in the Amazon Elastic Container Registry User Guide. 

// Example sending a request using PutImageTagMutabilityRequest.
req := client.PutImageTagMutabilityRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/PutImageTagMutability

func (*Client) PutLifecyclePolicyRequest added in v0.23.2 

func (c *Client) PutLifecyclePolicyRequest(input *PutLifecyclePolicyInput) PutLifecyclePolicyRequest

PutLifecyclePolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Creates or updates the lifecycle policy for the specified repository. For more information, see Lifecycle Policy Template (https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html). 

// Example sending a request using PutLifecyclePolicyRequest.
req := client.PutLifecyclePolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/PutLifecyclePolicy

func (*Client) SetRepositoryPolicyRequest added in v0.23.2 

func (c *Client) SetRepositoryPolicyRequest(input *SetRepositoryPolicyInput) SetRepositoryPolicyRequest

SetRepositoryPolicyRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Applies a repository policy to the specified repository to control access permissions. For more information, see Amazon ECR Repository Policies (https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html) in the Amazon Elastic Container Registry User Guide. 

// Example sending a request using SetRepositoryPolicyRequest.
req := client.SetRepositoryPolicyRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/SetRepositoryPolicy

func (*Client) StartImageScanRequest added in v0.23.2 

func (c *Client) StartImageScanRequest(input *StartImageScanInput) StartImageScanRequest

StartImageScanRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Starts an image vulnerability scan. An image scan can only be started once per day on an individual image. This limit includes if an image was scanned on initial push. For more information, see Image Scanning (https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html) in the Amazon Elastic Container Registry User Guide. 

// Example sending a request using StartImageScanRequest.
req := client.StartImageScanRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/StartImageScan

func (*Client) StartLifecyclePolicyPreviewRequest added in v0.23.2 

func (c *Client) StartLifecyclePolicyPreviewRequest(input *StartLifecyclePolicyPreviewInput) StartLifecyclePolicyPreviewRequest

StartLifecyclePolicyPreviewRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Starts a preview of a lifecycle policy for the specified repository. This allows you to see the results before associating the lifecycle policy with the repository. 

// Example sending a request using StartLifecyclePolicyPreviewRequest.
req := client.StartLifecyclePolicyPreviewRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/StartLifecyclePolicyPreview

func (*Client) TagResourceRequest added in v0.23.2 

func (c *Client) TagResourceRequest(input *TagResourceInput) TagResourceRequest

TagResourceRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Adds specified tags to a resource with the specified ARN. Existing tags on a resource are not changed if they are not specified in the request parameters. 

// Example sending a request using TagResourceRequest.
req := client.TagResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/TagResource

func (*Client) UntagResourceRequest added in v0.23.2 

func (c *Client) UntagResourceRequest(input *UntagResourceInput) UntagResourceRequest

UntagResourceRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Deletes specified tags from a resource. 

// Example sending a request using UntagResourceRequest.
req := client.UntagResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/UntagResource

func (*Client) UploadLayerPartRequest added in v0.23.2 

func (c *Client) UploadLayerPartRequest(input *UploadLayerPartInput) UploadLayerPartRequest

UploadLayerPartRequest returns a request value for making API operation for Amazon EC2 Container Registry.

Uploads an image layer part to Amazon ECR.

When an image is pushed, each new image layer is uploaded in parts. The maximum size of each image layer part can be 20971520 bytes (or about 20MB). The UploadLayerPart API is called once per each new image layer part.

This operation is used by the Amazon ECR proxy and is not generally used by customers for pulling and pushing images. In most cases, you should use the docker CLI to pull, tag, and push images. 

// Example sending a request using UploadLayerPartRequest.
req := client.UploadLayerPartRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/ecr-2015-09-21/UploadLayerPart

func (*Client) WaitUntilImageScanComplete added in v0.23.2 

func (c *Client) WaitUntilImageScanComplete(ctx context.Context, input *DescribeImageScanFindingsInput, opts ...aws.WaiterOption) error

WaitUntilImageScanComplete uses the Amazon ECR API operation DescribeImageScanFindings to wait for a condition to be met before returning. If the condition is not met within the max attempt window, an error will be returned.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Client) WaitUntilLifecyclePolicyPreviewComplete added in v0.23.2 

func (c *Client) WaitUntilLifecyclePolicyPreviewComplete(ctx context.Context, input *GetLifecyclePolicyPreviewInput, opts ...aws.WaiterOption) error

WaitUntilLifecyclePolicyPreviewComplete uses the Amazon ECR API operation GetLifecyclePolicyPreview to wait for a condition to be met before returning. If the condition is not met within the max attempt window, an error will be returned.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

type CompleteLayerUploadInput 

type CompleteLayerUploadInput struct {

	// The sha256 digest of the image layer.
	//
	// LayerDigests is a required field
	LayerDigests []string `locationName:"layerDigests" min:"1" type:"list" required:"true"`

	// The AWS account ID associated with the registry to which to upload layers.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to associate with the image layer.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`

	// The upload ID from a previous InitiateLayerUpload operation to associate
	// with the image layer.
	//
	// UploadId is a required field
	UploadId *string `locationName:"uploadId" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (CompleteLayerUploadInput) String 

func (s CompleteLayerUploadInput) String() string

String returns the string representation

func (*CompleteLayerUploadInput) Validate 

func (s *CompleteLayerUploadInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CompleteLayerUploadOutput 

type CompleteLayerUploadOutput struct {

	// The sha256 digest of the image layer.
	LayerDigest *string `locationName:"layerDigest" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`

	// The upload ID associated with the layer.
	UploadId *string `locationName:"uploadId" type:"string"`
	// contains filtered or unexported fields
}

func (CompleteLayerUploadOutput) String 

func (s CompleteLayerUploadOutput) String() string

String returns the string representation

type CompleteLayerUploadRequest 

type CompleteLayerUploadRequest struct {
	*aws.Request
	Input *CompleteLayerUploadInput
	Copy  func(*CompleteLayerUploadInput) CompleteLayerUploadRequest
}

CompleteLayerUploadRequest is the request type for the CompleteLayerUpload API operation.

func (CompleteLayerUploadRequest) Send 

func (r CompleteLayerUploadRequest) Send(ctx context.Context) (*CompleteLayerUploadResponse, error)

Send marshals and sends the CompleteLayerUpload API request.

type CompleteLayerUploadResponse added in v0.23.2 

type CompleteLayerUploadResponse struct {
	*CompleteLayerUploadOutput
	// contains filtered or unexported fields
}

CompleteLayerUploadResponse is the response type for the CompleteLayerUpload API operation.

func (*CompleteLayerUploadResponse) SDKResponseMetdata added in v0.23.2 

func (r *CompleteLayerUploadResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CompleteLayerUpload request.

type CreateRepositoryInput 

type CreateRepositoryInput struct {

	// The image scanning configuration for the repository. This setting determines
	// whether images are scanned for known vulnerabilities after being pushed to
	// the repository.
	ImageScanningConfiguration *ImageScanningConfiguration `locationName:"imageScanningConfiguration" type:"structure"`

	// The tag mutability setting for the repository. If this parameter is omitted,
	// the default setting of MUTABLE will be used which will allow image tags to
	// be overwritten. If IMMUTABLE is specified, all image tags within the repository
	// will be immutable which will prevent them from being overwritten.
	ImageTagMutability ImageTagMutability `locationName:"imageTagMutability" type:"string" enum:"true"`

	// The name to use for the repository. The repository name may be specified
	// on its own (such as nginx-web-app) or it can be prepended with a namespace
	// to group the repository into a category (such as project-a/nginx-web-app).
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`

	// The metadata that you apply to the repository to help you categorize and
	// organize them. Each tag consists of a key and an optional value, both of
	// which you define. Tag keys can have a maximum character length of 128 characters,
	// and tag values can have a maximum length of 256 characters.
	Tags []Tag `locationName:"tags" type:"list"`
	// contains filtered or unexported fields
}

func (CreateRepositoryInput) String 

func (s CreateRepositoryInput) String() string

String returns the string representation

func (*CreateRepositoryInput) Validate 

func (s *CreateRepositoryInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateRepositoryOutput 

type CreateRepositoryOutput struct {

	// The repository that was created.
	Repository *Repository `locationName:"repository" type:"structure"`
	// contains filtered or unexported fields
}

func (CreateRepositoryOutput) String 

func (s CreateRepositoryOutput) String() string

String returns the string representation

type CreateRepositoryRequest 

type CreateRepositoryRequest struct {
	*aws.Request
	Input *CreateRepositoryInput
	Copy  func(*CreateRepositoryInput) CreateRepositoryRequest
}

CreateRepositoryRequest is the request type for the CreateRepository API operation.

func (CreateRepositoryRequest) Send 

func (r CreateRepositoryRequest) Send(ctx context.Context) (*CreateRepositoryResponse, error)

Send marshals and sends the CreateRepository API request.

type CreateRepositoryResponse added in v0.23.2 

type CreateRepositoryResponse struct {
	*CreateRepositoryOutput
	// contains filtered or unexported fields
}

CreateRepositoryResponse is the response type for the CreateRepository API operation.

func (*CreateRepositoryResponse) SDKResponseMetdata added in v0.23.2 

func (r *CreateRepositoryResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateRepository request.

type DeleteLifecyclePolicyInput added in v0.2.0 

type DeleteLifecyclePolicyInput struct {

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteLifecyclePolicyInput) String added in v0.2.0 

func (s DeleteLifecyclePolicyInput) String() string

String returns the string representation

func (*DeleteLifecyclePolicyInput) Validate added in v0.2.0 

func (s *DeleteLifecyclePolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteLifecyclePolicyOutput added in v0.2.0 

type DeleteLifecyclePolicyOutput struct {

	// The time stamp of the last time that the lifecycle policy was run.
	LastEvaluatedAt *time.Time `locationName:"lastEvaluatedAt" type:"timestamp"`

	// The JSON lifecycle policy text.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (DeleteLifecyclePolicyOutput) String added in v0.2.0 

func (s DeleteLifecyclePolicyOutput) String() string

String returns the string representation

type DeleteLifecyclePolicyRequest added in v0.2.0 

type DeleteLifecyclePolicyRequest struct {
	*aws.Request
	Input *DeleteLifecyclePolicyInput
	Copy  func(*DeleteLifecyclePolicyInput) DeleteLifecyclePolicyRequest
}

DeleteLifecyclePolicyRequest is the request type for the DeleteLifecyclePolicy API operation.

func (DeleteLifecyclePolicyRequest) Send added in v0.2.0 

func (r DeleteLifecyclePolicyRequest) Send(ctx context.Context) (*DeleteLifecyclePolicyResponse, error)

Send marshals and sends the DeleteLifecyclePolicy API request.

type DeleteLifecyclePolicyResponse added in v0.23.2 

type DeleteLifecyclePolicyResponse struct {
	*DeleteLifecyclePolicyOutput
	// contains filtered or unexported fields
}

DeleteLifecyclePolicyResponse is the response type for the DeleteLifecyclePolicy API operation.

func (*DeleteLifecyclePolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *DeleteLifecyclePolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteLifecyclePolicy request.

type DeleteRepositoryInput 

type DeleteRepositoryInput struct {

	// If a repository contains images, forces the deletion.
	Force *bool `locationName:"force" type:"boolean"`

	// The AWS account ID associated with the registry that contains the repository
	// to delete. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to delete.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteRepositoryInput) String 

func (s DeleteRepositoryInput) String() string

String returns the string representation

func (*DeleteRepositoryInput) Validate 

func (s *DeleteRepositoryInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteRepositoryOutput 

type DeleteRepositoryOutput struct {

	// The repository that was deleted.
	Repository *Repository `locationName:"repository" type:"structure"`
	// contains filtered or unexported fields
}

func (DeleteRepositoryOutput) String 

func (s DeleteRepositoryOutput) String() string

String returns the string representation

type DeleteRepositoryPolicyInput 

type DeleteRepositoryPolicyInput struct {

	// The AWS account ID associated with the registry that contains the repository
	// policy to delete. If you do not specify a registry, the default registry
	// is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository that is associated with the repository policy
	// to delete.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteRepositoryPolicyInput) String 

func (s DeleteRepositoryPolicyInput) String() string

String returns the string representation

func (*DeleteRepositoryPolicyInput) Validate 

func (s *DeleteRepositoryPolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteRepositoryPolicyOutput 

type DeleteRepositoryPolicyOutput struct {

	// The JSON repository policy that was deleted from the repository.
	PolicyText *string `locationName:"policyText" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (DeleteRepositoryPolicyOutput) String 

func (s DeleteRepositoryPolicyOutput) String() string

String returns the string representation

type DeleteRepositoryPolicyRequest 

type DeleteRepositoryPolicyRequest struct {
	*aws.Request
	Input *DeleteRepositoryPolicyInput
	Copy  func(*DeleteRepositoryPolicyInput) DeleteRepositoryPolicyRequest
}

DeleteRepositoryPolicyRequest is the request type for the DeleteRepositoryPolicy API operation.

func (DeleteRepositoryPolicyRequest) Send 

func (r DeleteRepositoryPolicyRequest) Send(ctx context.Context) (*DeleteRepositoryPolicyResponse, error)

Send marshals and sends the DeleteRepositoryPolicy API request.

type DeleteRepositoryPolicyResponse added in v0.23.2 

type DeleteRepositoryPolicyResponse struct {
	*DeleteRepositoryPolicyOutput
	// contains filtered or unexported fields
}

DeleteRepositoryPolicyResponse is the response type for the DeleteRepositoryPolicy API operation.

func (*DeleteRepositoryPolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *DeleteRepositoryPolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteRepositoryPolicy request.

type DeleteRepositoryRequest 

type DeleteRepositoryRequest struct {
	*aws.Request
	Input *DeleteRepositoryInput
	Copy  func(*DeleteRepositoryInput) DeleteRepositoryRequest
}

DeleteRepositoryRequest is the request type for the DeleteRepository API operation.

func (DeleteRepositoryRequest) Send 

func (r DeleteRepositoryRequest) Send(ctx context.Context) (*DeleteRepositoryResponse, error)

Send marshals and sends the DeleteRepository API request.

type DeleteRepositoryResponse added in v0.23.2 

type DeleteRepositoryResponse struct {
	*DeleteRepositoryOutput
	// contains filtered or unexported fields
}

DeleteRepositoryResponse is the response type for the DeleteRepository API operation.

func (*DeleteRepositoryResponse) SDKResponseMetdata added in v0.23.2 

func (r *DeleteRepositoryResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteRepository request.

type DescribeImageScanFindingsInput added in v0.23.2 

type DescribeImageScanFindingsInput struct {

	// An object with identifying information for an Amazon ECR image.
	//
	// ImageId is a required field
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure" required:"true"`

	// The maximum number of image scan results returned by DescribeImageScanFindings
	// in paginated output. When this parameter is used, DescribeImageScanFindings
	// only returns maxResults results in a single page along with a nextToken response
	// element. The remaining results of the initial request can be seen by sending
	// another DescribeImageScanFindings request with the returned nextToken value.
	// This value can be between 1 and 1000. If this parameter is not used, then
	// DescribeImageScanFindings returns up to 100 results and a nextToken value,
	// if applicable.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// The nextToken value returned from a previous paginated DescribeImageScanFindings
	// request where maxResults was used and the results exceeded the value of that
	// parameter. Pagination continues from the end of the previous results that
	// returned the nextToken value. This value is null when there are no more results
	// to return.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to describe the image scan findings for. If you do not specify a
	// registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository for the image for which to describe the scan findings.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeImageScanFindingsInput) String added in v0.23.2 

func (s DescribeImageScanFindingsInput) String() string

String returns the string representation

func (*DescribeImageScanFindingsInput) Validate added in v0.23.2 

func (s *DescribeImageScanFindingsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeImageScanFindingsOutput added in v0.23.2 

type DescribeImageScanFindingsOutput struct {

	// An object with identifying information for an Amazon ECR image.
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure"`

	// The information contained in the image scan findings.
	ImageScanFindings *ImageScanFindings `locationName:"imageScanFindings" type:"structure"`

	// The current state of the scan.
	ImageScanStatus *ImageScanStatus `locationName:"imageScanStatus" type:"structure"`

	// The nextToken value to include in a future DescribeImageScanFindings request.
	// When the results of a DescribeImageScanFindings request exceed maxResults,
	// this value can be used to retrieve the next page of results. This value is
	// null when there are no more results to return.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (DescribeImageScanFindingsOutput) String added in v0.23.2 

func (s DescribeImageScanFindingsOutput) String() string

String returns the string representation

type DescribeImageScanFindingsPaginator added in v0.23.2 

type DescribeImageScanFindingsPaginator struct {
	aws.Pager
}

DescribeImageScanFindingsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewDescribeImageScanFindingsPaginator added in v0.23.2 

func NewDescribeImageScanFindingsPaginator(req DescribeImageScanFindingsRequest) DescribeImageScanFindingsPaginator

NewDescribeImageScanFindingsRequestPaginator returns a paginator for DescribeImageScanFindings. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.DescribeImageScanFindingsRequest(input)
p := ecr.NewDescribeImageScanFindingsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*DescribeImageScanFindingsPaginator) CurrentPage added in v0.23.2 

func (p *DescribeImageScanFindingsPaginator) CurrentPage() *DescribeImageScanFindingsOutput

type DescribeImageScanFindingsRequest added in v0.23.2 

type DescribeImageScanFindingsRequest struct {
	*aws.Request
	Input *DescribeImageScanFindingsInput
	Copy  func(*DescribeImageScanFindingsInput) DescribeImageScanFindingsRequest
}

DescribeImageScanFindingsRequest is the request type for the DescribeImageScanFindings API operation.

func (DescribeImageScanFindingsRequest) Send added in v0.23.2 

func (r DescribeImageScanFindingsRequest) Send(ctx context.Context) (*DescribeImageScanFindingsResponse, error)

Send marshals and sends the DescribeImageScanFindings API request.

type DescribeImageScanFindingsResponse added in v0.23.2 

type DescribeImageScanFindingsResponse struct {
	*DescribeImageScanFindingsOutput
	// contains filtered or unexported fields
}

DescribeImageScanFindingsResponse is the response type for the DescribeImageScanFindings API operation.

func (*DescribeImageScanFindingsResponse) SDKResponseMetdata added in v0.23.2 

func (r *DescribeImageScanFindingsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeImageScanFindings request.

type DescribeImagesFilter 

type DescribeImagesFilter struct {

	// The tag status with which to filter your DescribeImages results. You can
	// filter results based on whether they are TAGGED or UNTAGGED.
	TagStatus TagStatus `locationName:"tagStatus" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

An object representing a filter on a DescribeImages operation.

func (DescribeImagesFilter) String 

func (s DescribeImagesFilter) String() string

String returns the string representation

type DescribeImagesInput 

type DescribeImagesInput struct {

	// The filter key and value with which to filter your DescribeImages results.
	Filter *DescribeImagesFilter `locationName:"filter" type:"structure"`

	// The list of image IDs for the requested repository.
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list"`

	// The maximum number of repository results returned by DescribeImages in paginated
	// output. When this parameter is used, DescribeImages only returns maxResults
	// results in a single page along with a nextToken response element. The remaining
	// results of the initial request can be seen by sending another DescribeImages
	// request with the returned nextToken value. This value can be between 1 and
	// 1000. If this parameter is not used, then DescribeImages returns up to 100
	// results and a nextToken value, if applicable. This option cannot be used
	// when you specify images with imageIds.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// The nextToken value returned from a previous paginated DescribeImages request
	// where maxResults was used and the results exceeded the value of that parameter.
	// Pagination continues from the end of the previous results that returned the
	// nextToken value. This value is null when there are no more results to return.
	// This option cannot be used when you specify images with imageIds.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to describe images. If you do not specify a registry, the default
	// registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository that contains the images to describe.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeImagesInput) String 

func (s DescribeImagesInput) String() string

String returns the string representation

func (*DescribeImagesInput) Validate 

func (s *DescribeImagesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeImagesOutput 

type DescribeImagesOutput struct {

	// A list of ImageDetail objects that contain data about the image.
	ImageDetails []ImageDetail `locationName:"imageDetails" type:"list"`

	// The nextToken value to include in a future DescribeImages request. When the
	// results of a DescribeImages request exceed maxResults, this value can be
	// used to retrieve the next page of results. This value is null when there
	// are no more results to return.
	NextToken *string `locationName:"nextToken" type:"string"`
	// contains filtered or unexported fields
}

func (DescribeImagesOutput) String 

func (s DescribeImagesOutput) String() string

String returns the string representation

type DescribeImagesPaginator added in v0.23.2 

type DescribeImagesPaginator struct {
	aws.Pager
}

DescribeImagesPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewDescribeImagesPaginator added in v0.23.2 

func NewDescribeImagesPaginator(req DescribeImagesRequest) DescribeImagesPaginator

NewDescribeImagesRequestPaginator returns a paginator for DescribeImages. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.DescribeImagesRequest(input)
p := ecr.NewDescribeImagesRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*DescribeImagesPaginator) CurrentPage added in v0.23.2 

func (p *DescribeImagesPaginator) CurrentPage() *DescribeImagesOutput

type DescribeImagesRequest 

type DescribeImagesRequest struct {
	*aws.Request
	Input *DescribeImagesInput
	Copy  func(*DescribeImagesInput) DescribeImagesRequest
}

DescribeImagesRequest is the request type for the DescribeImages API operation.

func (DescribeImagesRequest) Send 

func (r DescribeImagesRequest) Send(ctx context.Context) (*DescribeImagesResponse, error)

Send marshals and sends the DescribeImages API request.

type DescribeImagesResponse added in v0.23.2 

type DescribeImagesResponse struct {
	*DescribeImagesOutput
	// contains filtered or unexported fields
}

DescribeImagesResponse is the response type for the DescribeImages API operation.

func (*DescribeImagesResponse) SDKResponseMetdata added in v0.23.2 

func (r *DescribeImagesResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeImages request.

type DescribeRepositoriesInput 

type DescribeRepositoriesInput struct {

	// The maximum number of repository results returned by DescribeRepositories
	// in paginated output. When this parameter is used, DescribeRepositories only
	// returns maxResults results in a single page along with a nextToken response
	// element. The remaining results of the initial request can be seen by sending
	// another DescribeRepositories request with the returned nextToken value. This
	// value can be between 1 and 1000. If this parameter is not used, then DescribeRepositories
	// returns up to 100 results and a nextToken value, if applicable. This option
	// cannot be used when you specify repositories with repositoryNames.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// The nextToken value returned from a previous paginated DescribeRepositories
	// request where maxResults was used and the results exceeded the value of that
	// parameter. Pagination continues from the end of the previous results that
	// returned the nextToken value. This value is null when there are no more results
	// to return. This option cannot be used when you specify repositories with
	// repositoryNames.
	//
	// This token should be treated as an opaque identifier that is only used to
	// retrieve the next items in a list and not for other programmatic purposes.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The AWS account ID associated with the registry that contains the repositories
	// to be described. If you do not specify a registry, the default registry is
	// assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// A list of repositories to describe. If this parameter is omitted, then all
	// repositories in a registry are described.
	RepositoryNames []string `locationName:"repositoryNames" min:"1" type:"list"`
	// contains filtered or unexported fields
}

func (DescribeRepositoriesInput) String 

func (s DescribeRepositoriesInput) String() string

String returns the string representation

func (*DescribeRepositoriesInput) Validate 

func (s *DescribeRepositoriesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeRepositoriesOutput 

type DescribeRepositoriesOutput struct {

	// The nextToken value to include in a future DescribeRepositories request.
	// When the results of a DescribeRepositories request exceed maxResults, this
	// value can be used to retrieve the next page of results. This value is null
	// when there are no more results to return.
	NextToken *string `locationName:"nextToken" type:"string"`

	// A list of repository objects corresponding to valid repositories.
	Repositories []Repository `locationName:"repositories" type:"list"`
	// contains filtered or unexported fields
}

func (DescribeRepositoriesOutput) String 

func (s DescribeRepositoriesOutput) String() string

String returns the string representation

type DescribeRepositoriesPaginator added in v0.23.2 

type DescribeRepositoriesPaginator struct {
	aws.Pager
}

DescribeRepositoriesPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewDescribeRepositoriesPaginator added in v0.23.2 

func NewDescribeRepositoriesPaginator(req DescribeRepositoriesRequest) DescribeRepositoriesPaginator

NewDescribeRepositoriesRequestPaginator returns a paginator for DescribeRepositories. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.DescribeRepositoriesRequest(input)
p := ecr.NewDescribeRepositoriesRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*DescribeRepositoriesPaginator) CurrentPage added in v0.23.2 

func (p *DescribeRepositoriesPaginator) CurrentPage() *DescribeRepositoriesOutput

type DescribeRepositoriesRequest 

type DescribeRepositoriesRequest struct {
	*aws.Request
	Input *DescribeRepositoriesInput
	Copy  func(*DescribeRepositoriesInput) DescribeRepositoriesRequest
}

DescribeRepositoriesRequest is the request type for the DescribeRepositories API operation.

func (DescribeRepositoriesRequest) Send 

func (r DescribeRepositoriesRequest) Send(ctx context.Context) (*DescribeRepositoriesResponse, error)

Send marshals and sends the DescribeRepositories API request.

type DescribeRepositoriesResponse added in v0.23.2 

type DescribeRepositoriesResponse struct {
	*DescribeRepositoriesOutput
	// contains filtered or unexported fields
}

DescribeRepositoriesResponse is the response type for the DescribeRepositories API operation.

func (*DescribeRepositoriesResponse) SDKResponseMetdata added in v0.23.2 

func (r *DescribeRepositoriesResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeRepositories request.

type FindingSeverity added in v0.23.2 

type FindingSeverity string
const (
	FindingSeverityInformational FindingSeverity = "INFORMATIONAL"
	FindingSeverityLow           FindingSeverity = "LOW"
	FindingSeverityMedium        FindingSeverity = "MEDIUM"
	FindingSeverityHigh          FindingSeverity = "HIGH"
	FindingSeverityCritical      FindingSeverity = "CRITICAL"
	FindingSeverityUndefined     FindingSeverity = "UNDEFINED"
)

Enum values for FindingSeverity

func (FindingSeverity) MarshalValue added in v0.23.2 

func (enum FindingSeverity) MarshalValue() (string, error)

func (FindingSeverity) MarshalValueBuf added in v0.23.2 

func (enum FindingSeverity) MarshalValueBuf(b []byte) ([]byte, error)

type GetAuthorizationTokenInput 

type GetAuthorizationTokenInput struct {

	// A list of AWS account IDs that are associated with the registries for which
	// to get AuthorizationData objects. If you do not specify a registry, the default
	// registry is assumed.
	RegistryIds []string `locationName:"registryIds" min:"1" type:"list"`
	// contains filtered or unexported fields
}

func (GetAuthorizationTokenInput) String 

func (s GetAuthorizationTokenInput) String() string

String returns the string representation

func (*GetAuthorizationTokenInput) Validate 

func (s *GetAuthorizationTokenInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetAuthorizationTokenOutput 

type GetAuthorizationTokenOutput struct {

	// A list of authorization token data objects that correspond to the registryIds
	// values in the request.
	AuthorizationData []AuthorizationData `locationName:"authorizationData" type:"list"`
	// contains filtered or unexported fields
}

func (GetAuthorizationTokenOutput) String 

func (s GetAuthorizationTokenOutput) String() string

String returns the string representation

type GetAuthorizationTokenRequest 

type GetAuthorizationTokenRequest struct {
	*aws.Request
	Input *GetAuthorizationTokenInput
	Copy  func(*GetAuthorizationTokenInput) GetAuthorizationTokenRequest
}

GetAuthorizationTokenRequest is the request type for the GetAuthorizationToken API operation.

func (GetAuthorizationTokenRequest) Send 

func (r GetAuthorizationTokenRequest) Send(ctx context.Context) (*GetAuthorizationTokenResponse, error)

Send marshals and sends the GetAuthorizationToken API request.

type GetAuthorizationTokenResponse added in v0.23.2 

type GetAuthorizationTokenResponse struct {
	*GetAuthorizationTokenOutput
	// contains filtered or unexported fields
}

GetAuthorizationTokenResponse is the response type for the GetAuthorizationToken API operation.

func (*GetAuthorizationTokenResponse) SDKResponseMetdata added in v0.23.2 

func (r *GetAuthorizationTokenResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetAuthorizationToken request.

type GetDownloadUrlForLayerInput 

type GetDownloadUrlForLayerInput struct {

	// The digest of the image layer to download.
	//
	// LayerDigest is a required field
	LayerDigest *string `locationName:"layerDigest" type:"string" required:"true"`

	// The AWS account ID associated with the registry that contains the image layer
	// to download. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository that is associated with the image layer to download.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (GetDownloadUrlForLayerInput) String 

func (s GetDownloadUrlForLayerInput) String() string

String returns the string representation

func (*GetDownloadUrlForLayerInput) Validate 

func (s *GetDownloadUrlForLayerInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetDownloadUrlForLayerOutput 

type GetDownloadUrlForLayerOutput struct {

	// The pre-signed Amazon S3 download URL for the requested layer.
	DownloadUrl *string `locationName:"downloadUrl" type:"string"`

	// The digest of the image layer to download.
	LayerDigest *string `locationName:"layerDigest" type:"string"`
	// contains filtered or unexported fields
}

func (GetDownloadUrlForLayerOutput) String 

func (s GetDownloadUrlForLayerOutput) String() string

String returns the string representation

type GetDownloadUrlForLayerRequest 

type GetDownloadUrlForLayerRequest struct {
	*aws.Request
	Input *GetDownloadUrlForLayerInput
	Copy  func(*GetDownloadUrlForLayerInput) GetDownloadUrlForLayerRequest
}

GetDownloadUrlForLayerRequest is the request type for the GetDownloadUrlForLayer API operation.

func (GetDownloadUrlForLayerRequest) Send 

func (r GetDownloadUrlForLayerRequest) Send(ctx context.Context) (*GetDownloadUrlForLayerResponse, error)

Send marshals and sends the GetDownloadUrlForLayer API request.

type GetDownloadUrlForLayerResponse added in v0.23.2 

type GetDownloadUrlForLayerResponse struct {
	*GetDownloadUrlForLayerOutput
	// contains filtered or unexported fields
}

GetDownloadUrlForLayerResponse is the response type for the GetDownloadUrlForLayer API operation.

func (*GetDownloadUrlForLayerResponse) SDKResponseMetdata added in v0.23.2 

func (r *GetDownloadUrlForLayerResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetDownloadUrlForLayer request.

type GetLifecyclePolicyInput added in v0.2.0 

type GetLifecyclePolicyInput struct {

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (GetLifecyclePolicyInput) String added in v0.2.0 

func (s GetLifecyclePolicyInput) String() string

String returns the string representation

func (*GetLifecyclePolicyInput) Validate added in v0.2.0 

func (s *GetLifecyclePolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetLifecyclePolicyOutput added in v0.2.0 

type GetLifecyclePolicyOutput struct {

	// The time stamp of the last time that the lifecycle policy was run.
	LastEvaluatedAt *time.Time `locationName:"lastEvaluatedAt" type:"timestamp"`

	// The JSON lifecycle policy text.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (GetLifecyclePolicyOutput) String added in v0.2.0 

func (s GetLifecyclePolicyOutput) String() string

String returns the string representation

type GetLifecyclePolicyPreviewInput added in v0.2.0 

type GetLifecyclePolicyPreviewInput struct {

	// An optional parameter that filters results based on image tag status and
	// all tags, if tagged.
	Filter *LifecyclePolicyPreviewFilter `locationName:"filter" type:"structure"`

	// The list of imageIDs to be included.
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list"`

	// The maximum number of repository results returned by GetLifecyclePolicyPreviewRequest
	// in paginated output. When this parameter is used, GetLifecyclePolicyPreviewRequest
	// only returns maxResults results in a single page along with a nextToken response
	// element. The remaining results of the initial request can be seen by sending
	// another GetLifecyclePolicyPreviewRequest request with the returned nextToken
	// value. This value can be between 1 and 1000. If this parameter is not used,
	// then GetLifecyclePolicyPreviewRequest returns up to 100 results and a nextToken
	// value, if applicable. This option cannot be used when you specify images
	// with imageIds.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// The nextToken value returned from a previous paginated GetLifecyclePolicyPreviewRequest
	// request where maxResults was used and the results exceeded the value of that
	// parameter. Pagination continues from the end of the previous results that
	// returned the nextToken value. This value is null when there are no more results
	// to return. This option cannot be used when you specify images with imageIds.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (GetLifecyclePolicyPreviewInput) String added in v0.2.0 

func (s GetLifecyclePolicyPreviewInput) String() string

String returns the string representation

func (*GetLifecyclePolicyPreviewInput) Validate added in v0.2.0 

func (s *GetLifecyclePolicyPreviewInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetLifecyclePolicyPreviewOutput added in v0.2.0 

type GetLifecyclePolicyPreviewOutput struct {

	// The JSON lifecycle policy text.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The nextToken value to include in a future GetLifecyclePolicyPreview request.
	// When the results of a GetLifecyclePolicyPreview request exceed maxResults,
	// this value can be used to retrieve the next page of results. This value is
	// null when there are no more results to return.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The results of the lifecycle policy preview request.
	PreviewResults []LifecyclePolicyPreviewResult `locationName:"previewResults" type:"list"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`

	// The status of the lifecycle policy preview request.
	Status LifecyclePolicyPreviewStatus `locationName:"status" type:"string" enum:"true"`

	// The list of images that is returned as a result of the action.
	Summary *LifecyclePolicyPreviewSummary `locationName:"summary" type:"structure"`
	// contains filtered or unexported fields
}

func (GetLifecyclePolicyPreviewOutput) String added in v0.2.0 

func (s GetLifecyclePolicyPreviewOutput) String() string

String returns the string representation

type GetLifecyclePolicyPreviewPaginator added in v0.23.2 

type GetLifecyclePolicyPreviewPaginator struct {
	aws.Pager
}

GetLifecyclePolicyPreviewPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewGetLifecyclePolicyPreviewPaginator added in v0.23.2 

func NewGetLifecyclePolicyPreviewPaginator(req GetLifecyclePolicyPreviewRequest) GetLifecyclePolicyPreviewPaginator

NewGetLifecyclePolicyPreviewRequestPaginator returns a paginator for GetLifecyclePolicyPreview. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.GetLifecyclePolicyPreviewRequest(input)
p := ecr.NewGetLifecyclePolicyPreviewRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*GetLifecyclePolicyPreviewPaginator) CurrentPage added in v0.23.2 

func (p *GetLifecyclePolicyPreviewPaginator) CurrentPage() *GetLifecyclePolicyPreviewOutput

type GetLifecyclePolicyPreviewRequest added in v0.2.0 

type GetLifecyclePolicyPreviewRequest struct {
	*aws.Request
	Input *GetLifecyclePolicyPreviewInput
	Copy  func(*GetLifecyclePolicyPreviewInput) GetLifecyclePolicyPreviewRequest
}

GetLifecyclePolicyPreviewRequest is the request type for the GetLifecyclePolicyPreview API operation.

func (GetLifecyclePolicyPreviewRequest) Send added in v0.2.0 

func (r GetLifecyclePolicyPreviewRequest) Send(ctx context.Context) (*GetLifecyclePolicyPreviewResponse, error)

Send marshals and sends the GetLifecyclePolicyPreview API request.

type GetLifecyclePolicyPreviewResponse added in v0.23.2 

type GetLifecyclePolicyPreviewResponse struct {
	*GetLifecyclePolicyPreviewOutput
	// contains filtered or unexported fields
}

GetLifecyclePolicyPreviewResponse is the response type for the GetLifecyclePolicyPreview API operation.

func (*GetLifecyclePolicyPreviewResponse) SDKResponseMetdata added in v0.23.2 

func (r *GetLifecyclePolicyPreviewResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetLifecyclePolicyPreview request.

type GetLifecyclePolicyRequest added in v0.2.0 

type GetLifecyclePolicyRequest struct {
	*aws.Request
	Input *GetLifecyclePolicyInput
	Copy  func(*GetLifecyclePolicyInput) GetLifecyclePolicyRequest
}

GetLifecyclePolicyRequest is the request type for the GetLifecyclePolicy API operation.

func (GetLifecyclePolicyRequest) Send added in v0.2.0 

func (r GetLifecyclePolicyRequest) Send(ctx context.Context) (*GetLifecyclePolicyResponse, error)

Send marshals and sends the GetLifecyclePolicy API request.

type GetLifecyclePolicyResponse added in v0.23.2 

type GetLifecyclePolicyResponse struct {
	*GetLifecyclePolicyOutput
	// contains filtered or unexported fields
}

GetLifecyclePolicyResponse is the response type for the GetLifecyclePolicy API operation.

func (*GetLifecyclePolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *GetLifecyclePolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetLifecyclePolicy request.

type GetRepositoryPolicyInput 

type GetRepositoryPolicyInput struct {

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository with the policy to retrieve.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (GetRepositoryPolicyInput) String 

func (s GetRepositoryPolicyInput) String() string

String returns the string representation

func (*GetRepositoryPolicyInput) Validate 

func (s *GetRepositoryPolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetRepositoryPolicyOutput 

type GetRepositoryPolicyOutput struct {

	// The JSON repository policy text associated with the repository.
	PolicyText *string `locationName:"policyText" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (GetRepositoryPolicyOutput) String 

func (s GetRepositoryPolicyOutput) String() string

String returns the string representation

type GetRepositoryPolicyRequest 

type GetRepositoryPolicyRequest struct {
	*aws.Request
	Input *GetRepositoryPolicyInput
	Copy  func(*GetRepositoryPolicyInput) GetRepositoryPolicyRequest
}

GetRepositoryPolicyRequest is the request type for the GetRepositoryPolicy API operation.

func (GetRepositoryPolicyRequest) Send 

func (r GetRepositoryPolicyRequest) Send(ctx context.Context) (*GetRepositoryPolicyResponse, error)

Send marshals and sends the GetRepositoryPolicy API request.

type GetRepositoryPolicyResponse added in v0.23.2 

type GetRepositoryPolicyResponse struct {
	*GetRepositoryPolicyOutput
	// contains filtered or unexported fields
}

GetRepositoryPolicyResponse is the response type for the GetRepositoryPolicy API operation.

func (*GetRepositoryPolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *GetRepositoryPolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetRepositoryPolicy request.

type Image 

type Image struct {

	// An object containing the image tag and image digest associated with an image.
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure"`

	// The image manifest associated with the image.
	ImageManifest *string `locationName:"imageManifest" min:"1" type:"string"`

	// The media type associated with the image manifest.
	ImageManifestMediaType *string `locationName:"imageManifestMediaType" type:"string"`

	// The AWS account ID associated with the registry containing the image.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository associated with the image.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

An object representing an Amazon ECR image.

func (Image) String 

func (s Image) String() string

String returns the string representation

type ImageActionType added in v0.2.0 

type ImageActionType string
const (
	ImageActionTypeExpire ImageActionType = "EXPIRE"
)

Enum values for ImageActionType

func (ImageActionType) MarshalValue added in v0.3.0 

func (enum ImageActionType) MarshalValue() (string, error)

func (ImageActionType) MarshalValueBuf added in v0.3.0 

func (enum ImageActionType) MarshalValueBuf(b []byte) ([]byte, error)

type ImageDetail 

type ImageDetail struct {

	// The sha256 digest of the image manifest.
	ImageDigest *string `locationName:"imageDigest" type:"string"`

	// The date and time, expressed in standard JavaScript date format, at which
	// the current image was pushed to the repository.
	ImagePushedAt *time.Time `locationName:"imagePushedAt" type:"timestamp"`

	// A summary of the last completed image scan.
	ImageScanFindingsSummary *ImageScanFindingsSummary `locationName:"imageScanFindingsSummary" type:"structure"`

	// The current state of the scan.
	ImageScanStatus *ImageScanStatus `locationName:"imageScanStatus" type:"structure"`

	// The size, in bytes, of the image in the repository.
	//
	// If the image is a manifest list, this will be the max size of all manifests
	// in the list.
	//
	// Beginning with Docker version 1.9, the Docker client compresses image layers
	// before pushing them to a V2 Docker registry. The output of the docker images
	// command shows the uncompressed image size, so it may return a larger image
	// size than the image sizes returned by DescribeImages.
	ImageSizeInBytes *int64 `locationName:"imageSizeInBytes" type:"long"`

	// The list of tags associated with this image.
	ImageTags []string `locationName:"imageTags" type:"list"`

	// The AWS account ID associated with the registry to which this image belongs.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to which this image belongs.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

An object that describes an image returned by a DescribeImages operation.

func (ImageDetail) String 

func (s ImageDetail) String() string

String returns the string representation

type ImageFailure 

type ImageFailure struct {

	// The code associated with the failure.
	FailureCode ImageFailureCode `locationName:"failureCode" type:"string" enum:"true"`

	// The reason for the failure.
	FailureReason *string `locationName:"failureReason" type:"string"`

	// The image ID associated with the failure.
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure"`
	// contains filtered or unexported fields
}

An object representing an Amazon ECR image failure.

func (ImageFailure) String 

func (s ImageFailure) String() string

String returns the string representation

type ImageFailureCode 

type ImageFailureCode string
const (
	ImageFailureCodeInvalidImageDigest            ImageFailureCode = "InvalidImageDigest"
	ImageFailureCodeInvalidImageTag               ImageFailureCode = "InvalidImageTag"
	ImageFailureCodeImageTagDoesNotMatchDigest    ImageFailureCode = "ImageTagDoesNotMatchDigest"
	ImageFailureCodeImageNotFound                 ImageFailureCode = "ImageNotFound"
	ImageFailureCodeMissingDigestAndTag           ImageFailureCode = "MissingDigestAndTag"
	ImageFailureCodeImageReferencedByManifestList ImageFailureCode = "ImageReferencedByManifestList"
)

Enum values for ImageFailureCode

func (ImageFailureCode) MarshalValue added in v0.3.0 

func (enum ImageFailureCode) MarshalValue() (string, error)

func (ImageFailureCode) MarshalValueBuf added in v0.3.0 

func (enum ImageFailureCode) MarshalValueBuf(b []byte) ([]byte, error)

type ImageIdentifier 

type ImageIdentifier struct {

	// The sha256 digest of the image manifest.
	ImageDigest *string `locationName:"imageDigest" type:"string"`

	// The tag used for the image.
	ImageTag *string `locationName:"imageTag" min:"1" type:"string"`
	// contains filtered or unexported fields
}

An object with identifying information for an Amazon ECR image.

func (ImageIdentifier) String 

func (s ImageIdentifier) String() string

String returns the string representation

func (*ImageIdentifier) Validate added in v0.23.2 

func (s *ImageIdentifier) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ImageScanFinding added in v0.23.2 

type ImageScanFinding struct {

	// A collection of attributes of the host from which the finding is generated.
	Attributes []Attribute `locationName:"attributes" type:"list"`

	// The description of the finding.
	Description *string `locationName:"description" type:"string"`

	// The name associated with the finding, usually a CVE number.
	Name *string `locationName:"name" type:"string"`

	// The finding severity.
	Severity FindingSeverity `locationName:"severity" type:"string" enum:"true"`

	// A link containing additional details about the security vulnerability.
	Uri *string `locationName:"uri" type:"string"`
	// contains filtered or unexported fields
}

Contains information about an image scan finding.

func (ImageScanFinding) String added in v0.23.2 

func (s ImageScanFinding) String() string

String returns the string representation

type ImageScanFindings added in v0.23.2 

type ImageScanFindings struct {

	// The image vulnerability counts, sorted by severity.
	FindingSeverityCounts map[string]int64 `locationName:"findingSeverityCounts" type:"map"`

	// The findings from the image scan.
	Findings []ImageScanFinding `locationName:"findings" type:"list"`

	// The time of the last completed image scan.
	ImageScanCompletedAt *time.Time `locationName:"imageScanCompletedAt" type:"timestamp"`

	// The time when the vulnerability data was last scanned.
	VulnerabilitySourceUpdatedAt *time.Time `locationName:"vulnerabilitySourceUpdatedAt" type:"timestamp"`
	// contains filtered or unexported fields
}

The details of an image scan.

func (ImageScanFindings) String added in v0.23.2 

func (s ImageScanFindings) String() string

String returns the string representation

type ImageScanFindingsSummary added in v0.23.2 

type ImageScanFindingsSummary struct {

	// The image vulnerability counts, sorted by severity.
	FindingSeverityCounts map[string]int64 `locationName:"findingSeverityCounts" type:"map"`

	// The time of the last completed image scan.
	ImageScanCompletedAt *time.Time `locationName:"imageScanCompletedAt" type:"timestamp"`

	// The time when the vulnerability data was last scanned.
	VulnerabilitySourceUpdatedAt *time.Time `locationName:"vulnerabilitySourceUpdatedAt" type:"timestamp"`
	// contains filtered or unexported fields
}

A summary of the last completed image scan.

func (ImageScanFindingsSummary) String added in v0.23.2 

func (s ImageScanFindingsSummary) String() string

String returns the string representation

type ImageScanStatus added in v0.23.2 

type ImageScanStatus struct {

	// The description of the image scan status.
	Description *string `locationName:"description" type:"string"`

	// The current state of an image scan.
	Status ScanStatus `locationName:"status" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

The current status of an image scan.

func (ImageScanStatus) String added in v0.23.2 

func (s ImageScanStatus) String() string

String returns the string representation

type ImageScanningConfiguration added in v0.23.2 

type ImageScanningConfiguration struct {

	// The setting that determines whether images are scanned after being pushed
	// to a repository. If set to true, images will be scanned after being pushed.
	// If this parameter is not specified, it will default to false and images will
	// not be scanned unless a scan is manually started with the StartImageScan
	// API.
	ScanOnPush *bool `locationName:"scanOnPush" type:"boolean"`
	// contains filtered or unexported fields
}

The image scanning configuration for a repository.

func (ImageScanningConfiguration) String added in v0.23.2 

func (s ImageScanningConfiguration) String() string

String returns the string representation

type ImageTagMutability added in v0.23.2 

type ImageTagMutability string
const (
	ImageTagMutabilityMutable   ImageTagMutability = "MUTABLE"
	ImageTagMutabilityImmutable ImageTagMutability = "IMMUTABLE"
)

Enum values for ImageTagMutability

func (ImageTagMutability) MarshalValue added in v0.23.2 

func (enum ImageTagMutability) MarshalValue() (string, error)

func (ImageTagMutability) MarshalValueBuf added in v0.23.2 

func (enum ImageTagMutability) MarshalValueBuf(b []byte) ([]byte, error)

type InitiateLayerUploadInput 

type InitiateLayerUploadInput struct {

	// The AWS account ID associated with the registry to which you intend to upload
	// layers. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to which you intend to upload layers.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (InitiateLayerUploadInput) String 

func (s InitiateLayerUploadInput) String() string

String returns the string representation

func (*InitiateLayerUploadInput) Validate 

func (s *InitiateLayerUploadInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type InitiateLayerUploadOutput 

type InitiateLayerUploadOutput struct {

	// The size, in bytes, that Amazon ECR expects future layer part uploads to
	// be.
	PartSize *int64 `locationName:"partSize" type:"long"`

	// The upload ID for the layer upload. This parameter is passed to further UploadLayerPart
	// and CompleteLayerUpload operations.
	UploadId *string `locationName:"uploadId" type:"string"`
	// contains filtered or unexported fields
}

func (InitiateLayerUploadOutput) String 

func (s InitiateLayerUploadOutput) String() string

String returns the string representation

type InitiateLayerUploadRequest 

type InitiateLayerUploadRequest struct {
	*aws.Request
	Input *InitiateLayerUploadInput
	Copy  func(*InitiateLayerUploadInput) InitiateLayerUploadRequest
}

InitiateLayerUploadRequest is the request type for the InitiateLayerUpload API operation.

func (InitiateLayerUploadRequest) Send 

func (r InitiateLayerUploadRequest) Send(ctx context.Context) (*InitiateLayerUploadResponse, error)

Send marshals and sends the InitiateLayerUpload API request.

type InitiateLayerUploadResponse added in v0.23.2 

type InitiateLayerUploadResponse struct {
	*InitiateLayerUploadOutput
	// contains filtered or unexported fields
}

InitiateLayerUploadResponse is the response type for the InitiateLayerUpload API operation.

func (*InitiateLayerUploadResponse) SDKResponseMetdata added in v0.23.2 

func (r *InitiateLayerUploadResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the InitiateLayerUpload request.

type Layer 

type Layer struct {

	// The availability status of the image layer.
	LayerAvailability LayerAvailability `locationName:"layerAvailability" type:"string" enum:"true"`

	// The sha256 digest of the image layer.
	LayerDigest *string `locationName:"layerDigest" type:"string"`

	// The size, in bytes, of the image layer.
	LayerSize *int64 `locationName:"layerSize" type:"long"`

	// The media type of the layer, such as application/vnd.docker.image.rootfs.diff.tar.gzip
	// or application/vnd.oci.image.layer.v1.tar+gzip.
	MediaType *string `locationName:"mediaType" type:"string"`
	// contains filtered or unexported fields
}

An object representing an Amazon ECR image layer.

func (Layer) String 

func (s Layer) String() string

String returns the string representation

type LayerAvailability 

type LayerAvailability string
const (
	LayerAvailabilityAvailable   LayerAvailability = "AVAILABLE"
	LayerAvailabilityUnavailable LayerAvailability = "UNAVAILABLE"
)

Enum values for LayerAvailability

func (LayerAvailability) MarshalValue added in v0.3.0 

func (enum LayerAvailability) MarshalValue() (string, error)

func (LayerAvailability) MarshalValueBuf added in v0.3.0 

func (enum LayerAvailability) MarshalValueBuf(b []byte) ([]byte, error)

type LayerFailure 

type LayerFailure struct {

	// The failure code associated with the failure.
	FailureCode LayerFailureCode `locationName:"failureCode" type:"string" enum:"true"`

	// The reason for the failure.
	FailureReason *string `locationName:"failureReason" type:"string"`

	// The layer digest associated with the failure.
	LayerDigest *string `locationName:"layerDigest" type:"string"`
	// contains filtered or unexported fields
}

An object representing an Amazon ECR image layer failure.

func (LayerFailure) String 

func (s LayerFailure) String() string

String returns the string representation

type LayerFailureCode 

type LayerFailureCode string
const (
	LayerFailureCodeInvalidLayerDigest LayerFailureCode = "InvalidLayerDigest"
	LayerFailureCodeMissingLayerDigest LayerFailureCode = "MissingLayerDigest"
)

Enum values for LayerFailureCode

func (LayerFailureCode) MarshalValue added in v0.3.0 

func (enum LayerFailureCode) MarshalValue() (string, error)

func (LayerFailureCode) MarshalValueBuf added in v0.3.0 

func (enum LayerFailureCode) MarshalValueBuf(b []byte) ([]byte, error)

type LifecyclePolicyPreviewFilter added in v0.2.0 

type LifecyclePolicyPreviewFilter struct {

	// The tag status of the image.
	TagStatus TagStatus `locationName:"tagStatus" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

The filter for the lifecycle policy preview.

func (LifecyclePolicyPreviewFilter) String added in v0.2.0 

func (s LifecyclePolicyPreviewFilter) String() string

String returns the string representation

type LifecyclePolicyPreviewResult added in v0.2.0 

type LifecyclePolicyPreviewResult struct {

	// The type of action to be taken.
	Action *LifecyclePolicyRuleAction `locationName:"action" type:"structure"`

	// The priority of the applied rule.
	AppliedRulePriority *int64 `locationName:"appliedRulePriority" min:"1" type:"integer"`

	// The sha256 digest of the image manifest.
	ImageDigest *string `locationName:"imageDigest" type:"string"`

	// The date and time, expressed in standard JavaScript date format, at which
	// the current image was pushed to the repository.
	ImagePushedAt *time.Time `locationName:"imagePushedAt" type:"timestamp"`

	// The list of tags associated with this image.
	ImageTags []string `locationName:"imageTags" type:"list"`
	// contains filtered or unexported fields
}

The result of the lifecycle policy preview.

func (LifecyclePolicyPreviewResult) String added in v0.2.0 

func (s LifecyclePolicyPreviewResult) String() string

String returns the string representation

type LifecyclePolicyPreviewStatus added in v0.2.0 

type LifecyclePolicyPreviewStatus string
const (
	LifecyclePolicyPreviewStatusInProgress LifecyclePolicyPreviewStatus = "IN_PROGRESS"
	LifecyclePolicyPreviewStatusComplete   LifecyclePolicyPreviewStatus = "COMPLETE"
	LifecyclePolicyPreviewStatusExpired    LifecyclePolicyPreviewStatus = "EXPIRED"
	LifecyclePolicyPreviewStatusFailed     LifecyclePolicyPreviewStatus = "FAILED"
)

Enum values for LifecyclePolicyPreviewStatus

func (LifecyclePolicyPreviewStatus) MarshalValue added in v0.3.0 

func (enum LifecyclePolicyPreviewStatus) MarshalValue() (string, error)

func (LifecyclePolicyPreviewStatus) MarshalValueBuf added in v0.3.0 

func (enum LifecyclePolicyPreviewStatus) MarshalValueBuf(b []byte) ([]byte, error)

type LifecyclePolicyPreviewSummary added in v0.2.0 

type LifecyclePolicyPreviewSummary struct {

	// The number of expiring images.
	ExpiringImageTotalCount *int64 `locationName:"expiringImageTotalCount" type:"integer"`
	// contains filtered or unexported fields
}

The summary of the lifecycle policy preview request.

func (LifecyclePolicyPreviewSummary) String added in v0.2.0 

func (s LifecyclePolicyPreviewSummary) String() string

String returns the string representation

type LifecyclePolicyRuleAction added in v0.2.0 

type LifecyclePolicyRuleAction struct {

	// The type of action to be taken.
	Type ImageActionType `locationName:"type" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

The type of action to be taken.

func (LifecyclePolicyRuleAction) String added in v0.2.0 

func (s LifecyclePolicyRuleAction) String() string

String returns the string representation

type ListImagesFilter 

type ListImagesFilter struct {

	// The tag status with which to filter your ListImages results. You can filter
	// results based on whether they are TAGGED or UNTAGGED.
	TagStatus TagStatus `locationName:"tagStatus" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

An object representing a filter on a ListImages operation.

func (ListImagesFilter) String 

func (s ListImagesFilter) String() string

String returns the string representation

type ListImagesInput 

type ListImagesInput struct {

	// The filter key and value with which to filter your ListImages results.
	Filter *ListImagesFilter `locationName:"filter" type:"structure"`

	// The maximum number of image results returned by ListImages in paginated output.
	// When this parameter is used, ListImages only returns maxResults results in
	// a single page along with a nextToken response element. The remaining results
	// of the initial request can be seen by sending another ListImages request
	// with the returned nextToken value. This value can be between 1 and 1000.
	// If this parameter is not used, then ListImages returns up to 100 results
	// and a nextToken value, if applicable.
	MaxResults *int64 `locationName:"maxResults" min:"1" type:"integer"`

	// The nextToken value returned from a previous paginated ListImages request
	// where maxResults was used and the results exceeded the value of that parameter.
	// Pagination continues from the end of the previous results that returned the
	// nextToken value. This value is null when there are no more results to return.
	//
	// This token should be treated as an opaque identifier that is only used to
	// retrieve the next items in a list and not for other programmatic purposes.
	NextToken *string `locationName:"nextToken" type:"string"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to list images. If you do not specify a registry, the default registry
	// is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository with image IDs to be listed.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (ListImagesInput) String 

func (s ListImagesInput) String() string

String returns the string representation

func (*ListImagesInput) Validate 

func (s *ListImagesInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListImagesOutput 

type ListImagesOutput struct {

	// The list of image IDs for the requested repository.
	ImageIds []ImageIdentifier `locationName:"imageIds" min:"1" type:"list"`

	// The nextToken value to include in a future ListImages request. When the results
	// of a ListImages request exceed maxResults, this value can be used to retrieve
	// the next page of results. This value is null when there are no more results
	// to return.
	NextToken *string `locationName:"nextToken" type:"string"`
	// contains filtered or unexported fields
}

func (ListImagesOutput) String 

func (s ListImagesOutput) String() string

String returns the string representation

type ListImagesPaginator added in v0.23.2 

type ListImagesPaginator struct {
	aws.Pager
}

ListImagesPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListImagesPaginator added in v0.23.2 

func NewListImagesPaginator(req ListImagesRequest) ListImagesPaginator

NewListImagesRequestPaginator returns a paginator for ListImages. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListImagesRequest(input)
p := ecr.NewListImagesRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListImagesPaginator) CurrentPage added in v0.23.2 

func (p *ListImagesPaginator) CurrentPage() *ListImagesOutput

type ListImagesRequest 

type ListImagesRequest struct {
	*aws.Request
	Input *ListImagesInput
	Copy  func(*ListImagesInput) ListImagesRequest
}

ListImagesRequest is the request type for the ListImages API operation.

func (ListImagesRequest) Send 

func (r ListImagesRequest) Send(ctx context.Context) (*ListImagesResponse, error)

Send marshals and sends the ListImages API request.

type ListImagesResponse added in v0.23.2 

type ListImagesResponse struct {
	*ListImagesOutput
	// contains filtered or unexported fields
}

ListImagesResponse is the response type for the ListImages API operation.

func (*ListImagesResponse) SDKResponseMetdata added in v0.23.2 

func (r *ListImagesResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListImages request.

type ListTagsForResourceInput added in v0.23.2 

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource for which to
	// list the tags. Currently, the only supported resource is an Amazon ECR repository.
	//
	// ResourceArn is a required field
	ResourceArn *string `locationName:"resourceArn" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (ListTagsForResourceInput) String added in v0.23.2 

func (s ListTagsForResourceInput) String() string

String returns the string representation

func (*ListTagsForResourceInput) Validate added in v0.23.2 

func (s *ListTagsForResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListTagsForResourceOutput added in v0.23.2 

type ListTagsForResourceOutput struct {

	// The tags for the resource.
	Tags []Tag `locationName:"tags" type:"list"`
	// contains filtered or unexported fields
}

func (ListTagsForResourceOutput) String added in v0.23.2 

func (s ListTagsForResourceOutput) String() string

String returns the string representation

type ListTagsForResourceRequest added in v0.23.2 

type ListTagsForResourceRequest struct {
	*aws.Request
	Input *ListTagsForResourceInput
	Copy  func(*ListTagsForResourceInput) ListTagsForResourceRequest
}

ListTagsForResourceRequest is the request type for the ListTagsForResource API operation.

func (ListTagsForResourceRequest) Send added in v0.23.2 

func (r ListTagsForResourceRequest) Send(ctx context.Context) (*ListTagsForResourceResponse, error)

Send marshals and sends the ListTagsForResource API request.

type ListTagsForResourceResponse added in v0.23.2 

type ListTagsForResourceResponse struct {
	*ListTagsForResourceOutput
	// contains filtered or unexported fields
}

ListTagsForResourceResponse is the response type for the ListTagsForResource API operation.

func (*ListTagsForResourceResponse) SDKResponseMetdata added in v0.23.2 

func (r *ListTagsForResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListTagsForResource request.

type PutImageInput 

type PutImageInput struct {

	// The image manifest corresponding to the image to be uploaded.
	//
	// ImageManifest is a required field
	ImageManifest *string `locationName:"imageManifest" min:"1" type:"string" required:"true"`

	// The media type of the image manifest. If you push an image manifest that
	// does not contain the mediaType field, you must specify the imageManifestMediaType
	// in the request.
	ImageManifestMediaType *string `locationName:"imageManifestMediaType" type:"string"`

	// The tag to associate with the image. This parameter is required for images
	// that use the Docker Image Manifest V2 Schema 2 or OCI formats.
	ImageTag *string `locationName:"imageTag" min:"1" type:"string"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to put the image. If you do not specify a registry, the default
	// registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository in which to put the image.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (PutImageInput) String 

func (s PutImageInput) String() string

String returns the string representation

func (*PutImageInput) Validate 

func (s *PutImageInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutImageOutput 

type PutImageOutput struct {

	// Details of the image uploaded.
	Image *Image `locationName:"image" type:"structure"`
	// contains filtered or unexported fields
}

func (PutImageOutput) String 

func (s PutImageOutput) String() string

String returns the string representation

type PutImageRequest 

type PutImageRequest struct {
	*aws.Request
	Input *PutImageInput
	Copy  func(*PutImageInput) PutImageRequest
}

PutImageRequest is the request type for the PutImage API operation.

func (PutImageRequest) Send 

func (r PutImageRequest) Send(ctx context.Context) (*PutImageResponse, error)

Send marshals and sends the PutImage API request.

type PutImageResponse added in v0.23.2 

type PutImageResponse struct {
	*PutImageOutput
	// contains filtered or unexported fields
}

PutImageResponse is the response type for the PutImage API operation.

func (*PutImageResponse) SDKResponseMetdata added in v0.23.2 

func (r *PutImageResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the PutImage request.

type PutImageScanningConfigurationInput added in v0.23.2 

type PutImageScanningConfigurationInput struct {

	// The image scanning configuration for the repository. This setting determines
	// whether images are scanned for known vulnerabilities after being pushed to
	// the repository.
	//
	// ImageScanningConfiguration is a required field
	ImageScanningConfiguration *ImageScanningConfiguration `locationName:"imageScanningConfiguration" type:"structure" required:"true"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to update the image scanning configuration setting. If you do not
	// specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository in which to update the image scanning configuration
	// setting.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (PutImageScanningConfigurationInput) String added in v0.23.2 

func (s PutImageScanningConfigurationInput) String() string

String returns the string representation

func (*PutImageScanningConfigurationInput) Validate added in v0.23.2 

func (s *PutImageScanningConfigurationInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutImageScanningConfigurationOutput added in v0.23.2 

type PutImageScanningConfigurationOutput struct {

	// The image scanning configuration setting for the repository.
	ImageScanningConfiguration *ImageScanningConfiguration `locationName:"imageScanningConfiguration" type:"structure"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (PutImageScanningConfigurationOutput) String added in v0.23.2 

func (s PutImageScanningConfigurationOutput) String() string

String returns the string representation

type PutImageScanningConfigurationRequest added in v0.23.2 

type PutImageScanningConfigurationRequest struct {
	*aws.Request
	Input *PutImageScanningConfigurationInput
	Copy  func(*PutImageScanningConfigurationInput) PutImageScanningConfigurationRequest
}

PutImageScanningConfigurationRequest is the request type for the PutImageScanningConfiguration API operation.

func (PutImageScanningConfigurationRequest) Send added in v0.23.2 

func (r PutImageScanningConfigurationRequest) Send(ctx context.Context) (*PutImageScanningConfigurationResponse, error)

Send marshals and sends the PutImageScanningConfiguration API request.

type PutImageScanningConfigurationResponse added in v0.23.2 

type PutImageScanningConfigurationResponse struct {
	*PutImageScanningConfigurationOutput
	// contains filtered or unexported fields
}

PutImageScanningConfigurationResponse is the response type for the PutImageScanningConfiguration API operation.

func (*PutImageScanningConfigurationResponse) SDKResponseMetdata added in v0.23.2 

func (r *PutImageScanningConfigurationResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the PutImageScanningConfiguration request.

type PutImageTagMutabilityInput added in v0.23.2 

type PutImageTagMutabilityInput struct {

	// The tag mutability setting for the repository. If MUTABLE is specified, image
	// tags can be overwritten. If IMMUTABLE is specified, all image tags within
	// the repository will be immutable which will prevent them from being overwritten.
	//
	// ImageTagMutability is a required field
	ImageTagMutability ImageTagMutability `locationName:"imageTagMutability" type:"string" required:"true" enum:"true"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to update the image tag mutability settings. If you do not specify
	// a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository in which to update the image tag mutability settings.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (PutImageTagMutabilityInput) String added in v0.23.2 

func (s PutImageTagMutabilityInput) String() string

String returns the string representation

func (*PutImageTagMutabilityInput) Validate added in v0.23.2 

func (s *PutImageTagMutabilityInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutImageTagMutabilityOutput added in v0.23.2 

type PutImageTagMutabilityOutput struct {

	// The image tag mutability setting for the repository.
	ImageTagMutability ImageTagMutability `locationName:"imageTagMutability" type:"string" enum:"true"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (PutImageTagMutabilityOutput) String added in v0.23.2 

func (s PutImageTagMutabilityOutput) String() string

String returns the string representation

type PutImageTagMutabilityRequest added in v0.23.2 

type PutImageTagMutabilityRequest struct {
	*aws.Request
	Input *PutImageTagMutabilityInput
	Copy  func(*PutImageTagMutabilityInput) PutImageTagMutabilityRequest
}

PutImageTagMutabilityRequest is the request type for the PutImageTagMutability API operation.

func (PutImageTagMutabilityRequest) Send added in v0.23.2 

func (r PutImageTagMutabilityRequest) Send(ctx context.Context) (*PutImageTagMutabilityResponse, error)

Send marshals and sends the PutImageTagMutability API request.

type PutImageTagMutabilityResponse added in v0.23.2 

type PutImageTagMutabilityResponse struct {
	*PutImageTagMutabilityOutput
	// contains filtered or unexported fields
}

PutImageTagMutabilityResponse is the response type for the PutImageTagMutability API operation.

func (*PutImageTagMutabilityResponse) SDKResponseMetdata added in v0.23.2 

func (r *PutImageTagMutabilityResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the PutImageTagMutability request.

type PutLifecyclePolicyInput added in v0.2.0 

type PutLifecyclePolicyInput struct {

	// The JSON repository policy text to apply to the repository.
	//
	// LifecyclePolicyText is a required field
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string" required:"true"`

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to receive the policy.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (PutLifecyclePolicyInput) String added in v0.2.0 

func (s PutLifecyclePolicyInput) String() string

String returns the string representation

func (*PutLifecyclePolicyInput) Validate added in v0.2.0 

func (s *PutLifecyclePolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PutLifecyclePolicyOutput added in v0.2.0 

type PutLifecyclePolicyOutput struct {

	// The JSON repository policy text.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (PutLifecyclePolicyOutput) String added in v0.2.0 

func (s PutLifecyclePolicyOutput) String() string

String returns the string representation

type PutLifecyclePolicyRequest added in v0.2.0 

type PutLifecyclePolicyRequest struct {
	*aws.Request
	Input *PutLifecyclePolicyInput
	Copy  func(*PutLifecyclePolicyInput) PutLifecyclePolicyRequest
}

PutLifecyclePolicyRequest is the request type for the PutLifecyclePolicy API operation.

func (PutLifecyclePolicyRequest) Send added in v0.2.0 

func (r PutLifecyclePolicyRequest) Send(ctx context.Context) (*PutLifecyclePolicyResponse, error)

Send marshals and sends the PutLifecyclePolicy API request.

type PutLifecyclePolicyResponse added in v0.23.2 

type PutLifecyclePolicyResponse struct {
	*PutLifecyclePolicyOutput
	// contains filtered or unexported fields
}

PutLifecyclePolicyResponse is the response type for the PutLifecyclePolicy API operation.

func (*PutLifecyclePolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *PutLifecyclePolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the PutLifecyclePolicy request.

type Repository 

type Repository struct {

	// The date and time, in JavaScript date format, when the repository was created.
	CreatedAt *time.Time `locationName:"createdAt" type:"timestamp"`

	// The image scanning configuration for a repository.
	ImageScanningConfiguration *ImageScanningConfiguration `locationName:"imageScanningConfiguration" type:"structure"`

	// The tag mutability setting for the repository.
	ImageTagMutability ImageTagMutability `locationName:"imageTagMutability" type:"string" enum:"true"`

	// The AWS account ID associated with the registry that contains the repository.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The Amazon Resource Name (ARN) that identifies the repository. The ARN contains
	// the arn:aws:ecr namespace, followed by the region of the repository, AWS
	// account ID of the repository owner, repository namespace, and repository
	// name. For example, arn:aws:ecr:region:012345678910:repository/test.
	RepositoryArn *string `locationName:"repositoryArn" type:"string"`

	// The name of the repository.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`

	// The URI for the repository. You can use this URI for Docker push or pull
	// operations.
	RepositoryUri *string `locationName:"repositoryUri" type:"string"`
	// contains filtered or unexported fields
}

An object representing a repository.

func (Repository) String 

func (s Repository) String() string

String returns the string representation

type ScanStatus added in v0.23.2 

type ScanStatus string
const (
	ScanStatusInProgress ScanStatus = "IN_PROGRESS"
	ScanStatusComplete   ScanStatus = "COMPLETE"
	ScanStatusFailed     ScanStatus = "FAILED"
)

Enum values for ScanStatus

func (ScanStatus) MarshalValue added in v0.23.2 

func (enum ScanStatus) MarshalValue() (string, error)

func (ScanStatus) MarshalValueBuf added in v0.23.2 

func (enum ScanStatus) MarshalValueBuf(b []byte) ([]byte, error)

type SetRepositoryPolicyInput 

type SetRepositoryPolicyInput struct {

	// If the policy you are attempting to set on a repository policy would prevent
	// you from setting another policy in the future, you must force the SetRepositoryPolicy
	// operation. This is intended to prevent accidental repository lock outs.
	Force *bool `locationName:"force" type:"boolean"`

	// The JSON repository policy text to apply to the repository. For more information,
	// see Amazon ECR Repository Policies (https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)
	// in the Amazon Elastic Container Registry User Guide.
	//
	// PolicyText is a required field
	PolicyText *string `locationName:"policyText" type:"string" required:"true"`

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to receive the policy.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (SetRepositoryPolicyInput) String 

func (s SetRepositoryPolicyInput) String() string

String returns the string representation

func (*SetRepositoryPolicyInput) Validate 

func (s *SetRepositoryPolicyInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SetRepositoryPolicyOutput 

type SetRepositoryPolicyOutput struct {

	// The JSON repository policy text applied to the repository.
	PolicyText *string `locationName:"policyText" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (SetRepositoryPolicyOutput) String 

func (s SetRepositoryPolicyOutput) String() string

String returns the string representation

type SetRepositoryPolicyRequest 

type SetRepositoryPolicyRequest struct {
	*aws.Request
	Input *SetRepositoryPolicyInput
	Copy  func(*SetRepositoryPolicyInput) SetRepositoryPolicyRequest
}

SetRepositoryPolicyRequest is the request type for the SetRepositoryPolicy API operation.

func (SetRepositoryPolicyRequest) Send 

func (r SetRepositoryPolicyRequest) Send(ctx context.Context) (*SetRepositoryPolicyResponse, error)

Send marshals and sends the SetRepositoryPolicy API request.

type SetRepositoryPolicyResponse added in v0.23.2 

type SetRepositoryPolicyResponse struct {
	*SetRepositoryPolicyOutput
	// contains filtered or unexported fields
}

SetRepositoryPolicyResponse is the response type for the SetRepositoryPolicy API operation.

func (*SetRepositoryPolicyResponse) SDKResponseMetdata added in v0.23.2 

func (r *SetRepositoryPolicyResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the SetRepositoryPolicy request.

type StartImageScanInput added in v0.23.2 

type StartImageScanInput struct {

	// An object with identifying information for an Amazon ECR image.
	//
	// ImageId is a required field
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure" required:"true"`

	// The AWS account ID associated with the registry that contains the repository
	// in which to start an image scan request. If you do not specify a registry,
	// the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository that contains the images to scan.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (StartImageScanInput) String added in v0.23.2 

func (s StartImageScanInput) String() string

String returns the string representation

func (*StartImageScanInput) Validate added in v0.23.2 

func (s *StartImageScanInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type StartImageScanOutput added in v0.23.2 

type StartImageScanOutput struct {

	// An object with identifying information for an Amazon ECR image.
	ImageId *ImageIdentifier `locationName:"imageId" type:"structure"`

	// The current state of the scan.
	ImageScanStatus *ImageScanStatus `locationName:"imageScanStatus" type:"structure"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`
	// contains filtered or unexported fields
}

func (StartImageScanOutput) String added in v0.23.2 

func (s StartImageScanOutput) String() string

String returns the string representation

type StartImageScanRequest added in v0.23.2 

type StartImageScanRequest struct {
	*aws.Request
	Input *StartImageScanInput
	Copy  func(*StartImageScanInput) StartImageScanRequest
}

StartImageScanRequest is the request type for the StartImageScan API operation.

func (StartImageScanRequest) Send added in v0.23.2 

func (r StartImageScanRequest) Send(ctx context.Context) (*StartImageScanResponse, error)

Send marshals and sends the StartImageScan API request.

type StartImageScanResponse added in v0.23.2 

type StartImageScanResponse struct {
	*StartImageScanOutput
	// contains filtered or unexported fields
}

StartImageScanResponse is the response type for the StartImageScan API operation.

func (*StartImageScanResponse) SDKResponseMetdata added in v0.23.2 

func (r *StartImageScanResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the StartImageScan request.

type StartLifecyclePolicyPreviewInput added in v0.2.0 

type StartLifecyclePolicyPreviewInput struct {

	// The policy to be evaluated against. If you do not specify a policy, the current
	// policy for the repository is used.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The AWS account ID associated with the registry that contains the repository.
	// If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to be evaluated.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (StartLifecyclePolicyPreviewInput) String added in v0.2.0 

func (s StartLifecyclePolicyPreviewInput) String() string

String returns the string representation

func (*StartLifecyclePolicyPreviewInput) Validate added in v0.2.0 

func (s *StartLifecyclePolicyPreviewInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type StartLifecyclePolicyPreviewOutput added in v0.2.0 

type StartLifecyclePolicyPreviewOutput struct {

	// The JSON repository policy text.
	LifecyclePolicyText *string `locationName:"lifecyclePolicyText" min:"100" type:"string"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`

	// The status of the lifecycle policy preview request.
	Status LifecyclePolicyPreviewStatus `locationName:"status" type:"string" enum:"true"`
	// contains filtered or unexported fields
}

func (StartLifecyclePolicyPreviewOutput) String added in v0.2.0 

func (s StartLifecyclePolicyPreviewOutput) String() string

String returns the string representation

type StartLifecyclePolicyPreviewRequest added in v0.2.0 

type StartLifecyclePolicyPreviewRequest struct {
	*aws.Request
	Input *StartLifecyclePolicyPreviewInput
	Copy  func(*StartLifecyclePolicyPreviewInput) StartLifecyclePolicyPreviewRequest
}

StartLifecyclePolicyPreviewRequest is the request type for the StartLifecyclePolicyPreview API operation.

func (StartLifecyclePolicyPreviewRequest) Send added in v0.2.0 

func (r StartLifecyclePolicyPreviewRequest) Send(ctx context.Context) (*StartLifecyclePolicyPreviewResponse, error)

Send marshals and sends the StartLifecyclePolicyPreview API request.

type StartLifecyclePolicyPreviewResponse added in v0.23.2 

type StartLifecyclePolicyPreviewResponse struct {
	*StartLifecyclePolicyPreviewOutput
	// contains filtered or unexported fields
}

StartLifecyclePolicyPreviewResponse is the response type for the StartLifecyclePolicyPreview API operation.

func (*StartLifecyclePolicyPreviewResponse) SDKResponseMetdata added in v0.23.2 

func (r *StartLifecyclePolicyPreviewResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the StartLifecyclePolicyPreview request.

type Tag added in v0.23.2 

type Tag struct {

	// One part of a key-value pair that make up a tag. A key is a general label
	// that acts like a category for more specific tag values.
	Key *string `type:"string"`

	// The optional part of a key-value pair that make up a tag. A value acts as
	// a descriptor within a tag category (key).
	Value *string `type:"string"`
	// contains filtered or unexported fields
}

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

func (Tag) String added in v0.23.2 

func (s Tag) String() string

String returns the string representation

type TagResourceInput added in v0.23.2 

type TagResourceInput struct {

	// The Amazon Resource Name (ARN) of the the resource to which to add tags.
	// Currently, the only supported resource is an Amazon ECR repository.
	//
	// ResourceArn is a required field
	ResourceArn *string `locationName:"resourceArn" type:"string" required:"true"`

	// The tags to add to the resource. A tag is an array of key-value pairs. Tag
	// keys can have a maximum character length of 128 characters, and tag values
	// can have a maximum length of 256 characters.
	//
	// Tags is a required field
	Tags []Tag `locationName:"tags" type:"list" required:"true"`
	// contains filtered or unexported fields
}

func (TagResourceInput) String added in v0.23.2 

func (s TagResourceInput) String() string

String returns the string representation

func (*TagResourceInput) Validate added in v0.23.2 

func (s *TagResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type TagResourceOutput added in v0.23.2 

type TagResourceOutput struct {
	// contains filtered or unexported fields
}

func (TagResourceOutput) String added in v0.23.2 

func (s TagResourceOutput) String() string

String returns the string representation

type TagResourceRequest added in v0.23.2 

type TagResourceRequest struct {
	*aws.Request
	Input *TagResourceInput
	Copy  func(*TagResourceInput) TagResourceRequest
}

TagResourceRequest is the request type for the TagResource API operation.

func (TagResourceRequest) Send added in v0.23.2 

func (r TagResourceRequest) Send(ctx context.Context) (*TagResourceResponse, error)

Send marshals and sends the TagResource API request.

type TagResourceResponse added in v0.23.2 

type TagResourceResponse struct {
	*TagResourceOutput
	// contains filtered or unexported fields
}

TagResourceResponse is the response type for the TagResource API operation.

func (*TagResourceResponse) SDKResponseMetdata added in v0.23.2 

func (r *TagResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the TagResource request.

type TagStatus 

type TagStatus string
const (
	TagStatusTagged   TagStatus = "TAGGED"
	TagStatusUntagged TagStatus = "UNTAGGED"
	TagStatusAny      TagStatus = "ANY"
)

Enum values for TagStatus

func (TagStatus) MarshalValue added in v0.3.0 

func (enum TagStatus) MarshalValue() (string, error)

func (TagStatus) MarshalValueBuf added in v0.3.0 

func (enum TagStatus) MarshalValueBuf(b []byte) ([]byte, error)

type UntagResourceInput added in v0.23.2 

type UntagResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource from which to remove tags.
	// Currently, the only supported resource is an Amazon ECR repository.
	//
	// ResourceArn is a required field
	ResourceArn *string `locationName:"resourceArn" type:"string" required:"true"`

	// The keys of the tags to be removed.
	//
	// TagKeys is a required field
	TagKeys []string `locationName:"tagKeys" type:"list" required:"true"`
	// contains filtered or unexported fields
}

func (UntagResourceInput) String added in v0.23.2 

func (s UntagResourceInput) String() string

String returns the string representation

func (*UntagResourceInput) Validate added in v0.23.2 

func (s *UntagResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UntagResourceOutput added in v0.23.2 

type UntagResourceOutput struct {
	// contains filtered or unexported fields
}

func (UntagResourceOutput) String added in v0.23.2 

func (s UntagResourceOutput) String() string

String returns the string representation

type UntagResourceRequest added in v0.23.2 

type UntagResourceRequest struct {
	*aws.Request
	Input *UntagResourceInput
	Copy  func(*UntagResourceInput) UntagResourceRequest
}

UntagResourceRequest is the request type for the UntagResource API operation.

func (UntagResourceRequest) Send added in v0.23.2 

func (r UntagResourceRequest) Send(ctx context.Context) (*UntagResourceResponse, error)

Send marshals and sends the UntagResource API request.

type UntagResourceResponse added in v0.23.2 

type UntagResourceResponse struct {
	*UntagResourceOutput
	// contains filtered or unexported fields
}

UntagResourceResponse is the response type for the UntagResource API operation.

func (*UntagResourceResponse) SDKResponseMetdata added in v0.23.2 

func (r *UntagResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the UntagResource request.

type UploadLayerPartInput 

type UploadLayerPartInput struct {

	// The base64-encoded layer part payload.
	//
	// LayerPartBlob is automatically base64 encoded/decoded by the SDK.
	//
	// LayerPartBlob is a required field
	LayerPartBlob []byte `locationName:"layerPartBlob" type:"blob" required:"true"`

	// The position of the first byte of the layer part witin the overall image
	// layer.
	//
	// PartFirstByte is a required field
	PartFirstByte *int64 `locationName:"partFirstByte" type:"long" required:"true"`

	// The position of the last byte of the layer part within the overall image
	// layer.
	//
	// PartLastByte is a required field
	PartLastByte *int64 `locationName:"partLastByte" type:"long" required:"true"`

	// The AWS account ID associated with the registry to which you are uploading
	// layer parts. If you do not specify a registry, the default registry is assumed.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The name of the repository to which you are uploading layer parts.
	//
	// RepositoryName is a required field
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string" required:"true"`

	// The upload ID from a previous InitiateLayerUpload operation to associate
	// with the layer part upload.
	//
	// UploadId is a required field
	UploadId *string `locationName:"uploadId" type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (UploadLayerPartInput) String 

func (s UploadLayerPartInput) String() string

String returns the string representation

func (*UploadLayerPartInput) Validate 

func (s *UploadLayerPartInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UploadLayerPartOutput 

type UploadLayerPartOutput struct {

	// The integer value of the last byte received in the request.
	LastByteReceived *int64 `locationName:"lastByteReceived" type:"long"`

	// The registry ID associated with the request.
	RegistryId *string `locationName:"registryId" type:"string"`

	// The repository name associated with the request.
	RepositoryName *string `locationName:"repositoryName" min:"2" type:"string"`

	// The upload ID associated with the request.
	UploadId *string `locationName:"uploadId" type:"string"`
	// contains filtered or unexported fields
}

func (UploadLayerPartOutput) String 

func (s UploadLayerPartOutput) String() string

String returns the string representation

type UploadLayerPartRequest 

type UploadLayerPartRequest struct {
	*aws.Request
	Input *UploadLayerPartInput
	Copy  func(*UploadLayerPartInput) UploadLayerPartRequest
}

UploadLayerPartRequest is the request type for the UploadLayerPart API operation.

func (UploadLayerPartRequest) Send 

func (r UploadLayerPartRequest) Send(ctx context.Context) (*UploadLayerPartResponse, error)

Send marshals and sends the UploadLayerPart API request.

type UploadLayerPartResponse added in v0.23.2 

type UploadLayerPartResponse struct {
	*UploadLayerPartOutput
	// contains filtered or unexported fields
}

UploadLayerPartResponse is the response type for the UploadLayerPart API operation.

func (*UploadLayerPartResponse) SDKResponseMetdata added in v0.23.2 

func (r *UploadLayerPartResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the UploadLayerPart request.

Source Files

View all Source files

Directories

Path Synopsis
Package ecriface provides an interface to enable mocking the Amazon EC2 Container Registry service client for testing your code.
 Package ecriface provides an interface to enable mocking the Amazon EC2 Container Registry service client for testing your code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.