Module types

By default, when no encryption configuration is set or the AES256 encryption type is used, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts your data at rest using an AES256 encryption algorithm. This does not require any action on your part.

For more control over the encryption of the contents of your repository, you can use server-side encryption with Key Management Service key stored in Key Management Service (KMS) to encrypt your images. For more information, see Amazon ECR encryption at rest in the Amazon Elastic Container Registry User Guide.

EncryptionConfigurationForRepositoryCreationTemplate

The encryption configuration to associate with the repository creation template.

EnhancedImageScanFinding

The details of an enhanced image scan. This is returned when enhanced scanning is enabled for your private registry.

Image

An object representing an Amazon ECR image.

ImageDetail

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

ImageFailure

An object representing an Amazon ECR image failure.

ImageIdentifier

An object with identifying information for an image in an Amazon ECR repository.

ImageReplicationStatus

The status of the replication process for an image.

ImageScanFinding

Contains information about an image scan finding.

ImageScanFindings

The details of an image scan.

ImageScanFindingsSummary

A summary of the last completed image scan.

ImageScanStatus

The current status of an image scan.

ImageScanningConfiguration

The image scanning configuration for a repository.

ImageTagMutabilityExclusionFilter

Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.

Layer

An object representing an Amazon ECR image layer.

LayerFailure

An object representing an Amazon ECR image layer failure.

LifecyclePolicyPreviewFilter

The filter for the lifecycle policy preview.

LifecyclePolicyPreviewResult

The result of the lifecycle policy preview.

LifecyclePolicyPreviewSummary

The summary of the lifecycle policy preview request.

LifecyclePolicyRuleAction

The type of action to be taken.

ListImagesFilter

An object representing a filter on a ListImages operation.

PackageVulnerabilityDetails

Information about a package vulnerability finding.

PullThroughCacheRule

The details of a pull through cache rule.

Recommendation

Details about the recommended course of action to remediate the finding.

RegistryScanningConfiguration

The scanning configuration for a private registry.

RegistryScanningRule

The details of a scanning rule for a private registry.

Remediation

Information on how to remediate a finding.

ReplicationConfiguration

The replication configuration for a registry.

ReplicationDestination

An array of objects representing the destination for a replication rule.

ReplicationRule

An array of objects representing the replication destinations and repository filters for a replication configuration.

Repository

An object representing a repository.

RepositoryCreationTemplate

The details of the repository creation template associated with the request.

RepositoryFilter

The filter settings used with image replication. Specifying a repository filter to a replication rule provides a method for controlling which repositories in a private registry are replicated. If no filters are added, the contents of all repositories are replicated.

RepositoryScanningConfiguration

The details of the scanning configuration for a repository.

RepositoryScanningConfigurationFailure

The details about any failures associated with the scanning configuration of a repository.

Resource

Details about the resource involved in a finding.

ResourceDetails

Contains details about the resource involved in the finding.

ScanningRepositoryFilter

The details of a scanning repository filter. For more information on how to use filters, see Using filters in the Amazon Elastic Container Registry User Guide.

ScoreDetails

Information about the Amazon Inspector score given to a finding.

Tag

The metadata to apply to a resource to help you categorize and organize them. Each tag consists of a key and a 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.

VulnerablePackage

Information on the vulnerable package identified by a finding.

Enums§

EncryptionType: When writing a match expression against EncryptionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FindingSeverity: When writing a match expression against FindingSeverity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ImageActionType: When writing a match expression against ImageActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ImageFailureCode: When writing a match expression against ImageFailureCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ImageTagMutability: When writing a match expression against ImageTagMutability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ImageTagMutabilityExclusionFilterType: When writing a match expression against ImageTagMutabilityExclusionFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LayerAvailability: When writing a match expression against LayerAvailability, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LayerFailureCode: When writing a match expression against LayerFailureCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LifecyclePolicyPreviewStatus: When writing a match expression against LifecyclePolicyPreviewStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
RctAppliedFor: When writing a match expression against RctAppliedFor, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReplicationStatus: When writing a match expression against ReplicationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
RepositoryFilterType: When writing a match expression against RepositoryFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScanFrequency: When writing a match expression against ScanFrequency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScanStatus: When writing a match expression against ScanStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScanType: When writing a match expression against ScanType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScanningConfigurationFailureCode: When writing a match expression against ScanningConfigurationFailureCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScanningRepositoryFilterType: When writing a match expression against ScanningRepositoryFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TagStatus: When writing a match expression against TagStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
UpstreamRegistry: When writing a match expression against UpstreamRegistry, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module types

Module types Copy item path

Modules§

Structs§

Enums§

Module types