ecr

package
v0.104.0 Latest Latest
Warning

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

 Go to latest Published: Apr 30, 2024 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	RepositoryCreationTemplateAppliedForItemReplication      = RepositoryCreationTemplateAppliedForItem("REPLICATION")
	RepositoryCreationTemplateAppliedForItemPullThroughCache = RepositoryCreationTemplateAppliedForItem("PULL_THROUGH_CACHE")
)
View Source 
const (
	RepositoryCreationTemplateEncryptionTypeAes256 = RepositoryCreationTemplateEncryptionType("AES256")
	RepositoryCreationTemplateEncryptionTypeKms    = RepositoryCreationTemplateEncryptionType("KMS")
)
View Source 
const (
	RepositoryCreationTemplateImageTagMutabilityMutable   = RepositoryCreationTemplateImageTagMutability("MUTABLE")
	RepositoryCreationTemplateImageTagMutabilityImmutable = RepositoryCreationTemplateImageTagMutability("IMMUTABLE")
)
View Source 
const (
	RepositoryEncryptionTypeAes256 = RepositoryEncryptionType("AES256")
	RepositoryEncryptionTypeKms    = RepositoryEncryptionType("KMS")
)
View Source 
const (
	RepositoryImageTagMutabilityMutable   = RepositoryImageTagMutability("MUTABLE")
	RepositoryImageTagMutabilityImmutable = RepositoryImageTagMutability("IMMUTABLE")
)
View Source 
const (
	ReplicationConfigurationFilterTypePrefixMatch = ReplicationConfigurationFilterType("PREFIX_MATCH")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type LookupRegistryPolicyArgs added in v0.12.0 

type LookupRegistryPolicyArgs struct {
	RegistryId string `pulumi:"registryId"`
}

type LookupRegistryPolicyOutputArgs added in v0.12.0 

type LookupRegistryPolicyOutputArgs struct {
	RegistryId pulumi.StringInput `pulumi:"registryId"`
}

func (LookupRegistryPolicyOutputArgs) ElementType added in v0.12.0 

func (LookupRegistryPolicyOutputArgs) ElementType() reflect.Type

type LookupRegistryPolicyResult added in v0.12.0 

type LookupRegistryPolicyResult struct {
	// The JSON policy text for your registry.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::RegistryPolicy` for more information about the expected schema for this property.
	PolicyText interface{} `pulumi:"policyText"`
	RegistryId *string     `pulumi:"registryId"`
}

func LookupRegistryPolicy added in v0.12.0 

func LookupRegistryPolicy(ctx *pulumi.Context, args *LookupRegistryPolicyArgs, opts ...pulumi.InvokeOption) (*LookupRegistryPolicyResult, error)

The “AWS::ECR::RegistryPolicy“ resource creates or updates the permissions policy for a private registry. 

A private registry policy is used to specify permissions for another AWS-account and is used when configuring cross-account replication. For more information, see [Registry permissions](https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry-permissions.html) in the *Amazon Elastic Container Registry User Guide*.

type LookupRegistryPolicyResultOutput added in v0.12.0 

type LookupRegistryPolicyResultOutput struct{ *pulumi.OutputState }

func LookupRegistryPolicyOutput added in v0.12.0 

func LookupRegistryPolicyOutput(ctx *pulumi.Context, args LookupRegistryPolicyOutputArgs, opts ...pulumi.InvokeOption) LookupRegistryPolicyResultOutput

func (LookupRegistryPolicyResultOutput) ElementType added in v0.12.0 

func (LookupRegistryPolicyResultOutput) ElementType() reflect.Type

func (LookupRegistryPolicyResultOutput) PolicyText added in v0.12.0 

func (o LookupRegistryPolicyResultOutput) PolicyText() pulumi.AnyOutput

The JSON policy text for your registry.

Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::RegistryPolicy` for more information about the expected schema for this property.

func (LookupRegistryPolicyResultOutput) RegistryId added in v0.12.0 

func (o LookupRegistryPolicyResultOutput) RegistryId() pulumi.StringPtrOutput

func (LookupRegistryPolicyResultOutput) ToLookupRegistryPolicyResultOutput added in v0.12.0 

func (o LookupRegistryPolicyResultOutput) ToLookupRegistryPolicyResultOutput() LookupRegistryPolicyResultOutput

func (LookupRegistryPolicyResultOutput) ToLookupRegistryPolicyResultOutputWithContext added in v0.12.0 

func (o LookupRegistryPolicyResultOutput) ToLookupRegistryPolicyResultOutputWithContext(ctx context.Context) LookupRegistryPolicyResultOutput

type LookupReplicationConfigurationArgs added in v0.12.0 

type LookupReplicationConfigurationArgs struct {
	// The RegistryId associated with the aws account.
	RegistryId string `pulumi:"registryId"`
}

type LookupReplicationConfigurationOutputArgs added in v0.12.0 

type LookupReplicationConfigurationOutputArgs struct {
	// The RegistryId associated with the aws account.
	RegistryId pulumi.StringInput `pulumi:"registryId"`
}

func (LookupReplicationConfigurationOutputArgs) ElementType added in v0.12.0 

func (LookupReplicationConfigurationOutputArgs) ElementType() reflect.Type

type LookupReplicationConfigurationResult added in v0.12.0 

type LookupReplicationConfigurationResult struct {
	// The RegistryId associated with the aws account.
	RegistryId               *string                       `pulumi:"registryId"`
	ReplicationConfiguration *ReplicationConfigurationType `pulumi:"replicationConfiguration"`
}

func LookupReplicationConfiguration added in v0.12.0 

func LookupReplicationConfiguration(ctx *pulumi.Context, args *LookupReplicationConfigurationArgs, opts ...pulumi.InvokeOption) (*LookupReplicationConfigurationResult, error)

The AWS::ECR::ReplicationConfiguration resource configures the replication destinations for an Amazon Elastic Container Registry (Amazon Private ECR). For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/replication.html

type LookupReplicationConfigurationResultOutput added in v0.12.0 

type LookupReplicationConfigurationResultOutput struct{ *pulumi.OutputState }

func LookupReplicationConfigurationOutput added in v0.12.0 

func LookupReplicationConfigurationOutput(ctx *pulumi.Context, args LookupReplicationConfigurationOutputArgs, opts ...pulumi.InvokeOption) LookupReplicationConfigurationResultOutput

func (LookupReplicationConfigurationResultOutput) ElementType added in v0.12.0 

func (LookupReplicationConfigurationResultOutput) ElementType() reflect.Type

func (LookupReplicationConfigurationResultOutput) RegistryId added in v0.12.0 

func (o LookupReplicationConfigurationResultOutput) RegistryId() pulumi.StringPtrOutput

The RegistryId associated with the aws account.

func (LookupReplicationConfigurationResultOutput) ReplicationConfiguration added in v0.12.0 

func (o LookupReplicationConfigurationResultOutput) ReplicationConfiguration() ReplicationConfigurationTypePtrOutput

func (LookupReplicationConfigurationResultOutput) ToLookupReplicationConfigurationResultOutput added in v0.12.0 

func (o LookupReplicationConfigurationResultOutput) ToLookupReplicationConfigurationResultOutput() LookupReplicationConfigurationResultOutput

func (LookupReplicationConfigurationResultOutput) ToLookupReplicationConfigurationResultOutputWithContext added in v0.12.0 

func (o LookupReplicationConfigurationResultOutput) ToLookupReplicationConfigurationResultOutputWithContext(ctx context.Context) LookupReplicationConfigurationResultOutput

type LookupRepositoryArgs added in v0.12.0 

type LookupRepositoryArgs struct {
	// 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“). If you don't specify a name, CFNlong generates a unique physical ID and uses that ID for the repository name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html).
	//  The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.
	//   If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
	RepositoryName string `pulumi:"repositoryName"`
}

type LookupRepositoryCreationTemplateArgs added in v0.103.0 

type LookupRepositoryCreationTemplateArgs struct {
	// The prefix use to match the repository name and apply the template.
	Prefix string `pulumi:"prefix"`
}

type LookupRepositoryCreationTemplateOutputArgs added in v0.103.0 

type LookupRepositoryCreationTemplateOutputArgs struct {
	// The prefix use to match the repository name and apply the template.
	Prefix pulumi.StringInput `pulumi:"prefix"`
}

func (LookupRepositoryCreationTemplateOutputArgs) ElementType added in v0.103.0 

func (LookupRepositoryCreationTemplateOutputArgs) ElementType() reflect.Type

type LookupRepositoryCreationTemplateResult added in v0.103.0 

type LookupRepositoryCreationTemplateResult struct {
	// A list of enumerable Strings representing the repository creation scenarios that the template will apply towards.
	AppliedFor []RepositoryCreationTemplateAppliedForItem `pulumi:"appliedFor"`
	// Create timestamp of the template.
	CreatedAt *string `pulumi:"createdAt"`
	// The description of the template.
	Description             *string                                            `pulumi:"description"`
	EncryptionConfiguration *RepositoryCreationTemplateEncryptionConfiguration `pulumi:"encryptionConfiguration"`
	// The image tag mutability setting for the repository.
	ImageTagMutability *RepositoryCreationTemplateImageTagMutability `pulumi:"imageTagMutability"`
	// The JSON lifecycle policy text to apply to the repository. For information about lifecycle policy syntax, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html
	LifecyclePolicy *string `pulumi:"lifecyclePolicy"`
	// The JSON repository policy text to apply to the repository. For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html
	RepositoryPolicy *string `pulumi:"repositoryPolicy"`
	// An array of key-value pairs to apply to this resource.
	ResourceTags []RepositoryCreationTemplateTag `pulumi:"resourceTags"`
	// Update timestamp of the template.
	UpdatedAt *string `pulumi:"updatedAt"`
}

func LookupRepositoryCreationTemplate added in v0.103.0 

func LookupRepositoryCreationTemplate(ctx *pulumi.Context, args *LookupRepositoryCreationTemplateArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryCreationTemplateResult, error)

AWS::ECR::RepositoryCreationTemplate is used to create repository with configuration from a pre-defined template.

type LookupRepositoryCreationTemplateResultOutput added in v0.103.0 

type LookupRepositoryCreationTemplateResultOutput struct{ *pulumi.OutputState }

func LookupRepositoryCreationTemplateOutput added in v0.103.0 

func LookupRepositoryCreationTemplateOutput(ctx *pulumi.Context, args LookupRepositoryCreationTemplateOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryCreationTemplateResultOutput

func (LookupRepositoryCreationTemplateResultOutput) AppliedFor added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) AppliedFor() RepositoryCreationTemplateAppliedForItemArrayOutput

A list of enumerable Strings representing the repository creation scenarios that the template will apply towards.

func (LookupRepositoryCreationTemplateResultOutput) CreatedAt added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) CreatedAt() pulumi.StringPtrOutput

Create timestamp of the template.

func (LookupRepositoryCreationTemplateResultOutput) Description added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) Description() pulumi.StringPtrOutput

The description of the template.

func (LookupRepositoryCreationTemplateResultOutput) ElementType added in v0.103.0 

func (LookupRepositoryCreationTemplateResultOutput) ElementType() reflect.Type

func (LookupRepositoryCreationTemplateResultOutput) EncryptionConfiguration added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) EncryptionConfiguration() RepositoryCreationTemplateEncryptionConfigurationPtrOutput

func (LookupRepositoryCreationTemplateResultOutput) ImageTagMutability added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) ImageTagMutability() RepositoryCreationTemplateImageTagMutabilityPtrOutput

The image tag mutability setting for the repository.

func (LookupRepositoryCreationTemplateResultOutput) LifecyclePolicy added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) LifecyclePolicy() pulumi.StringPtrOutput

The JSON lifecycle policy text to apply to the repository. For information about lifecycle policy syntax, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html

func (LookupRepositoryCreationTemplateResultOutput) RepositoryPolicy added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) RepositoryPolicy() pulumi.StringPtrOutput

The JSON repository policy text to apply to the repository. For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html

func (LookupRepositoryCreationTemplateResultOutput) ResourceTags added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) ResourceTags() RepositoryCreationTemplateTagArrayOutput

An array of key-value pairs to apply to this resource.

func (LookupRepositoryCreationTemplateResultOutput) ToLookupRepositoryCreationTemplateResultOutput added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) ToLookupRepositoryCreationTemplateResultOutput() LookupRepositoryCreationTemplateResultOutput

func (LookupRepositoryCreationTemplateResultOutput) ToLookupRepositoryCreationTemplateResultOutputWithContext added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) ToLookupRepositoryCreationTemplateResultOutputWithContext(ctx context.Context) LookupRepositoryCreationTemplateResultOutput

func (LookupRepositoryCreationTemplateResultOutput) UpdatedAt added in v0.103.0 

func (o LookupRepositoryCreationTemplateResultOutput) UpdatedAt() pulumi.StringPtrOutput

Update timestamp of the template.

type LookupRepositoryOutputArgs added in v0.12.0 

type LookupRepositoryOutputArgs struct {
	// 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“). If you don't specify a name, CFNlong generates a unique physical ID and uses that ID for the repository name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html).
	//  The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.
	//   If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
	RepositoryName pulumi.StringInput `pulumi:"repositoryName"`
}

func (LookupRepositoryOutputArgs) ElementType added in v0.12.0 

func (LookupRepositoryOutputArgs) ElementType() reflect.Type

type LookupRepositoryResult added in v0.12.0 

type LookupRepositoryResult struct {
	Arn *string `pulumi:"arn"`
	// The image scanning configuration for the repository. This determines whether images are scanned for known vulnerabilities after being pushed to the repository.
	ImageScanningConfiguration *RepositoryImageScanningConfiguration `pulumi:"imageScanningConfiguration"`
	// 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 *RepositoryImageTagMutability `pulumi:"imageTagMutability"`
	// Creates or updates a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).
	LifecyclePolicy *RepositoryLifecyclePolicy `pulumi:"lifecyclePolicy"`
	// 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*.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::Repository` for more information about the expected schema for this property.
	RepositoryPolicyText interface{} `pulumi:"repositoryPolicyText"`
	RepositoryUri        *string     `pulumi:"repositoryUri"`
	// An array of key-value pairs to apply to this resource.
	Tags []aws.Tag `pulumi:"tags"`
}

func LookupRepository added in v0.12.0 

func LookupRepository(ctx *pulumi.Context, args *LookupRepositoryArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryResult, error)

The “AWS::ECR::Repository“ resource specifies an Amazon Elastic Container Registry (Amazon ECR) repository, where users can push and pull Docker images, Open Container Initiative (OCI) images, and OCI compatible artifacts. For more information, see [Amazon ECR private repositories](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) in the *Amazon ECR User Guide*.

type LookupRepositoryResultOutput added in v0.12.0 

type LookupRepositoryResultOutput struct{ *pulumi.OutputState }

func LookupRepositoryOutput added in v0.12.0 

func LookupRepositoryOutput(ctx *pulumi.Context, args LookupRepositoryOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryResultOutput

func (LookupRepositoryResultOutput) Arn added in v0.12.0 

func (o LookupRepositoryResultOutput) Arn() pulumi.StringPtrOutput

func (LookupRepositoryResultOutput) ElementType added in v0.12.0 

func (LookupRepositoryResultOutput) ElementType() reflect.Type

func (LookupRepositoryResultOutput) ImageScanningConfiguration added in v0.12.0 

func (o LookupRepositoryResultOutput) ImageScanningConfiguration() RepositoryImageScanningConfigurationPtrOutput

The image scanning configuration for the repository. This determines whether images are scanned for known vulnerabilities after being pushed to the repository.

func (LookupRepositoryResultOutput) ImageTagMutability added in v0.12.0 

func (o LookupRepositoryResultOutput) ImageTagMutability() RepositoryImageTagMutabilityPtrOutput

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.

func (LookupRepositoryResultOutput) LifecyclePolicy added in v0.12.0 

func (o LookupRepositoryResultOutput) LifecyclePolicy() RepositoryLifecyclePolicyPtrOutput

Creates or updates a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).

func (LookupRepositoryResultOutput) RepositoryPolicyText added in v0.12.0 

func (o LookupRepositoryResultOutput) RepositoryPolicyText() pulumi.AnyOutput

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*.

Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::Repository` for more information about the expected schema for this property.

func (LookupRepositoryResultOutput) RepositoryUri added in v0.12.0 

func (o LookupRepositoryResultOutput) RepositoryUri() pulumi.StringPtrOutput

func (LookupRepositoryResultOutput) Tags added in v0.12.0 

func (o LookupRepositoryResultOutput) Tags() aws.TagArrayOutput

An array of key-value pairs to apply to this resource.

func (LookupRepositoryResultOutput) ToLookupRepositoryResultOutput added in v0.12.0 

func (o LookupRepositoryResultOutput) ToLookupRepositoryResultOutput() LookupRepositoryResultOutput

func (LookupRepositoryResultOutput) ToLookupRepositoryResultOutputWithContext added in v0.12.0 

func (o LookupRepositoryResultOutput) ToLookupRepositoryResultOutputWithContext(ctx context.Context) LookupRepositoryResultOutput

type PullThroughCacheRule added in v0.13.0 

type PullThroughCacheRule struct {
	pulumi.CustomResourceState

	// The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that identifies the credentials to authenticate to the upstream registry.
	CredentialArn pulumi.StringPtrOutput `pulumi:"credentialArn"`
	// The ECRRepositoryPrefix is a custom alias for upstream registry url.
	EcrRepositoryPrefix pulumi.StringPtrOutput `pulumi:"ecrRepositoryPrefix"`
	// The name of the upstream registry.
	UpstreamRegistry pulumi.StringPtrOutput `pulumi:"upstreamRegistry"`
	// The upstreamRegistryUrl is the endpoint of upstream registry url of the public repository to be cached
	UpstreamRegistryUrl pulumi.StringPtrOutput `pulumi:"upstreamRegistryUrl"`
}

The AWS::ECR::PullThroughCacheRule resource configures the upstream registry configuration details for an Amazon Elastic Container Registry (Amazon Private ECR) pull-through cache.

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.NewPullThroughCacheRule(ctx, "myECRPullThroughCacheRule", &ecr.PullThroughCacheRuleArgs{
			EcrRepositoryPrefix: pulumi.String("my-ecr"),
			UpstreamRegistryUrl: pulumi.String("public.ecr.aws"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.NewPullThroughCacheRule(ctx, "myECRPullThroughCacheRule", &ecr.PullThroughCacheRuleArgs{
			EcrRepositoryPrefix: pulumi.String("my-ecr"),
			UpstreamRegistryUrl: pulumi.String("public.ecr.aws"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetPullThroughCacheRule added in v0.13.0 

func GetPullThroughCacheRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PullThroughCacheRuleState, opts ...pulumi.ResourceOption) (*PullThroughCacheRule, error)

GetPullThroughCacheRule gets an existing PullThroughCacheRule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewPullThroughCacheRule added in v0.13.0 

func NewPullThroughCacheRule(ctx *pulumi.Context,
	name string, args *PullThroughCacheRuleArgs, opts ...pulumi.ResourceOption) (*PullThroughCacheRule, error)

NewPullThroughCacheRule registers a new resource with the given unique name, arguments, and options.

func (*PullThroughCacheRule) ElementType added in v0.13.0 

func (*PullThroughCacheRule) ElementType() reflect.Type

func (*PullThroughCacheRule) ToPullThroughCacheRuleOutput added in v0.13.0 

func (i *PullThroughCacheRule) ToPullThroughCacheRuleOutput() PullThroughCacheRuleOutput

func (*PullThroughCacheRule) ToPullThroughCacheRuleOutputWithContext added in v0.13.0 

func (i *PullThroughCacheRule) ToPullThroughCacheRuleOutputWithContext(ctx context.Context) PullThroughCacheRuleOutput

type PullThroughCacheRuleArgs added in v0.13.0 

type PullThroughCacheRuleArgs struct {
	// The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that identifies the credentials to authenticate to the upstream registry.
	CredentialArn pulumi.StringPtrInput
	// The ECRRepositoryPrefix is a custom alias for upstream registry url.
	EcrRepositoryPrefix pulumi.StringPtrInput
	// The name of the upstream registry.
	UpstreamRegistry pulumi.StringPtrInput
	// The upstreamRegistryUrl is the endpoint of upstream registry url of the public repository to be cached
	UpstreamRegistryUrl pulumi.StringPtrInput
}

The set of arguments for constructing a PullThroughCacheRule resource.

func (PullThroughCacheRuleArgs) ElementType added in v0.13.0 

func (PullThroughCacheRuleArgs) ElementType() reflect.Type

type PullThroughCacheRuleInput added in v0.13.0 

type PullThroughCacheRuleInput interface {
	pulumi.Input

	ToPullThroughCacheRuleOutput() PullThroughCacheRuleOutput
	ToPullThroughCacheRuleOutputWithContext(ctx context.Context) PullThroughCacheRuleOutput
}

type PullThroughCacheRuleOutput added in v0.13.0 

type PullThroughCacheRuleOutput struct{ *pulumi.OutputState }

func (PullThroughCacheRuleOutput) CredentialArn added in v0.85.0 

func (o PullThroughCacheRuleOutput) CredentialArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that identifies the credentials to authenticate to the upstream registry.

func (PullThroughCacheRuleOutput) EcrRepositoryPrefix added in v0.17.0 

func (o PullThroughCacheRuleOutput) EcrRepositoryPrefix() pulumi.StringPtrOutput

The ECRRepositoryPrefix is a custom alias for upstream registry url.

func (PullThroughCacheRuleOutput) ElementType added in v0.13.0 

func (PullThroughCacheRuleOutput) ElementType() reflect.Type

func (PullThroughCacheRuleOutput) ToPullThroughCacheRuleOutput added in v0.13.0 

func (o PullThroughCacheRuleOutput) ToPullThroughCacheRuleOutput() PullThroughCacheRuleOutput

func (PullThroughCacheRuleOutput) ToPullThroughCacheRuleOutputWithContext added in v0.13.0 

func (o PullThroughCacheRuleOutput) ToPullThroughCacheRuleOutputWithContext(ctx context.Context) PullThroughCacheRuleOutput

func (PullThroughCacheRuleOutput) UpstreamRegistry added in v0.85.0 

func (o PullThroughCacheRuleOutput) UpstreamRegistry() pulumi.StringPtrOutput

The name of the upstream registry.

func (PullThroughCacheRuleOutput) UpstreamRegistryUrl added in v0.17.0 

func (o PullThroughCacheRuleOutput) UpstreamRegistryUrl() pulumi.StringPtrOutput

The upstreamRegistryUrl is the endpoint of upstream registry url of the public repository to be cached

type PullThroughCacheRuleState added in v0.13.0 

type PullThroughCacheRuleState struct {
}

func (PullThroughCacheRuleState) ElementType added in v0.13.0 

func (PullThroughCacheRuleState) ElementType() reflect.Type

type RegistryPolicy 

type RegistryPolicy struct {
	pulumi.CustomResourceState

	// The JSON policy text for your registry.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::RegistryPolicy` for more information about the expected schema for this property.
	PolicyText pulumi.AnyOutput    `pulumi:"policyText"`
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
}

The “AWS::ECR::RegistryPolicy“ resource creates or updates the permissions policy for a private registry. 

A private registry policy is used to specify permissions for another AWS-account and is used when configuring cross-account replication. For more information, see [Registry permissions](https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry-permissions.html) in the *Amazon Elastic Container Registry User Guide*.

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.NewRegistryPolicy(ctx, "testRegistryPolicy", &ecr.RegistryPolicyArgs{
			PolicyText: pulumi.Any(map[string]interface{}{
				"version": "2012-10-17",
				"statement": []map[string]interface{}{
					map[string]interface{}{
						"sid":    "UpdatedRegistryPolicy",
						"effect": "Allow",
						"principal": map[string]interface{}{
							"aws": "arn:aws:iam::210987654321:root",
						},
						"action": []string{
							"ecr:CreateRepository",
							"ecr:ReplicateImage",
						},
						"resource": "arn:aws:ecr:us-west-2:123456789012:repository/*",
					},
				},
			}),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetRegistryPolicy 

func GetRegistryPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RegistryPolicyState, opts ...pulumi.ResourceOption) (*RegistryPolicy, error)

GetRegistryPolicy gets an existing RegistryPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRegistryPolicy 

func NewRegistryPolicy(ctx *pulumi.Context,
	name string, args *RegistryPolicyArgs, opts ...pulumi.ResourceOption) (*RegistryPolicy, error)

NewRegistryPolicy registers a new resource with the given unique name, arguments, and options.

func (*RegistryPolicy) ElementType 

func (*RegistryPolicy) ElementType() reflect.Type

func (*RegistryPolicy) ToRegistryPolicyOutput 

func (i *RegistryPolicy) ToRegistryPolicyOutput() RegistryPolicyOutput

func (*RegistryPolicy) ToRegistryPolicyOutputWithContext 

func (i *RegistryPolicy) ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput

type RegistryPolicyArgs 

type RegistryPolicyArgs struct {
	// The JSON policy text for your registry.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::RegistryPolicy` for more information about the expected schema for this property.
	PolicyText pulumi.Input
}

The set of arguments for constructing a RegistryPolicy resource.

func (RegistryPolicyArgs) ElementType 

func (RegistryPolicyArgs) ElementType() reflect.Type

type RegistryPolicyInput 

type RegistryPolicyInput interface {
	pulumi.Input

	ToRegistryPolicyOutput() RegistryPolicyOutput
	ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput
}

type RegistryPolicyOutput 

type RegistryPolicyOutput struct{ *pulumi.OutputState }

func (RegistryPolicyOutput) ElementType 

func (RegistryPolicyOutput) ElementType() reflect.Type

func (RegistryPolicyOutput) PolicyText added in v0.17.0 

func (o RegistryPolicyOutput) PolicyText() pulumi.AnyOutput

The JSON policy text for your registry.

Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::RegistryPolicy` for more information about the expected schema for this property.

func (RegistryPolicyOutput) RegistryId added in v0.17.0 

func (o RegistryPolicyOutput) RegistryId() pulumi.StringOutput

func (RegistryPolicyOutput) ToRegistryPolicyOutput 

func (o RegistryPolicyOutput) ToRegistryPolicyOutput() RegistryPolicyOutput

func (RegistryPolicyOutput) ToRegistryPolicyOutputWithContext 

func (o RegistryPolicyOutput) ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput

type RegistryPolicyState 

type RegistryPolicyState struct {
}

func (RegistryPolicyState) ElementType 

func (RegistryPolicyState) ElementType() reflect.Type

type ReplicationConfiguration 

type ReplicationConfiguration struct {
	pulumi.CustomResourceState

	// The RegistryId associated with the aws account.
	RegistryId               pulumi.StringOutput                `pulumi:"registryId"`
	ReplicationConfiguration ReplicationConfigurationTypeOutput `pulumi:"replicationConfiguration"`
}

The AWS::ECR::ReplicationConfiguration resource configures the replication destinations for an Amazon Elastic Container Registry (Amazon Private ECR). For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/replication.html

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.NewReplicationConfiguration(ctx, "myReplicationConfig", &ecr.ReplicationConfigurationArgs{
			ReplicationConfiguration: &ecr.ReplicationConfigurationTypeArgs{
				Rules: ecr.ReplicationConfigurationReplicationRuleArray{
					&ecr.ReplicationConfigurationReplicationRuleArgs{
						Destinations: ecr.ReplicationConfigurationReplicationDestinationArray{
							&ecr.ReplicationConfigurationReplicationDestinationArgs{
								Region:     pulumi.String("us-east-2"),
								RegistryId: pulumi.String("123456789012"),
							},
							&ecr.ReplicationConfigurationReplicationDestinationArgs{
								Region:     pulumi.String("us-west-1"),
								RegistryId: pulumi.String("123456789012"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetReplicationConfiguration 

func GetReplicationConfiguration(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ReplicationConfigurationState, opts ...pulumi.ResourceOption) (*ReplicationConfiguration, error)

GetReplicationConfiguration gets an existing ReplicationConfiguration resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewReplicationConfiguration 

func NewReplicationConfiguration(ctx *pulumi.Context,
	name string, args *ReplicationConfigurationArgs, opts ...pulumi.ResourceOption) (*ReplicationConfiguration, error)

NewReplicationConfiguration registers a new resource with the given unique name, arguments, and options.

func (*ReplicationConfiguration) ElementType 

func (*ReplicationConfiguration) ElementType() reflect.Type

func (*ReplicationConfiguration) ToReplicationConfigurationOutput 

func (i *ReplicationConfiguration) ToReplicationConfigurationOutput() ReplicationConfigurationOutput

func (*ReplicationConfiguration) ToReplicationConfigurationOutputWithContext 

func (i *ReplicationConfiguration) ToReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationOutput

type ReplicationConfigurationArgs 

type ReplicationConfigurationArgs struct {
	ReplicationConfiguration ReplicationConfigurationTypeInput
}

The set of arguments for constructing a ReplicationConfiguration resource.

func (ReplicationConfigurationArgs) ElementType 

func (ReplicationConfigurationArgs) ElementType() reflect.Type

type ReplicationConfigurationFilterType 

type ReplicationConfigurationFilterType string

Type of repository filter

func (ReplicationConfigurationFilterType) ElementType 

func (ReplicationConfigurationFilterType) ElementType() reflect.Type

func (ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypeOutput 

func (e ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypeOutput() ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypeOutputWithContext 

func (e ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypeOutputWithContext(ctx context.Context) ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypePtrOutput 

func (e ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypePtrOutput() ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypePtrOutputWithContext 

func (e ReplicationConfigurationFilterType) ToReplicationConfigurationFilterTypePtrOutputWithContext(ctx context.Context) ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterType) ToStringOutput 

func (e ReplicationConfigurationFilterType) ToStringOutput() pulumi.StringOutput

func (ReplicationConfigurationFilterType) ToStringOutputWithContext 

func (e ReplicationConfigurationFilterType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ReplicationConfigurationFilterType) ToStringPtrOutput 

func (e ReplicationConfigurationFilterType) ToStringPtrOutput() pulumi.StringPtrOutput

func (ReplicationConfigurationFilterType) ToStringPtrOutputWithContext 

func (e ReplicationConfigurationFilterType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ReplicationConfigurationFilterTypeInput 

type ReplicationConfigurationFilterTypeInput interface {
	pulumi.Input

	ToReplicationConfigurationFilterTypeOutput() ReplicationConfigurationFilterTypeOutput
	ToReplicationConfigurationFilterTypeOutputWithContext(context.Context) ReplicationConfigurationFilterTypeOutput
}

ReplicationConfigurationFilterTypeInput is an input type that accepts values of the ReplicationConfigurationFilterType enum A concrete instance of `ReplicationConfigurationFilterTypeInput` can be one of the following: 

ReplicationConfigurationFilterTypePrefixMatch

type ReplicationConfigurationFilterTypeOutput 

type ReplicationConfigurationFilterTypeOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationFilterTypeOutput) ElementType 

func (ReplicationConfigurationFilterTypeOutput) ElementType() reflect.Type

func (ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypeOutput 

func (o ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypeOutput() ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypeOutputWithContext 

func (o ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypeOutputWithContext(ctx context.Context) ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypePtrOutput 

func (o ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypePtrOutput() ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypePtrOutputWithContext 

func (o ReplicationConfigurationFilterTypeOutput) ToReplicationConfigurationFilterTypePtrOutputWithContext(ctx context.Context) ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterTypeOutput) ToStringOutput 

func (o ReplicationConfigurationFilterTypeOutput) ToStringOutput() pulumi.StringOutput

func (ReplicationConfigurationFilterTypeOutput) ToStringOutputWithContext 

func (o ReplicationConfigurationFilterTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ReplicationConfigurationFilterTypeOutput) ToStringPtrOutput 

func (o ReplicationConfigurationFilterTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ReplicationConfigurationFilterTypeOutput) ToStringPtrOutputWithContext 

func (o ReplicationConfigurationFilterTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ReplicationConfigurationFilterTypePtrInput 

type ReplicationConfigurationFilterTypePtrInput interface {
	pulumi.Input

	ToReplicationConfigurationFilterTypePtrOutput() ReplicationConfigurationFilterTypePtrOutput
	ToReplicationConfigurationFilterTypePtrOutputWithContext(context.Context) ReplicationConfigurationFilterTypePtrOutput
}

func ReplicationConfigurationFilterTypePtr 

func ReplicationConfigurationFilterTypePtr(v string) ReplicationConfigurationFilterTypePtrInput

type ReplicationConfigurationFilterTypePtrOutput 

type ReplicationConfigurationFilterTypePtrOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationFilterTypePtrOutput) Elem 

func (o ReplicationConfigurationFilterTypePtrOutput) Elem() ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationFilterTypePtrOutput) ElementType 

func (ReplicationConfigurationFilterTypePtrOutput) ElementType() reflect.Type

func (ReplicationConfigurationFilterTypePtrOutput) ToReplicationConfigurationFilterTypePtrOutput 

func (o ReplicationConfigurationFilterTypePtrOutput) ToReplicationConfigurationFilterTypePtrOutput() ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterTypePtrOutput) ToReplicationConfigurationFilterTypePtrOutputWithContext 

func (o ReplicationConfigurationFilterTypePtrOutput) ToReplicationConfigurationFilterTypePtrOutputWithContext(ctx context.Context) ReplicationConfigurationFilterTypePtrOutput

func (ReplicationConfigurationFilterTypePtrOutput) ToStringPtrOutput 

func (o ReplicationConfigurationFilterTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ReplicationConfigurationFilterTypePtrOutput) ToStringPtrOutputWithContext 

func (o ReplicationConfigurationFilterTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ReplicationConfigurationInput 

type ReplicationConfigurationInput interface {
	pulumi.Input

	ToReplicationConfigurationOutput() ReplicationConfigurationOutput
	ToReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationOutput
}

type ReplicationConfigurationOutput 

type ReplicationConfigurationOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationOutput) ElementType 

func (ReplicationConfigurationOutput) ElementType() reflect.Type

func (ReplicationConfigurationOutput) RegistryId added in v0.17.0 

func (o ReplicationConfigurationOutput) RegistryId() pulumi.StringOutput

The RegistryId associated with the aws account.

func (ReplicationConfigurationOutput) ReplicationConfiguration added in v0.17.0 

func (o ReplicationConfigurationOutput) ReplicationConfiguration() ReplicationConfigurationTypeOutput

func (ReplicationConfigurationOutput) ToReplicationConfigurationOutput 

func (o ReplicationConfigurationOutput) ToReplicationConfigurationOutput() ReplicationConfigurationOutput

func (ReplicationConfigurationOutput) ToReplicationConfigurationOutputWithContext 

func (o ReplicationConfigurationOutput) ToReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationOutput

type ReplicationConfigurationReplicationDestination 

type ReplicationConfigurationReplicationDestination struct {
	Region     string `pulumi:"region"`
	RegistryId string `pulumi:"registryId"`
}

An array of objects representing the details of a replication destination.

type ReplicationConfigurationReplicationDestinationArgs 

type ReplicationConfigurationReplicationDestinationArgs struct {
	Region     pulumi.StringInput `pulumi:"region"`
	RegistryId pulumi.StringInput `pulumi:"registryId"`
}

An array of objects representing the details of a replication destination.

func (ReplicationConfigurationReplicationDestinationArgs) ElementType 

func (ReplicationConfigurationReplicationDestinationArgs) ElementType() reflect.Type

func (ReplicationConfigurationReplicationDestinationArgs) ToReplicationConfigurationReplicationDestinationOutput 

func (i ReplicationConfigurationReplicationDestinationArgs) ToReplicationConfigurationReplicationDestinationOutput() ReplicationConfigurationReplicationDestinationOutput

func (ReplicationConfigurationReplicationDestinationArgs) ToReplicationConfigurationReplicationDestinationOutputWithContext 

func (i ReplicationConfigurationReplicationDestinationArgs) ToReplicationConfigurationReplicationDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationDestinationOutput

type ReplicationConfigurationReplicationDestinationArray 

type ReplicationConfigurationReplicationDestinationArray []ReplicationConfigurationReplicationDestinationInput

func (ReplicationConfigurationReplicationDestinationArray) ElementType 

func (ReplicationConfigurationReplicationDestinationArray) ElementType() reflect.Type

func (ReplicationConfigurationReplicationDestinationArray) ToReplicationConfigurationReplicationDestinationArrayOutput 

func (i ReplicationConfigurationReplicationDestinationArray) ToReplicationConfigurationReplicationDestinationArrayOutput() ReplicationConfigurationReplicationDestinationArrayOutput

func (ReplicationConfigurationReplicationDestinationArray) ToReplicationConfigurationReplicationDestinationArrayOutputWithContext 

func (i ReplicationConfigurationReplicationDestinationArray) ToReplicationConfigurationReplicationDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationDestinationArrayOutput

type ReplicationConfigurationReplicationDestinationArrayInput 

type ReplicationConfigurationReplicationDestinationArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationDestinationArrayOutput() ReplicationConfigurationReplicationDestinationArrayOutput
	ToReplicationConfigurationReplicationDestinationArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationDestinationArrayOutput
}

ReplicationConfigurationReplicationDestinationArrayInput is an input type that accepts ReplicationConfigurationReplicationDestinationArray and ReplicationConfigurationReplicationDestinationArrayOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationDestinationArrayInput` via: 

ReplicationConfigurationReplicationDestinationArray{ ReplicationConfigurationReplicationDestinationArgs{...} }

type ReplicationConfigurationReplicationDestinationArrayOutput 

type ReplicationConfigurationReplicationDestinationArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationDestinationArrayOutput) ElementType 

func (ReplicationConfigurationReplicationDestinationArrayOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationDestinationArrayOutput) Index 

func (o ReplicationConfigurationReplicationDestinationArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationDestinationOutput

func (ReplicationConfigurationReplicationDestinationArrayOutput) ToReplicationConfigurationReplicationDestinationArrayOutput 

func (o ReplicationConfigurationReplicationDestinationArrayOutput) ToReplicationConfigurationReplicationDestinationArrayOutput() ReplicationConfigurationReplicationDestinationArrayOutput

func (ReplicationConfigurationReplicationDestinationArrayOutput) ToReplicationConfigurationReplicationDestinationArrayOutputWithContext 

func (o ReplicationConfigurationReplicationDestinationArrayOutput) ToReplicationConfigurationReplicationDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationDestinationArrayOutput

type ReplicationConfigurationReplicationDestinationInput 

type ReplicationConfigurationReplicationDestinationInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationDestinationOutput() ReplicationConfigurationReplicationDestinationOutput
	ToReplicationConfigurationReplicationDestinationOutputWithContext(context.Context) ReplicationConfigurationReplicationDestinationOutput
}

ReplicationConfigurationReplicationDestinationInput is an input type that accepts ReplicationConfigurationReplicationDestinationArgs and ReplicationConfigurationReplicationDestinationOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationDestinationInput` via: 

ReplicationConfigurationReplicationDestinationArgs{...}

type ReplicationConfigurationReplicationDestinationOutput 

type ReplicationConfigurationReplicationDestinationOutput struct{ *pulumi.OutputState }

An array of objects representing the details of a replication destination.

func (ReplicationConfigurationReplicationDestinationOutput) ElementType 

func (ReplicationConfigurationReplicationDestinationOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationDestinationOutput) Region 

func (o ReplicationConfigurationReplicationDestinationOutput) Region() pulumi.StringOutput

func (ReplicationConfigurationReplicationDestinationOutput) RegistryId 

func (o ReplicationConfigurationReplicationDestinationOutput) RegistryId() pulumi.StringOutput

func (ReplicationConfigurationReplicationDestinationOutput) ToReplicationConfigurationReplicationDestinationOutput 

func (o ReplicationConfigurationReplicationDestinationOutput) ToReplicationConfigurationReplicationDestinationOutput() ReplicationConfigurationReplicationDestinationOutput

func (ReplicationConfigurationReplicationDestinationOutput) ToReplicationConfigurationReplicationDestinationOutputWithContext 

func (o ReplicationConfigurationReplicationDestinationOutput) ToReplicationConfigurationReplicationDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationDestinationOutput

type ReplicationConfigurationReplicationRule 

type ReplicationConfigurationReplicationRule struct {
	// An array of objects representing the details of a replication destination.
	Destinations []ReplicationConfigurationReplicationDestination `pulumi:"destinations"`
	// An array of objects representing the details of a repository filter.
	RepositoryFilters []ReplicationConfigurationRepositoryFilter `pulumi:"repositoryFilters"`
}

An array of objects representing the details of a replication destination.

type ReplicationConfigurationReplicationRuleArgs 

type ReplicationConfigurationReplicationRuleArgs struct {
	// An array of objects representing the details of a replication destination.
	Destinations ReplicationConfigurationReplicationDestinationArrayInput `pulumi:"destinations"`
	// An array of objects representing the details of a repository filter.
	RepositoryFilters ReplicationConfigurationRepositoryFilterArrayInput `pulumi:"repositoryFilters"`
}

An array of objects representing the details of a replication destination.

func (ReplicationConfigurationReplicationRuleArgs) ElementType 

func (ReplicationConfigurationReplicationRuleArgs) ElementType() reflect.Type

func (ReplicationConfigurationReplicationRuleArgs) ToReplicationConfigurationReplicationRuleOutput 

func (i ReplicationConfigurationReplicationRuleArgs) ToReplicationConfigurationReplicationRuleOutput() ReplicationConfigurationReplicationRuleOutput

func (ReplicationConfigurationReplicationRuleArgs) ToReplicationConfigurationReplicationRuleOutputWithContext 

func (i ReplicationConfigurationReplicationRuleArgs) ToReplicationConfigurationReplicationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationRuleOutput

type ReplicationConfigurationReplicationRuleArray 

type ReplicationConfigurationReplicationRuleArray []ReplicationConfigurationReplicationRuleInput

func (ReplicationConfigurationReplicationRuleArray) ElementType 

func (ReplicationConfigurationReplicationRuleArray) ElementType() reflect.Type

func (ReplicationConfigurationReplicationRuleArray) ToReplicationConfigurationReplicationRuleArrayOutput 

func (i ReplicationConfigurationReplicationRuleArray) ToReplicationConfigurationReplicationRuleArrayOutput() ReplicationConfigurationReplicationRuleArrayOutput

func (ReplicationConfigurationReplicationRuleArray) ToReplicationConfigurationReplicationRuleArrayOutputWithContext 

func (i ReplicationConfigurationReplicationRuleArray) ToReplicationConfigurationReplicationRuleArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationRuleArrayOutput

type ReplicationConfigurationReplicationRuleArrayInput 

type ReplicationConfigurationReplicationRuleArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationRuleArrayOutput() ReplicationConfigurationReplicationRuleArrayOutput
	ToReplicationConfigurationReplicationRuleArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationRuleArrayOutput
}

ReplicationConfigurationReplicationRuleArrayInput is an input type that accepts ReplicationConfigurationReplicationRuleArray and ReplicationConfigurationReplicationRuleArrayOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationRuleArrayInput` via: 

ReplicationConfigurationReplicationRuleArray{ ReplicationConfigurationReplicationRuleArgs{...} }

type ReplicationConfigurationReplicationRuleArrayOutput 

type ReplicationConfigurationReplicationRuleArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationRuleArrayOutput) ElementType 

func (ReplicationConfigurationReplicationRuleArrayOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationRuleArrayOutput) Index 

func (o ReplicationConfigurationReplicationRuleArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationRuleOutput

func (ReplicationConfigurationReplicationRuleArrayOutput) ToReplicationConfigurationReplicationRuleArrayOutput 

func (o ReplicationConfigurationReplicationRuleArrayOutput) ToReplicationConfigurationReplicationRuleArrayOutput() ReplicationConfigurationReplicationRuleArrayOutput

func (ReplicationConfigurationReplicationRuleArrayOutput) ToReplicationConfigurationReplicationRuleArrayOutputWithContext 

func (o ReplicationConfigurationReplicationRuleArrayOutput) ToReplicationConfigurationReplicationRuleArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationRuleArrayOutput

type ReplicationConfigurationReplicationRuleInput 

type ReplicationConfigurationReplicationRuleInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationRuleOutput() ReplicationConfigurationReplicationRuleOutput
	ToReplicationConfigurationReplicationRuleOutputWithContext(context.Context) ReplicationConfigurationReplicationRuleOutput
}

ReplicationConfigurationReplicationRuleInput is an input type that accepts ReplicationConfigurationReplicationRuleArgs and ReplicationConfigurationReplicationRuleOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationRuleInput` via: 

ReplicationConfigurationReplicationRuleArgs{...}

type ReplicationConfigurationReplicationRuleOutput 

type ReplicationConfigurationReplicationRuleOutput struct{ *pulumi.OutputState }

An array of objects representing the details of a replication destination.

func (ReplicationConfigurationReplicationRuleOutput) Destinations 

func (o ReplicationConfigurationReplicationRuleOutput) Destinations() ReplicationConfigurationReplicationDestinationArrayOutput

An array of objects representing the details of a replication destination.

func (ReplicationConfigurationReplicationRuleOutput) ElementType 

func (ReplicationConfigurationReplicationRuleOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationRuleOutput) RepositoryFilters 

func (o ReplicationConfigurationReplicationRuleOutput) RepositoryFilters() ReplicationConfigurationRepositoryFilterArrayOutput

An array of objects representing the details of a repository filter.

func (ReplicationConfigurationReplicationRuleOutput) ToReplicationConfigurationReplicationRuleOutput 

func (o ReplicationConfigurationReplicationRuleOutput) ToReplicationConfigurationReplicationRuleOutput() ReplicationConfigurationReplicationRuleOutput

func (ReplicationConfigurationReplicationRuleOutput) ToReplicationConfigurationReplicationRuleOutputWithContext 

func (o ReplicationConfigurationReplicationRuleOutput) ToReplicationConfigurationReplicationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationRuleOutput

type ReplicationConfigurationRepositoryFilter 

type ReplicationConfigurationRepositoryFilter struct {
	Filter     string                             `pulumi:"filter"`
	FilterType ReplicationConfigurationFilterType `pulumi:"filterType"`
}

An array of objects representing the details of a repository filter.

type ReplicationConfigurationRepositoryFilterArgs 

type ReplicationConfigurationRepositoryFilterArgs struct {
	Filter     pulumi.StringInput                      `pulumi:"filter"`
	FilterType ReplicationConfigurationFilterTypeInput `pulumi:"filterType"`
}

An array of objects representing the details of a repository filter.

func (ReplicationConfigurationRepositoryFilterArgs) ElementType 

func (ReplicationConfigurationRepositoryFilterArgs) ElementType() reflect.Type

func (ReplicationConfigurationRepositoryFilterArgs) ToReplicationConfigurationRepositoryFilterOutput 

func (i ReplicationConfigurationRepositoryFilterArgs) ToReplicationConfigurationRepositoryFilterOutput() ReplicationConfigurationRepositoryFilterOutput

func (ReplicationConfigurationRepositoryFilterArgs) ToReplicationConfigurationRepositoryFilterOutputWithContext 

func (i ReplicationConfigurationRepositoryFilterArgs) ToReplicationConfigurationRepositoryFilterOutputWithContext(ctx context.Context) ReplicationConfigurationRepositoryFilterOutput

type ReplicationConfigurationRepositoryFilterArray 

type ReplicationConfigurationRepositoryFilterArray []ReplicationConfigurationRepositoryFilterInput

func (ReplicationConfigurationRepositoryFilterArray) ElementType 

func (ReplicationConfigurationRepositoryFilterArray) ElementType() reflect.Type

func (ReplicationConfigurationRepositoryFilterArray) ToReplicationConfigurationRepositoryFilterArrayOutput 

func (i ReplicationConfigurationRepositoryFilterArray) ToReplicationConfigurationRepositoryFilterArrayOutput() ReplicationConfigurationRepositoryFilterArrayOutput

func (ReplicationConfigurationRepositoryFilterArray) ToReplicationConfigurationRepositoryFilterArrayOutputWithContext 

func (i ReplicationConfigurationRepositoryFilterArray) ToReplicationConfigurationRepositoryFilterArrayOutputWithContext(ctx context.Context) ReplicationConfigurationRepositoryFilterArrayOutput

type ReplicationConfigurationRepositoryFilterArrayInput 

type ReplicationConfigurationRepositoryFilterArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationRepositoryFilterArrayOutput() ReplicationConfigurationRepositoryFilterArrayOutput
	ToReplicationConfigurationRepositoryFilterArrayOutputWithContext(context.Context) ReplicationConfigurationRepositoryFilterArrayOutput
}

ReplicationConfigurationRepositoryFilterArrayInput is an input type that accepts ReplicationConfigurationRepositoryFilterArray and ReplicationConfigurationRepositoryFilterArrayOutput values. You can construct a concrete instance of `ReplicationConfigurationRepositoryFilterArrayInput` via: 

ReplicationConfigurationRepositoryFilterArray{ ReplicationConfigurationRepositoryFilterArgs{...} }

type ReplicationConfigurationRepositoryFilterArrayOutput 

type ReplicationConfigurationRepositoryFilterArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationRepositoryFilterArrayOutput) ElementType 

func (ReplicationConfigurationRepositoryFilterArrayOutput) ElementType() reflect.Type

func (ReplicationConfigurationRepositoryFilterArrayOutput) Index 

func (o ReplicationConfigurationRepositoryFilterArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationRepositoryFilterOutput

func (ReplicationConfigurationRepositoryFilterArrayOutput) ToReplicationConfigurationRepositoryFilterArrayOutput 

func (o ReplicationConfigurationRepositoryFilterArrayOutput) ToReplicationConfigurationRepositoryFilterArrayOutput() ReplicationConfigurationRepositoryFilterArrayOutput

func (ReplicationConfigurationRepositoryFilterArrayOutput) ToReplicationConfigurationRepositoryFilterArrayOutputWithContext 

func (o ReplicationConfigurationRepositoryFilterArrayOutput) ToReplicationConfigurationRepositoryFilterArrayOutputWithContext(ctx context.Context) ReplicationConfigurationRepositoryFilterArrayOutput

type ReplicationConfigurationRepositoryFilterInput 

type ReplicationConfigurationRepositoryFilterInput interface {
	pulumi.Input

	ToReplicationConfigurationRepositoryFilterOutput() ReplicationConfigurationRepositoryFilterOutput
	ToReplicationConfigurationRepositoryFilterOutputWithContext(context.Context) ReplicationConfigurationRepositoryFilterOutput
}

ReplicationConfigurationRepositoryFilterInput is an input type that accepts ReplicationConfigurationRepositoryFilterArgs and ReplicationConfigurationRepositoryFilterOutput values. You can construct a concrete instance of `ReplicationConfigurationRepositoryFilterInput` via: 

ReplicationConfigurationRepositoryFilterArgs{...}

type ReplicationConfigurationRepositoryFilterOutput 

type ReplicationConfigurationRepositoryFilterOutput struct{ *pulumi.OutputState }

An array of objects representing the details of a repository filter.

func (ReplicationConfigurationRepositoryFilterOutput) ElementType 

func (ReplicationConfigurationRepositoryFilterOutput) ElementType() reflect.Type

func (ReplicationConfigurationRepositoryFilterOutput) Filter 

func (o ReplicationConfigurationRepositoryFilterOutput) Filter() pulumi.StringOutput

func (ReplicationConfigurationRepositoryFilterOutput) FilterType 

func (o ReplicationConfigurationRepositoryFilterOutput) FilterType() ReplicationConfigurationFilterTypeOutput

func (ReplicationConfigurationRepositoryFilterOutput) ToReplicationConfigurationRepositoryFilterOutput 

func (o ReplicationConfigurationRepositoryFilterOutput) ToReplicationConfigurationRepositoryFilterOutput() ReplicationConfigurationRepositoryFilterOutput

func (ReplicationConfigurationRepositoryFilterOutput) ToReplicationConfigurationRepositoryFilterOutputWithContext 

func (o ReplicationConfigurationRepositoryFilterOutput) ToReplicationConfigurationRepositoryFilterOutputWithContext(ctx context.Context) ReplicationConfigurationRepositoryFilterOutput

type ReplicationConfigurationState 

type ReplicationConfigurationState struct {
}

func (ReplicationConfigurationState) ElementType 

func (ReplicationConfigurationState) ElementType() reflect.Type

type ReplicationConfigurationType added in v0.2.0 

type ReplicationConfigurationType struct {
	// An array of objects representing the replication rules for a replication configuration. A replication configuration may contain a maximum of 10 rules.
	Rules []ReplicationConfigurationReplicationRule `pulumi:"rules"`
}

An object representing the replication configuration for a registry.

type ReplicationConfigurationTypeArgs added in v0.2.0 

type ReplicationConfigurationTypeArgs struct {
	// An array of objects representing the replication rules for a replication configuration. A replication configuration may contain a maximum of 10 rules.
	Rules ReplicationConfigurationReplicationRuleArrayInput `pulumi:"rules"`
}

An object representing the replication configuration for a registry.

func (ReplicationConfigurationTypeArgs) ElementType added in v0.2.0 

func (ReplicationConfigurationTypeArgs) ElementType() reflect.Type

func (ReplicationConfigurationTypeArgs) ToReplicationConfigurationTypeOutput added in v0.2.0 

func (i ReplicationConfigurationTypeArgs) ToReplicationConfigurationTypeOutput() ReplicationConfigurationTypeOutput

func (ReplicationConfigurationTypeArgs) ToReplicationConfigurationTypeOutputWithContext added in v0.2.0 

func (i ReplicationConfigurationTypeArgs) ToReplicationConfigurationTypeOutputWithContext(ctx context.Context) ReplicationConfigurationTypeOutput

type ReplicationConfigurationTypeInput added in v0.2.0 

type ReplicationConfigurationTypeInput interface {
	pulumi.Input

	ToReplicationConfigurationTypeOutput() ReplicationConfigurationTypeOutput
	ToReplicationConfigurationTypeOutputWithContext(context.Context) ReplicationConfigurationTypeOutput
}

ReplicationConfigurationTypeInput is an input type that accepts ReplicationConfigurationTypeArgs and ReplicationConfigurationTypeOutput values. You can construct a concrete instance of `ReplicationConfigurationTypeInput` via: 

ReplicationConfigurationTypeArgs{...}

type ReplicationConfigurationTypeOutput added in v0.2.0 

type ReplicationConfigurationTypeOutput struct{ *pulumi.OutputState }

An object representing the replication configuration for a registry.

func (ReplicationConfigurationTypeOutput) ElementType added in v0.2.0 

func (ReplicationConfigurationTypeOutput) ElementType() reflect.Type

func (ReplicationConfigurationTypeOutput) Rules added in v0.2.0 

func (o ReplicationConfigurationTypeOutput) Rules() ReplicationConfigurationReplicationRuleArrayOutput

An array of objects representing the replication rules for a replication configuration. A replication configuration may contain a maximum of 10 rules.

func (ReplicationConfigurationTypeOutput) ToReplicationConfigurationTypeOutput added in v0.2.0 

func (o ReplicationConfigurationTypeOutput) ToReplicationConfigurationTypeOutput() ReplicationConfigurationTypeOutput

func (ReplicationConfigurationTypeOutput) ToReplicationConfigurationTypeOutputWithContext added in v0.2.0 

func (o ReplicationConfigurationTypeOutput) ToReplicationConfigurationTypeOutputWithContext(ctx context.Context) ReplicationConfigurationTypeOutput

type ReplicationConfigurationTypePtrOutput added in v0.2.0 

type ReplicationConfigurationTypePtrOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationTypePtrOutput) Elem added in v0.2.0 

func (o ReplicationConfigurationTypePtrOutput) Elem() ReplicationConfigurationTypeOutput

func (ReplicationConfigurationTypePtrOutput) ElementType added in v0.2.0 

func (ReplicationConfigurationTypePtrOutput) ElementType() reflect.Type

func (ReplicationConfigurationTypePtrOutput) Rules added in v0.2.0 

func (o ReplicationConfigurationTypePtrOutput) Rules() ReplicationConfigurationReplicationRuleArrayOutput

An array of objects representing the replication rules for a replication configuration. A replication configuration may contain a maximum of 10 rules.

func (ReplicationConfigurationTypePtrOutput) ToReplicationConfigurationTypePtrOutput added in v0.2.0 

func (o ReplicationConfigurationTypePtrOutput) ToReplicationConfigurationTypePtrOutput() ReplicationConfigurationTypePtrOutput

func (ReplicationConfigurationTypePtrOutput) ToReplicationConfigurationTypePtrOutputWithContext added in v0.2.0 

func (o ReplicationConfigurationTypePtrOutput) ToReplicationConfigurationTypePtrOutputWithContext(ctx context.Context) ReplicationConfigurationTypePtrOutput

type Repository 

type Repository struct {
	pulumi.CustomResourceState

	Arn pulumi.StringOutput `pulumi:"arn"`
	// If true, deleting the repository force deletes the contents of the repository. If false, the repository must be empty before attempting to delete it.
	EmptyOnDelete pulumi.BoolPtrOutput `pulumi:"emptyOnDelete"`
	// The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest.
	EncryptionConfiguration RepositoryEncryptionConfigurationPtrOutput `pulumi:"encryptionConfiguration"`
	// The image scanning configuration for the repository. This determines whether images are scanned for known vulnerabilities after being pushed to the repository.
	ImageScanningConfiguration RepositoryImageScanningConfigurationPtrOutput `pulumi:"imageScanningConfiguration"`
	// 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 RepositoryImageTagMutabilityPtrOutput `pulumi:"imageTagMutability"`
	// Creates or updates a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).
	LifecyclePolicy RepositoryLifecyclePolicyPtrOutput `pulumi:"lifecyclePolicy"`
	// 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“). If you don't specify a name, CFNlong generates a unique physical ID and uses that ID for the repository name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html).
	//  The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.
	//   If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
	RepositoryName pulumi.StringPtrOutput `pulumi:"repositoryName"`
	// 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*.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::Repository` for more information about the expected schema for this property.
	RepositoryPolicyText pulumi.AnyOutput    `pulumi:"repositoryPolicyText"`
	RepositoryUri        pulumi.StringOutput `pulumi:"repositoryUri"`
	// An array of key-value pairs to apply to this resource.
	Tags aws.TagArrayOutput `pulumi:"tags"`
}

The “AWS::ECR::Repository“ resource specifies an Amazon Elastic Container Registry (Amazon ECR) repository, where users can push and pull Docker images, Open Container Initiative (OCI) images, and OCI compatible artifacts. For more information, see [Amazon ECR private repositories](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) in the *Amazon ECR User Guide*.

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		lifecyclePolicyText := cfg.Require("lifecyclePolicyText")
		repositoryName := cfg.Require("repositoryName")
		registryId := cfg.Require("registryId")
		myRepository, err := ecr.NewRepository(ctx, "myRepository", &ecr.RepositoryArgs{
			LifecyclePolicy: &ecr.RepositoryLifecyclePolicyArgs{
				LifecyclePolicyText: pulumi.String(lifecyclePolicyText),
				RegistryId:          pulumi.String(registryId),
			},
			RepositoryName: pulumi.String(repositoryName),
		})
		if err != nil {
			return err
		}
		ctx.Export("arn", myRepository.Arn)
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecr"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		lifecyclePolicyText := cfg.Require("lifecyclePolicyText")
		repositoryName := cfg.Require("repositoryName")
		registryId := cfg.Require("registryId")
		myRepository, err := ecr.NewRepository(ctx, "myRepository", &ecr.RepositoryArgs{
			LifecyclePolicy: &ecr.RepositoryLifecyclePolicyArgs{
				LifecyclePolicyText: pulumi.String(lifecyclePolicyText),
				RegistryId:          pulumi.String(registryId),
			},
			RepositoryName: pulumi.String(repositoryName),
		})
		if err != nil {
			return err
		}
		ctx.Export("arn", myRepository.Arn)
		return nil
	})
}

```

func GetRepository 

func GetRepository(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryState, opts ...pulumi.ResourceOption) (*Repository, error)

GetRepository gets an existing Repository resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRepository 

func NewRepository(ctx *pulumi.Context,
	name string, args *RepositoryArgs, opts ...pulumi.ResourceOption) (*Repository, error)

NewRepository registers a new resource with the given unique name, arguments, and options.

func (*Repository) ElementType 

func (*Repository) ElementType() reflect.Type

func (*Repository) ToRepositoryOutput 

func (i *Repository) ToRepositoryOutput() RepositoryOutput

func (*Repository) ToRepositoryOutputWithContext 

func (i *Repository) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

type RepositoryArgs 

type RepositoryArgs struct {
	// If true, deleting the repository force deletes the contents of the repository. If false, the repository must be empty before attempting to delete it.
	EmptyOnDelete pulumi.BoolPtrInput
	// The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest.
	EncryptionConfiguration RepositoryEncryptionConfigurationPtrInput
	// The image scanning configuration for the repository. This determines whether images are scanned for known vulnerabilities after being pushed to the repository.
	ImageScanningConfiguration RepositoryImageScanningConfigurationPtrInput
	// 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 RepositoryImageTagMutabilityPtrInput
	// Creates or updates a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).
	LifecyclePolicy RepositoryLifecyclePolicyPtrInput
	// 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“). If you don't specify a name, CFNlong generates a unique physical ID and uses that ID for the repository name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html).
	//  The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.
	//   If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
	RepositoryName pulumi.StringPtrInput
	// 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*.
	//
	// Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::Repository` for more information about the expected schema for this property.
	RepositoryPolicyText pulumi.Input
	// An array of key-value pairs to apply to this resource.
	Tags aws.TagArrayInput
}

The set of arguments for constructing a Repository resource.

func (RepositoryArgs) ElementType 

func (RepositoryArgs) ElementType() reflect.Type

type RepositoryCreationTemplate added in v0.103.0 

type RepositoryCreationTemplate struct {
	pulumi.CustomResourceState

	// A list of enumerable Strings representing the repository creation scenarios that the template will apply towards.
	AppliedFor RepositoryCreationTemplateAppliedForItemArrayOutput `pulumi:"appliedFor"`
	// Create timestamp of the template.
	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
	// The description of the template.
	Description             pulumi.StringPtrOutput                                     `pulumi:"description"`
	EncryptionConfiguration RepositoryCreationTemplateEncryptionConfigurationPtrOutput `pulumi:"encryptionConfiguration"`
	// The image tag mutability setting for the repository.
	ImageTagMutability RepositoryCreationTemplateImageTagMutabilityPtrOutput `pulumi:"imageTagMutability"`
	// The JSON lifecycle policy text to apply to the repository. For information about lifecycle policy syntax, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html
	LifecyclePolicy pulumi.StringPtrOutput `pulumi:"lifecyclePolicy"`
	// The prefix use to match the repository name and apply the template.
	Prefix pulumi.StringOutput `pulumi:"prefix"`
	// The JSON repository policy text to apply to the repository. For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html
	RepositoryPolicy pulumi.StringPtrOutput `pulumi:"repositoryPolicy"`
	// An array of key-value pairs to apply to this resource.
	ResourceTags RepositoryCreationTemplateTagArrayOutput `pulumi:"resourceTags"`
	// Update timestamp of the template.
	UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"`
}

AWS::ECR::RepositoryCreationTemplate is used to create repository with configuration from a pre-defined template.

func GetRepositoryCreationTemplate added in v0.103.0 

func GetRepositoryCreationTemplate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryCreationTemplateState, opts ...pulumi.ResourceOption) (*RepositoryCreationTemplate, error)

GetRepositoryCreationTemplate gets an existing RepositoryCreationTemplate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRepositoryCreationTemplate added in v0.103.0 

func NewRepositoryCreationTemplate(ctx *pulumi.Context,
	name string, args *RepositoryCreationTemplateArgs, opts ...pulumi.ResourceOption) (*RepositoryCreationTemplate, error)

NewRepositoryCreationTemplate registers a new resource with the given unique name, arguments, and options.

func (*RepositoryCreationTemplate) ElementType added in v0.103.0 

func (*RepositoryCreationTemplate) ElementType() reflect.Type

func (*RepositoryCreationTemplate) ToRepositoryCreationTemplateOutput added in v0.103.0 

func (i *RepositoryCreationTemplate) ToRepositoryCreationTemplateOutput() RepositoryCreationTemplateOutput

func (*RepositoryCreationTemplate) ToRepositoryCreationTemplateOutputWithContext added in v0.103.0 

func (i *RepositoryCreationTemplate) ToRepositoryCreationTemplateOutputWithContext(ctx context.Context) RepositoryCreationTemplateOutput

type RepositoryCreationTemplateAppliedForItem added in v0.103.0 

type RepositoryCreationTemplateAppliedForItem string

Enumerable Strings representing the repository creation scenarios that the template will apply towards.

func (RepositoryCreationTemplateAppliedForItem) ElementType added in v0.103.0 

func (RepositoryCreationTemplateAppliedForItem) ElementType() reflect.Type

func (RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemOutput added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemOutput() RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemPtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemPtrOutput() RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItem) ToStringOutput added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateAppliedForItem) ToStringOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateAppliedForItem) ToStringPtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateAppliedForItem) ToStringPtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateAppliedForItem) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateAppliedForItemArray added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemArray []RepositoryCreationTemplateAppliedForItem

func (RepositoryCreationTemplateAppliedForItemArray) ElementType added in v0.103.0 

func (RepositoryCreationTemplateAppliedForItemArray) ElementType() reflect.Type

func (RepositoryCreationTemplateAppliedForItemArray) ToRepositoryCreationTemplateAppliedForItemArrayOutput added in v0.103.0 

func (i RepositoryCreationTemplateAppliedForItemArray) ToRepositoryCreationTemplateAppliedForItemArrayOutput() RepositoryCreationTemplateAppliedForItemArrayOutput

func (RepositoryCreationTemplateAppliedForItemArray) ToRepositoryCreationTemplateAppliedForItemArrayOutputWithContext added in v0.103.0 

func (i RepositoryCreationTemplateAppliedForItemArray) ToRepositoryCreationTemplateAppliedForItemArrayOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemArrayOutput

type RepositoryCreationTemplateAppliedForItemArrayInput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemArrayInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateAppliedForItemArrayOutput() RepositoryCreationTemplateAppliedForItemArrayOutput
	ToRepositoryCreationTemplateAppliedForItemArrayOutputWithContext(context.Context) RepositoryCreationTemplateAppliedForItemArrayOutput
}

RepositoryCreationTemplateAppliedForItemArrayInput is an input type that accepts RepositoryCreationTemplateAppliedForItemArray and RepositoryCreationTemplateAppliedForItemArrayOutput values. You can construct a concrete instance of `RepositoryCreationTemplateAppliedForItemArrayInput` via: 

RepositoryCreationTemplateAppliedForItemArray{ RepositoryCreationTemplateAppliedForItemArgs{...} }

type RepositoryCreationTemplateAppliedForItemArrayOutput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemArrayOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateAppliedForItemArrayOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateAppliedForItemArrayOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateAppliedForItemArrayOutput) Index added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemArrayOutput) Index(i pulumi.IntInput) RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItemArrayOutput) ToRepositoryCreationTemplateAppliedForItemArrayOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemArrayOutput) ToRepositoryCreationTemplateAppliedForItemArrayOutput() RepositoryCreationTemplateAppliedForItemArrayOutput

func (RepositoryCreationTemplateAppliedForItemArrayOutput) ToRepositoryCreationTemplateAppliedForItemArrayOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemArrayOutput) ToRepositoryCreationTemplateAppliedForItemArrayOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemArrayOutput

type RepositoryCreationTemplateAppliedForItemInput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateAppliedForItemOutput() RepositoryCreationTemplateAppliedForItemOutput
	ToRepositoryCreationTemplateAppliedForItemOutputWithContext(context.Context) RepositoryCreationTemplateAppliedForItemOutput
}

RepositoryCreationTemplateAppliedForItemInput is an input type that accepts values of the RepositoryCreationTemplateAppliedForItem enum A concrete instance of `RepositoryCreationTemplateAppliedForItemInput` can be one of the following: 

RepositoryCreationTemplateAppliedForItemReplication
RepositoryCreationTemplateAppliedForItemPullThroughCache

type RepositoryCreationTemplateAppliedForItemOutput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateAppliedForItemOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateAppliedForItemOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemOutput() RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutput() RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToStringOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToStringOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateAppliedForItemOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateAppliedForItemPtrInput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemPtrInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateAppliedForItemPtrOutput() RepositoryCreationTemplateAppliedForItemPtrOutput
	ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext(context.Context) RepositoryCreationTemplateAppliedForItemPtrOutput
}

func RepositoryCreationTemplateAppliedForItemPtr added in v0.103.0 

func RepositoryCreationTemplateAppliedForItemPtr(v string) RepositoryCreationTemplateAppliedForItemPtrInput

type RepositoryCreationTemplateAppliedForItemPtrOutput added in v0.103.0 

type RepositoryCreationTemplateAppliedForItemPtrOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateAppliedForItemPtrOutput) Elem added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemPtrOutput) Elem() RepositoryCreationTemplateAppliedForItemOutput

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemPtrOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutput() RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemPtrOutput) ToRepositoryCreationTemplateAppliedForItemPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateAppliedForItemPtrOutput

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateAppliedForItemPtrOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateAppliedForItemPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateArgs added in v0.103.0 

type RepositoryCreationTemplateArgs struct {
	// A list of enumerable Strings representing the repository creation scenarios that the template will apply towards.
	AppliedFor RepositoryCreationTemplateAppliedForItemArrayInput
	// The description of the template.
	Description             pulumi.StringPtrInput
	EncryptionConfiguration RepositoryCreationTemplateEncryptionConfigurationPtrInput
	// The image tag mutability setting for the repository.
	ImageTagMutability RepositoryCreationTemplateImageTagMutabilityPtrInput
	// The JSON lifecycle policy text to apply to the repository. For information about lifecycle policy syntax, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html
	LifecyclePolicy pulumi.StringPtrInput
	// The prefix use to match the repository name and apply the template.
	Prefix pulumi.StringInput
	// The JSON repository policy text to apply to the repository. For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html
	RepositoryPolicy pulumi.StringPtrInput
	// An array of key-value pairs to apply to this resource.
	ResourceTags RepositoryCreationTemplateTagArrayInput
}

The set of arguments for constructing a RepositoryCreationTemplate resource.

func (RepositoryCreationTemplateArgs) ElementType added in v0.103.0 

func (RepositoryCreationTemplateArgs) ElementType() reflect.Type

type RepositoryCreationTemplateEncryptionConfiguration added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfiguration struct {
	EncryptionType RepositoryCreationTemplateEncryptionType `pulumi:"encryptionType"`
	KmsKey         *string                                  `pulumi:"kmsKey"`
}

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 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 AES-256 encryption algorithm. This does not require any action on your part.

For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html

type RepositoryCreationTemplateEncryptionConfigurationArgs added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfigurationArgs struct {
	EncryptionType RepositoryCreationTemplateEncryptionTypeInput `pulumi:"encryptionType"`
	KmsKey         pulumi.StringPtrInput                         `pulumi:"kmsKey"`
}

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 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 AES-256 encryption algorithm. This does not require any action on your part.

For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationOutput added in v0.103.0 

func (i RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationOutput() RepositoryCreationTemplateEncryptionConfigurationOutput

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationOutputWithContext added in v0.103.0 

func (i RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionConfigurationOutput

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput added in v0.103.0 

func (i RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput() RepositoryCreationTemplateEncryptionConfigurationPtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext added in v0.103.0 

func (i RepositoryCreationTemplateEncryptionConfigurationArgs) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionConfigurationPtrOutput

type RepositoryCreationTemplateEncryptionConfigurationInput added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfigurationInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateEncryptionConfigurationOutput() RepositoryCreationTemplateEncryptionConfigurationOutput
	ToRepositoryCreationTemplateEncryptionConfigurationOutputWithContext(context.Context) RepositoryCreationTemplateEncryptionConfigurationOutput
}

RepositoryCreationTemplateEncryptionConfigurationInput is an input type that accepts RepositoryCreationTemplateEncryptionConfigurationArgs and RepositoryCreationTemplateEncryptionConfigurationOutput values. You can construct a concrete instance of `RepositoryCreationTemplateEncryptionConfigurationInput` via: 

RepositoryCreationTemplateEncryptionConfigurationArgs{...}

type RepositoryCreationTemplateEncryptionConfigurationOutput added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfigurationOutput struct{ *pulumi.OutputState }

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 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 AES-256 encryption algorithm. This does not require any action on your part.

For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionConfigurationOutput) EncryptionType added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) EncryptionType() RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionConfigurationOutput) KmsKey added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) KmsKey() pulumi.StringPtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationOutput() RepositoryCreationTemplateEncryptionConfigurationOutput

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionConfigurationOutput

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput() RepositoryCreationTemplateEncryptionConfigurationPtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionConfigurationPtrOutput

type RepositoryCreationTemplateEncryptionConfigurationPtrInput added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfigurationPtrInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput() RepositoryCreationTemplateEncryptionConfigurationPtrOutput
	ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext(context.Context) RepositoryCreationTemplateEncryptionConfigurationPtrOutput
}

RepositoryCreationTemplateEncryptionConfigurationPtrInput is an input type that accepts RepositoryCreationTemplateEncryptionConfigurationArgs, RepositoryCreationTemplateEncryptionConfigurationPtr and RepositoryCreationTemplateEncryptionConfigurationPtrOutput values. You can construct a concrete instance of `RepositoryCreationTemplateEncryptionConfigurationPtrInput` via: 

        RepositoryCreationTemplateEncryptionConfigurationArgs{...}

or:

        nil

func RepositoryCreationTemplateEncryptionConfigurationPtr added in v0.103.0 

func RepositoryCreationTemplateEncryptionConfigurationPtr(v *RepositoryCreationTemplateEncryptionConfigurationArgs) RepositoryCreationTemplateEncryptionConfigurationPtrInput

type RepositoryCreationTemplateEncryptionConfigurationPtrOutput added in v0.103.0 

type RepositoryCreationTemplateEncryptionConfigurationPtrOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) Elem added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationPtrOutput) Elem() RepositoryCreationTemplateEncryptionConfigurationOutput

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) EncryptionType added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationPtrOutput) EncryptionType() RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) KmsKey added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationPtrOutput) KmsKey() pulumi.StringPtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutput() RepositoryCreationTemplateEncryptionConfigurationPtrOutput

func (RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionConfigurationPtrOutput) ToRepositoryCreationTemplateEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionConfigurationPtrOutput

type RepositoryCreationTemplateEncryptionType added in v0.103.0 

type RepositoryCreationTemplateEncryptionType string

The encryption type to use.

func (RepositoryCreationTemplateEncryptionType) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionType) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypeOutput added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypeOutput() RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypeOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypeOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypePtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypePtrOutput() RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionType) ToStringOutput added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateEncryptionType) ToStringOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateEncryptionType) ToStringPtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateEncryptionType) ToStringPtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateEncryptionType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateEncryptionTypeInput added in v0.103.0 

type RepositoryCreationTemplateEncryptionTypeInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateEncryptionTypeOutput() RepositoryCreationTemplateEncryptionTypeOutput
	ToRepositoryCreationTemplateEncryptionTypeOutputWithContext(context.Context) RepositoryCreationTemplateEncryptionTypeOutput
}

RepositoryCreationTemplateEncryptionTypeInput is an input type that accepts values of the RepositoryCreationTemplateEncryptionType enum A concrete instance of `RepositoryCreationTemplateEncryptionTypeInput` can be one of the following: 

RepositoryCreationTemplateEncryptionTypeAes256
RepositoryCreationTemplateEncryptionTypeKms

type RepositoryCreationTemplateEncryptionTypeOutput added in v0.103.0 

type RepositoryCreationTemplateEncryptionTypeOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateEncryptionTypeOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionTypeOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypeOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypeOutput() RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypeOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypeOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutput() RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToStringOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToStringOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateEncryptionTypeOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateEncryptionTypePtrInput added in v0.103.0 

type RepositoryCreationTemplateEncryptionTypePtrInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateEncryptionTypePtrOutput() RepositoryCreationTemplateEncryptionTypePtrOutput
	ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext(context.Context) RepositoryCreationTemplateEncryptionTypePtrOutput
}

func RepositoryCreationTemplateEncryptionTypePtr added in v0.103.0 

func RepositoryCreationTemplateEncryptionTypePtr(v string) RepositoryCreationTemplateEncryptionTypePtrInput

type RepositoryCreationTemplateEncryptionTypePtrOutput added in v0.103.0 

type RepositoryCreationTemplateEncryptionTypePtrOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateEncryptionTypePtrOutput) Elem added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypePtrOutput) Elem() RepositoryCreationTemplateEncryptionTypeOutput

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypePtrOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutput() RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypePtrOutput) ToRepositoryCreationTemplateEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateEncryptionTypePtrOutput

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateEncryptionTypePtrOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateEncryptionTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateImageTagMutability added in v0.103.0 

type RepositoryCreationTemplateImageTagMutability string

The image tag mutability setting for the repository.

func (RepositoryCreationTemplateImageTagMutability) ElementType added in v0.103.0 

func (RepositoryCreationTemplateImageTagMutability) ElementType() reflect.Type

func (RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityOutput added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityOutput() RepositoryCreationTemplateImageTagMutabilityOutput

func (RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityOutputWithContext(ctx context.Context) RepositoryCreationTemplateImageTagMutabilityOutput

func (RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput() RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutability) ToStringOutput added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateImageTagMutability) ToStringOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateImageTagMutability) ToStringPtrOutput added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateImageTagMutability) ToStringPtrOutputWithContext added in v0.103.0 

func (e RepositoryCreationTemplateImageTagMutability) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateImageTagMutabilityInput added in v0.103.0 

type RepositoryCreationTemplateImageTagMutabilityInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateImageTagMutabilityOutput() RepositoryCreationTemplateImageTagMutabilityOutput
	ToRepositoryCreationTemplateImageTagMutabilityOutputWithContext(context.Context) RepositoryCreationTemplateImageTagMutabilityOutput
}

RepositoryCreationTemplateImageTagMutabilityInput is an input type that accepts values of the RepositoryCreationTemplateImageTagMutability enum A concrete instance of `RepositoryCreationTemplateImageTagMutabilityInput` can be one of the following: 

RepositoryCreationTemplateImageTagMutabilityMutable
RepositoryCreationTemplateImageTagMutabilityImmutable

type RepositoryCreationTemplateImageTagMutabilityOutput added in v0.103.0 

type RepositoryCreationTemplateImageTagMutabilityOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateImageTagMutabilityOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateImageTagMutabilityOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityOutput() RepositoryCreationTemplateImageTagMutabilityOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityOutputWithContext(ctx context.Context) RepositoryCreationTemplateImageTagMutabilityOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput() RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToStringOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToStringOutput() pulumi.StringOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToStringOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateImageTagMutabilityPtrInput added in v0.103.0 

type RepositoryCreationTemplateImageTagMutabilityPtrInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateImageTagMutabilityPtrOutput() RepositoryCreationTemplateImageTagMutabilityPtrOutput
	ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext(context.Context) RepositoryCreationTemplateImageTagMutabilityPtrOutput
}

func RepositoryCreationTemplateImageTagMutabilityPtr added in v0.103.0 

func RepositoryCreationTemplateImageTagMutabilityPtr(v string) RepositoryCreationTemplateImageTagMutabilityPtrInput

type RepositoryCreationTemplateImageTagMutabilityPtrOutput added in v0.103.0 

type RepositoryCreationTemplateImageTagMutabilityPtrOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) Elem added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityPtrOutput) Elem() RepositoryCreationTemplateImageTagMutabilityOutput

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutput() RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToRepositoryCreationTemplateImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryCreationTemplateImageTagMutabilityPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToStringPtrOutput added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToStringPtrOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateImageTagMutabilityPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryCreationTemplateInput added in v0.103.0 

type RepositoryCreationTemplateInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateOutput() RepositoryCreationTemplateOutput
	ToRepositoryCreationTemplateOutputWithContext(ctx context.Context) RepositoryCreationTemplateOutput
}

type RepositoryCreationTemplateOutput added in v0.103.0 

type RepositoryCreationTemplateOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateOutput) AppliedFor added in v0.103.0 

func (o RepositoryCreationTemplateOutput) AppliedFor() RepositoryCreationTemplateAppliedForItemArrayOutput

A list of enumerable Strings representing the repository creation scenarios that the template will apply towards.

func (RepositoryCreationTemplateOutput) CreatedAt added in v0.103.0 

func (o RepositoryCreationTemplateOutput) CreatedAt() pulumi.StringOutput

Create timestamp of the template.

func (RepositoryCreationTemplateOutput) Description added in v0.103.0 

func (o RepositoryCreationTemplateOutput) Description() pulumi.StringPtrOutput

The description of the template.

func (RepositoryCreationTemplateOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateOutput) EncryptionConfiguration added in v0.103.0 

func (o RepositoryCreationTemplateOutput) EncryptionConfiguration() RepositoryCreationTemplateEncryptionConfigurationPtrOutput

func (RepositoryCreationTemplateOutput) ImageTagMutability added in v0.103.0 

func (o RepositoryCreationTemplateOutput) ImageTagMutability() RepositoryCreationTemplateImageTagMutabilityPtrOutput

The image tag mutability setting for the repository.

func (RepositoryCreationTemplateOutput) LifecyclePolicy added in v0.103.0 

func (o RepositoryCreationTemplateOutput) LifecyclePolicy() pulumi.StringPtrOutput

The JSON lifecycle policy text to apply to the repository. For information about lifecycle policy syntax, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html

func (RepositoryCreationTemplateOutput) Prefix added in v0.103.0 

func (o RepositoryCreationTemplateOutput) Prefix() pulumi.StringOutput

The prefix use to match the repository name and apply the template.

func (RepositoryCreationTemplateOutput) RepositoryPolicy added in v0.103.0 

func (o RepositoryCreationTemplateOutput) RepositoryPolicy() pulumi.StringPtrOutput

The JSON repository policy text to apply to the repository. For more information, see https://docs.aws.amazon.com/AmazonECR/latest/userguide/RepositoryPolicyExamples.html

func (RepositoryCreationTemplateOutput) ResourceTags added in v0.103.0 

func (o RepositoryCreationTemplateOutput) ResourceTags() RepositoryCreationTemplateTagArrayOutput

An array of key-value pairs to apply to this resource.

func (RepositoryCreationTemplateOutput) ToRepositoryCreationTemplateOutput added in v0.103.0 

func (o RepositoryCreationTemplateOutput) ToRepositoryCreationTemplateOutput() RepositoryCreationTemplateOutput

func (RepositoryCreationTemplateOutput) ToRepositoryCreationTemplateOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateOutput) ToRepositoryCreationTemplateOutputWithContext(ctx context.Context) RepositoryCreationTemplateOutput

func (RepositoryCreationTemplateOutput) UpdatedAt added in v0.103.0 

func (o RepositoryCreationTemplateOutput) UpdatedAt() pulumi.StringOutput

Update timestamp of the template.

type RepositoryCreationTemplateState added in v0.103.0 

type RepositoryCreationTemplateState struct {
}

func (RepositoryCreationTemplateState) ElementType added in v0.103.0 

func (RepositoryCreationTemplateState) ElementType() reflect.Type

type RepositoryCreationTemplateTag added in v0.103.0 

type RepositoryCreationTemplateTag struct {
	// The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
	Key string `pulumi:"key"`
	// The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
	Value string `pulumi:"value"`
}

An array of key-value pairs to apply to this resource.

type RepositoryCreationTemplateTagArgs added in v0.103.0 

type RepositoryCreationTemplateTagArgs struct {
	// The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
	Key pulumi.StringInput `pulumi:"key"`
	// The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.
	Value pulumi.StringInput `pulumi:"value"`
}

An array of key-value pairs to apply to this resource.

func (RepositoryCreationTemplateTagArgs) ElementType added in v0.103.0 

func (RepositoryCreationTemplateTagArgs) ElementType() reflect.Type

func (RepositoryCreationTemplateTagArgs) ToRepositoryCreationTemplateTagOutput added in v0.103.0 

func (i RepositoryCreationTemplateTagArgs) ToRepositoryCreationTemplateTagOutput() RepositoryCreationTemplateTagOutput

func (RepositoryCreationTemplateTagArgs) ToRepositoryCreationTemplateTagOutputWithContext added in v0.103.0 

func (i RepositoryCreationTemplateTagArgs) ToRepositoryCreationTemplateTagOutputWithContext(ctx context.Context) RepositoryCreationTemplateTagOutput

type RepositoryCreationTemplateTagArray added in v0.103.0 

type RepositoryCreationTemplateTagArray []RepositoryCreationTemplateTagInput

func (RepositoryCreationTemplateTagArray) ElementType added in v0.103.0 

func (RepositoryCreationTemplateTagArray) ElementType() reflect.Type

func (RepositoryCreationTemplateTagArray) ToRepositoryCreationTemplateTagArrayOutput added in v0.103.0 

func (i RepositoryCreationTemplateTagArray) ToRepositoryCreationTemplateTagArrayOutput() RepositoryCreationTemplateTagArrayOutput

func (RepositoryCreationTemplateTagArray) ToRepositoryCreationTemplateTagArrayOutputWithContext added in v0.103.0 

func (i RepositoryCreationTemplateTagArray) ToRepositoryCreationTemplateTagArrayOutputWithContext(ctx context.Context) RepositoryCreationTemplateTagArrayOutput

type RepositoryCreationTemplateTagArrayInput added in v0.103.0 

type RepositoryCreationTemplateTagArrayInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateTagArrayOutput() RepositoryCreationTemplateTagArrayOutput
	ToRepositoryCreationTemplateTagArrayOutputWithContext(context.Context) RepositoryCreationTemplateTagArrayOutput
}

RepositoryCreationTemplateTagArrayInput is an input type that accepts RepositoryCreationTemplateTagArray and RepositoryCreationTemplateTagArrayOutput values. You can construct a concrete instance of `RepositoryCreationTemplateTagArrayInput` via: 

RepositoryCreationTemplateTagArray{ RepositoryCreationTemplateTagArgs{...} }

type RepositoryCreationTemplateTagArrayOutput added in v0.103.0 

type RepositoryCreationTemplateTagArrayOutput struct{ *pulumi.OutputState }

func (RepositoryCreationTemplateTagArrayOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateTagArrayOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateTagArrayOutput) Index added in v0.103.0 

func (o RepositoryCreationTemplateTagArrayOutput) Index(i pulumi.IntInput) RepositoryCreationTemplateTagOutput

func (RepositoryCreationTemplateTagArrayOutput) ToRepositoryCreationTemplateTagArrayOutput added in v0.103.0 

func (o RepositoryCreationTemplateTagArrayOutput) ToRepositoryCreationTemplateTagArrayOutput() RepositoryCreationTemplateTagArrayOutput

func (RepositoryCreationTemplateTagArrayOutput) ToRepositoryCreationTemplateTagArrayOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateTagArrayOutput) ToRepositoryCreationTemplateTagArrayOutputWithContext(ctx context.Context) RepositoryCreationTemplateTagArrayOutput

type RepositoryCreationTemplateTagInput added in v0.103.0 

type RepositoryCreationTemplateTagInput interface {
	pulumi.Input

	ToRepositoryCreationTemplateTagOutput() RepositoryCreationTemplateTagOutput
	ToRepositoryCreationTemplateTagOutputWithContext(context.Context) RepositoryCreationTemplateTagOutput
}

RepositoryCreationTemplateTagInput is an input type that accepts RepositoryCreationTemplateTagArgs and RepositoryCreationTemplateTagOutput values. You can construct a concrete instance of `RepositoryCreationTemplateTagInput` via: 

RepositoryCreationTemplateTagArgs{...}

type RepositoryCreationTemplateTagOutput added in v0.103.0 

type RepositoryCreationTemplateTagOutput struct{ *pulumi.OutputState }

An array of key-value pairs to apply to this resource.

func (RepositoryCreationTemplateTagOutput) ElementType added in v0.103.0 

func (RepositoryCreationTemplateTagOutput) ElementType() reflect.Type

func (RepositoryCreationTemplateTagOutput) Key added in v0.103.0 

func (o RepositoryCreationTemplateTagOutput) Key() pulumi.StringOutput

The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.

func (RepositoryCreationTemplateTagOutput) ToRepositoryCreationTemplateTagOutput added in v0.103.0 

func (o RepositoryCreationTemplateTagOutput) ToRepositoryCreationTemplateTagOutput() RepositoryCreationTemplateTagOutput

func (RepositoryCreationTemplateTagOutput) ToRepositoryCreationTemplateTagOutputWithContext added in v0.103.0 

func (o RepositoryCreationTemplateTagOutput) ToRepositoryCreationTemplateTagOutputWithContext(ctx context.Context) RepositoryCreationTemplateTagOutput

func (RepositoryCreationTemplateTagOutput) Value added in v0.103.0 

func (o RepositoryCreationTemplateTagOutput) Value() pulumi.StringOutput

The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -.

type RepositoryEncryptionConfiguration 

type RepositoryEncryptionConfiguration struct {
	// The encryption type to use.
	//  If you use the “KMS“ encryption type, the contents of the repository will be encrypted using server-side encryption with KMSlong key stored in KMS. When you use KMS to encrypt your data, you can either use the default AWS managed KMS key for Amazon ECR, or specify your own KMS key, which you already created. For more information, see [Protecting data using server-side encryption with an key stored in (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) in the *Amazon Simple Storage Service Console Developer Guide*.
	//  If you use the “AES256“ encryption type, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts the images in the repository using an AES-256 encryption algorithm. For more information, see [Protecting data using server-side encryption with Amazon S3-managed encryption keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) in the *Ama
	EncryptionType RepositoryEncryptionType `pulumi:"encryptionType"`
	// If you use the “KMS“ encryption type, specify the KMS key to use for encryption. The alias, key ID, or full ARN of the KMS key can be specified. The key must exist in the same Region as the repository. If no key is specified, the default AWS managed KMS key for Amazon ECR will be used.
	KmsKey *string `pulumi:"kmsKey"`
}

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 

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 AES-256 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 KMSlong key stored in KMSlong (KMS) to encrypt your images. For more information, see [Amazon ECR encryption at rest](https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html) in the *Amazon Elastic Container Registry User Guide*.

type RepositoryEncryptionConfigurationArgs 

type RepositoryEncryptionConfigurationArgs struct {
	// The encryption type to use.
	//  If you use the “KMS“ encryption type, the contents of the repository will be encrypted using server-side encryption with KMSlong key stored in KMS. When you use KMS to encrypt your data, you can either use the default AWS managed KMS key for Amazon ECR, or specify your own KMS key, which you already created. For more information, see [Protecting data using server-side encryption with an key stored in (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) in the *Amazon Simple Storage Service Console Developer Guide*.
	//  If you use the “AES256“ encryption type, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts the images in the repository using an AES-256 encryption algorithm. For more information, see [Protecting data using server-side encryption with Amazon S3-managed encryption keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) in the *Ama
	EncryptionType RepositoryEncryptionTypeInput `pulumi:"encryptionType"`
	// If you use the “KMS“ encryption type, specify the KMS key to use for encryption. The alias, key ID, or full ARN of the KMS key can be specified. The key must exist in the same Region as the repository. If no key is specified, the default AWS managed KMS key for Amazon ECR will be used.
	KmsKey pulumi.StringPtrInput `pulumi:"kmsKey"`
}

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 

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 AES-256 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 KMSlong key stored in KMSlong (KMS) to encrypt your images. For more information, see [Amazon ECR encryption at rest](https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html) in the *Amazon Elastic Container Registry User Guide*.

func (RepositoryEncryptionConfigurationArgs) ElementType 

func (RepositoryEncryptionConfigurationArgs) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutput 

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutputWithContext 

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationPtrOutput 

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationPtrOutput() RepositoryEncryptionConfigurationPtrOutput

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationPtrOutputWithContext 

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationPtrOutput

type RepositoryEncryptionConfigurationInput 

type RepositoryEncryptionConfigurationInput interface {
	pulumi.Input

	ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput
	ToRepositoryEncryptionConfigurationOutputWithContext(context.Context) RepositoryEncryptionConfigurationOutput
}

RepositoryEncryptionConfigurationInput is an input type that accepts RepositoryEncryptionConfigurationArgs and RepositoryEncryptionConfigurationOutput values. You can construct a concrete instance of `RepositoryEncryptionConfigurationInput` via: 

RepositoryEncryptionConfigurationArgs{...}

type RepositoryEncryptionConfigurationOutput 

type RepositoryEncryptionConfigurationOutput struct{ *pulumi.OutputState }

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest. 

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 AES-256 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 KMSlong key stored in KMSlong (KMS) to encrypt your images. For more information, see [Amazon ECR encryption at rest](https://docs.aws.amazon.com/AmazonECR/latest/userguide/encryption-at-rest.html) in the *Amazon Elastic Container Registry User Guide*.

func (RepositoryEncryptionConfigurationOutput) ElementType 

func (RepositoryEncryptionConfigurationOutput) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationOutput) EncryptionType 

func (o RepositoryEncryptionConfigurationOutput) EncryptionType() RepositoryEncryptionTypeOutput

The encryption type to use. 

If you use the ``KMS`` encryption type, the contents of the repository will be encrypted using server-side encryption with KMSlong key stored in KMS. When you use KMS to encrypt your data, you can either use the default AWS managed KMS key for Amazon ECR, or specify your own KMS key, which you already created. For more information, see [Protecting data using server-side encryption with an key stored in (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) in the *Amazon Simple Storage Service Console Developer Guide*.
If you use the ``AES256`` encryption type, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts the images in the repository using an AES-256 encryption algorithm. For more information, see [Protecting data using server-side encryption with Amazon S3-managed encryption keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) in the *Ama

func (RepositoryEncryptionConfigurationOutput) KmsKey 

func (o RepositoryEncryptionConfigurationOutput) KmsKey() pulumi.StringPtrOutput

If you use the “KMS“ encryption type, specify the KMS key to use for encryption. The alias, key ID, or full ARN of the KMS key can be specified. The key must exist in the same Region as the repository. If no key is specified, the default AWS managed KMS key for Amazon ECR will be used.

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutput 

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutputWithContext 

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationPtrOutput 

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationPtrOutput() RepositoryEncryptionConfigurationPtrOutput

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationPtrOutputWithContext 

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationPtrOutput

type RepositoryEncryptionConfigurationPtrInput 

type RepositoryEncryptionConfigurationPtrInput interface {
	pulumi.Input

	ToRepositoryEncryptionConfigurationPtrOutput() RepositoryEncryptionConfigurationPtrOutput
	ToRepositoryEncryptionConfigurationPtrOutputWithContext(context.Context) RepositoryEncryptionConfigurationPtrOutput
}

RepositoryEncryptionConfigurationPtrInput is an input type that accepts RepositoryEncryptionConfigurationArgs, RepositoryEncryptionConfigurationPtr and RepositoryEncryptionConfigurationPtrOutput values. You can construct a concrete instance of `RepositoryEncryptionConfigurationPtrInput` via: 

        RepositoryEncryptionConfigurationArgs{...}

or:

        nil

func RepositoryEncryptionConfigurationPtr 

func RepositoryEncryptionConfigurationPtr(v *RepositoryEncryptionConfigurationArgs) RepositoryEncryptionConfigurationPtrInput

type RepositoryEncryptionConfigurationPtrOutput 

type RepositoryEncryptionConfigurationPtrOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionConfigurationPtrOutput) Elem 

func (o RepositoryEncryptionConfigurationPtrOutput) Elem() RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationPtrOutput) ElementType 

func (RepositoryEncryptionConfigurationPtrOutput) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationPtrOutput) EncryptionType 

func (o RepositoryEncryptionConfigurationPtrOutput) EncryptionType() RepositoryEncryptionTypePtrOutput

The encryption type to use. 

If you use the ``KMS`` encryption type, the contents of the repository will be encrypted using server-side encryption with KMSlong key stored in KMS. When you use KMS to encrypt your data, you can either use the default AWS managed KMS key for Amazon ECR, or specify your own KMS key, which you already created. For more information, see [Protecting data using server-side encryption with an key stored in (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html) in the *Amazon Simple Storage Service Console Developer Guide*.
If you use the ``AES256`` encryption type, Amazon ECR uses server-side encryption with Amazon S3-managed encryption keys which encrypts the images in the repository using an AES-256 encryption algorithm. For more information, see [Protecting data using server-side encryption with Amazon S3-managed encryption keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) in the *Ama

func (RepositoryEncryptionConfigurationPtrOutput) KmsKey 

func (o RepositoryEncryptionConfigurationPtrOutput) KmsKey() pulumi.StringPtrOutput

If you use the “KMS“ encryption type, specify the KMS key to use for encryption. The alias, key ID, or full ARN of the KMS key can be specified. The key must exist in the same Region as the repository. If no key is specified, the default AWS managed KMS key for Amazon ECR will be used.

func (RepositoryEncryptionConfigurationPtrOutput) ToRepositoryEncryptionConfigurationPtrOutput 

func (o RepositoryEncryptionConfigurationPtrOutput) ToRepositoryEncryptionConfigurationPtrOutput() RepositoryEncryptionConfigurationPtrOutput

func (RepositoryEncryptionConfigurationPtrOutput) ToRepositoryEncryptionConfigurationPtrOutputWithContext 

func (o RepositoryEncryptionConfigurationPtrOutput) ToRepositoryEncryptionConfigurationPtrOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationPtrOutput

type RepositoryEncryptionType 

type RepositoryEncryptionType string

The encryption type to use.

func (RepositoryEncryptionType) ElementType 

func (RepositoryEncryptionType) ElementType() reflect.Type

func (RepositoryEncryptionType) ToRepositoryEncryptionTypeOutput 

func (e RepositoryEncryptionType) ToRepositoryEncryptionTypeOutput() RepositoryEncryptionTypeOutput

func (RepositoryEncryptionType) ToRepositoryEncryptionTypeOutputWithContext 

func (e RepositoryEncryptionType) ToRepositoryEncryptionTypeOutputWithContext(ctx context.Context) RepositoryEncryptionTypeOutput

func (RepositoryEncryptionType) ToRepositoryEncryptionTypePtrOutput 

func (e RepositoryEncryptionType) ToRepositoryEncryptionTypePtrOutput() RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionType) ToRepositoryEncryptionTypePtrOutputWithContext 

func (e RepositoryEncryptionType) ToRepositoryEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionType) ToStringOutput 

func (e RepositoryEncryptionType) ToStringOutput() pulumi.StringOutput

func (RepositoryEncryptionType) ToStringOutputWithContext 

func (e RepositoryEncryptionType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryEncryptionType) ToStringPtrOutput 

func (e RepositoryEncryptionType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryEncryptionType) ToStringPtrOutputWithContext 

func (e RepositoryEncryptionType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryEncryptionTypeInput 

type RepositoryEncryptionTypeInput interface {
	pulumi.Input

	ToRepositoryEncryptionTypeOutput() RepositoryEncryptionTypeOutput
	ToRepositoryEncryptionTypeOutputWithContext(context.Context) RepositoryEncryptionTypeOutput
}

RepositoryEncryptionTypeInput is an input type that accepts values of the RepositoryEncryptionType enum A concrete instance of `RepositoryEncryptionTypeInput` can be one of the following: 

RepositoryEncryptionTypeAes256
RepositoryEncryptionTypeKms

type RepositoryEncryptionTypeOutput 

type RepositoryEncryptionTypeOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionTypeOutput) ElementType 

func (RepositoryEncryptionTypeOutput) ElementType() reflect.Type

func (RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypeOutput 

func (o RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypeOutput() RepositoryEncryptionTypeOutput

func (RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypeOutputWithContext 

func (o RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypeOutputWithContext(ctx context.Context) RepositoryEncryptionTypeOutput

func (RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypePtrOutput 

func (o RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypePtrOutput() RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypePtrOutputWithContext 

func (o RepositoryEncryptionTypeOutput) ToRepositoryEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionTypeOutput) ToStringOutput 

func (o RepositoryEncryptionTypeOutput) ToStringOutput() pulumi.StringOutput

func (RepositoryEncryptionTypeOutput) ToStringOutputWithContext 

func (o RepositoryEncryptionTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryEncryptionTypeOutput) ToStringPtrOutput 

func (o RepositoryEncryptionTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryEncryptionTypeOutput) ToStringPtrOutputWithContext 

func (o RepositoryEncryptionTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryEncryptionTypePtrInput 

type RepositoryEncryptionTypePtrInput interface {
	pulumi.Input

	ToRepositoryEncryptionTypePtrOutput() RepositoryEncryptionTypePtrOutput
	ToRepositoryEncryptionTypePtrOutputWithContext(context.Context) RepositoryEncryptionTypePtrOutput
}

func RepositoryEncryptionTypePtr 

func RepositoryEncryptionTypePtr(v string) RepositoryEncryptionTypePtrInput

type RepositoryEncryptionTypePtrOutput 

type RepositoryEncryptionTypePtrOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionTypePtrOutput) Elem 

func (o RepositoryEncryptionTypePtrOutput) Elem() RepositoryEncryptionTypeOutput

func (RepositoryEncryptionTypePtrOutput) ElementType 

func (RepositoryEncryptionTypePtrOutput) ElementType() reflect.Type

func (RepositoryEncryptionTypePtrOutput) ToRepositoryEncryptionTypePtrOutput 

func (o RepositoryEncryptionTypePtrOutput) ToRepositoryEncryptionTypePtrOutput() RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionTypePtrOutput) ToRepositoryEncryptionTypePtrOutputWithContext 

func (o RepositoryEncryptionTypePtrOutput) ToRepositoryEncryptionTypePtrOutputWithContext(ctx context.Context) RepositoryEncryptionTypePtrOutput

func (RepositoryEncryptionTypePtrOutput) ToStringPtrOutput 

func (o RepositoryEncryptionTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryEncryptionTypePtrOutput) ToStringPtrOutputWithContext 

func (o RepositoryEncryptionTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryImageScanningConfiguration 

type RepositoryImageScanningConfiguration 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.
	ScanOnPush *bool `pulumi:"scanOnPush"`
}

The image scanning configuration for a repository.

type RepositoryImageScanningConfigurationArgs 

type RepositoryImageScanningConfigurationArgs 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.
	ScanOnPush pulumi.BoolPtrInput `pulumi:"scanOnPush"`
}

The image scanning configuration for a repository.

func (RepositoryImageScanningConfigurationArgs) ElementType 

func (RepositoryImageScanningConfigurationArgs) ElementType() reflect.Type

func (RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutput 

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput

func (RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutputWithContext 

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationOutput

func (RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutput 

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput

func (RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutputWithContext 

func (i RepositoryImageScanningConfigurationArgs) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput

type RepositoryImageScanningConfigurationInput 

type RepositoryImageScanningConfigurationInput interface {
	pulumi.Input

	ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput
	ToRepositoryImageScanningConfigurationOutputWithContext(context.Context) RepositoryImageScanningConfigurationOutput
}

RepositoryImageScanningConfigurationInput is an input type that accepts RepositoryImageScanningConfigurationArgs and RepositoryImageScanningConfigurationOutput values. You can construct a concrete instance of `RepositoryImageScanningConfigurationInput` via: 

RepositoryImageScanningConfigurationArgs{...}

type RepositoryImageScanningConfigurationOutput 

type RepositoryImageScanningConfigurationOutput struct{ *pulumi.OutputState }

The image scanning configuration for a repository.

func (RepositoryImageScanningConfigurationOutput) ElementType 

func (RepositoryImageScanningConfigurationOutput) ElementType() reflect.Type

func (RepositoryImageScanningConfigurationOutput) ScanOnPush 

func (o RepositoryImageScanningConfigurationOutput) ScanOnPush() pulumi.BoolPtrOutput

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.

func (RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutput 

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutput() RepositoryImageScanningConfigurationOutput

func (RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutputWithContext 

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationOutput

func (RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutput 

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput

func (RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext 

func (o RepositoryImageScanningConfigurationOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput

type RepositoryImageScanningConfigurationPtrInput 

type RepositoryImageScanningConfigurationPtrInput interface {
	pulumi.Input

	ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput
	ToRepositoryImageScanningConfigurationPtrOutputWithContext(context.Context) RepositoryImageScanningConfigurationPtrOutput
}

RepositoryImageScanningConfigurationPtrInput is an input type that accepts RepositoryImageScanningConfigurationArgs, RepositoryImageScanningConfigurationPtr and RepositoryImageScanningConfigurationPtrOutput values. You can construct a concrete instance of `RepositoryImageScanningConfigurationPtrInput` via: 

        RepositoryImageScanningConfigurationArgs{...}

or:

        nil

func RepositoryImageScanningConfigurationPtr 

func RepositoryImageScanningConfigurationPtr(v *RepositoryImageScanningConfigurationArgs) RepositoryImageScanningConfigurationPtrInput

type RepositoryImageScanningConfigurationPtrOutput 

type RepositoryImageScanningConfigurationPtrOutput struct{ *pulumi.OutputState }

func (RepositoryImageScanningConfigurationPtrOutput) Elem 

func (o RepositoryImageScanningConfigurationPtrOutput) Elem() RepositoryImageScanningConfigurationOutput

func (RepositoryImageScanningConfigurationPtrOutput) ElementType 

func (RepositoryImageScanningConfigurationPtrOutput) ElementType() reflect.Type

func (RepositoryImageScanningConfigurationPtrOutput) ScanOnPush 

func (o RepositoryImageScanningConfigurationPtrOutput) ScanOnPush() pulumi.BoolPtrOutput

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.

func (RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutput 

func (o RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput

func (RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext 

func (o RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext(ctx context.Context) RepositoryImageScanningConfigurationPtrOutput

type RepositoryImageTagMutability 

type RepositoryImageTagMutability string

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.

func (RepositoryImageTagMutability) ElementType 

func (RepositoryImageTagMutability) ElementType() reflect.Type

func (RepositoryImageTagMutability) ToRepositoryImageTagMutabilityOutput 

func (e RepositoryImageTagMutability) ToRepositoryImageTagMutabilityOutput() RepositoryImageTagMutabilityOutput

func (RepositoryImageTagMutability) ToRepositoryImageTagMutabilityOutputWithContext 

func (e RepositoryImageTagMutability) ToRepositoryImageTagMutabilityOutputWithContext(ctx context.Context) RepositoryImageTagMutabilityOutput

func (RepositoryImageTagMutability) ToRepositoryImageTagMutabilityPtrOutput 

func (e RepositoryImageTagMutability) ToRepositoryImageTagMutabilityPtrOutput() RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutability) ToRepositoryImageTagMutabilityPtrOutputWithContext 

func (e RepositoryImageTagMutability) ToRepositoryImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutability) ToStringOutput 

func (e RepositoryImageTagMutability) ToStringOutput() pulumi.StringOutput

func (RepositoryImageTagMutability) ToStringOutputWithContext 

func (e RepositoryImageTagMutability) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryImageTagMutability) ToStringPtrOutput 

func (e RepositoryImageTagMutability) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryImageTagMutability) ToStringPtrOutputWithContext 

func (e RepositoryImageTagMutability) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryImageTagMutabilityInput 

type RepositoryImageTagMutabilityInput interface {
	pulumi.Input

	ToRepositoryImageTagMutabilityOutput() RepositoryImageTagMutabilityOutput
	ToRepositoryImageTagMutabilityOutputWithContext(context.Context) RepositoryImageTagMutabilityOutput
}

RepositoryImageTagMutabilityInput is an input type that accepts values of the RepositoryImageTagMutability enum A concrete instance of `RepositoryImageTagMutabilityInput` can be one of the following: 

RepositoryImageTagMutabilityMutable
RepositoryImageTagMutabilityImmutable

type RepositoryImageTagMutabilityOutput 

type RepositoryImageTagMutabilityOutput struct{ *pulumi.OutputState }

func (RepositoryImageTagMutabilityOutput) ElementType 

func (RepositoryImageTagMutabilityOutput) ElementType() reflect.Type

func (RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityOutput 

func (o RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityOutput() RepositoryImageTagMutabilityOutput

func (RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityOutputWithContext 

func (o RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityOutputWithContext(ctx context.Context) RepositoryImageTagMutabilityOutput

func (RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityPtrOutput 

func (o RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityPtrOutput() RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityPtrOutputWithContext 

func (o RepositoryImageTagMutabilityOutput) ToRepositoryImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutabilityOutput) ToStringOutput 

func (o RepositoryImageTagMutabilityOutput) ToStringOutput() pulumi.StringOutput

func (RepositoryImageTagMutabilityOutput) ToStringOutputWithContext 

func (o RepositoryImageTagMutabilityOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RepositoryImageTagMutabilityOutput) ToStringPtrOutput 

func (o RepositoryImageTagMutabilityOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryImageTagMutabilityOutput) ToStringPtrOutputWithContext 

func (o RepositoryImageTagMutabilityOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryImageTagMutabilityPtrInput 

type RepositoryImageTagMutabilityPtrInput interface {
	pulumi.Input

	ToRepositoryImageTagMutabilityPtrOutput() RepositoryImageTagMutabilityPtrOutput
	ToRepositoryImageTagMutabilityPtrOutputWithContext(context.Context) RepositoryImageTagMutabilityPtrOutput
}

func RepositoryImageTagMutabilityPtr 

func RepositoryImageTagMutabilityPtr(v string) RepositoryImageTagMutabilityPtrInput

type RepositoryImageTagMutabilityPtrOutput 

type RepositoryImageTagMutabilityPtrOutput struct{ *pulumi.OutputState }

func (RepositoryImageTagMutabilityPtrOutput) Elem 

func (o RepositoryImageTagMutabilityPtrOutput) Elem() RepositoryImageTagMutabilityOutput

func (RepositoryImageTagMutabilityPtrOutput) ElementType 

func (RepositoryImageTagMutabilityPtrOutput) ElementType() reflect.Type

func (RepositoryImageTagMutabilityPtrOutput) ToRepositoryImageTagMutabilityPtrOutput 

func (o RepositoryImageTagMutabilityPtrOutput) ToRepositoryImageTagMutabilityPtrOutput() RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutabilityPtrOutput) ToRepositoryImageTagMutabilityPtrOutputWithContext 

func (o RepositoryImageTagMutabilityPtrOutput) ToRepositoryImageTagMutabilityPtrOutputWithContext(ctx context.Context) RepositoryImageTagMutabilityPtrOutput

func (RepositoryImageTagMutabilityPtrOutput) ToStringPtrOutput 

func (o RepositoryImageTagMutabilityPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RepositoryImageTagMutabilityPtrOutput) ToStringPtrOutputWithContext 

func (o RepositoryImageTagMutabilityPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RepositoryInput 

type RepositoryInput interface {
	pulumi.Input

	ToRepositoryOutput() RepositoryOutput
	ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput
}

type RepositoryLifecyclePolicy 

type RepositoryLifecyclePolicy struct {
	// The JSON repository policy text to apply to the repository.
	LifecyclePolicyText *string `pulumi:"lifecyclePolicyText"`
	// 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 `pulumi:"registryId"`
}

The “LifecyclePolicy“ property type specifies a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html) in the *Amazon ECR User Guide*.

type RepositoryLifecyclePolicyArgs 

type RepositoryLifecyclePolicyArgs struct {
	// The JSON repository policy text to apply to the repository.
	LifecyclePolicyText pulumi.StringPtrInput `pulumi:"lifecyclePolicyText"`
	// 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 pulumi.StringPtrInput `pulumi:"registryId"`
}

The “LifecyclePolicy“ property type specifies a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html) in the *Amazon ECR User Guide*.

func (RepositoryLifecyclePolicyArgs) ElementType 

func (RepositoryLifecyclePolicyArgs) ElementType() reflect.Type

func (RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyOutput 

func (i RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyOutput() RepositoryLifecyclePolicyOutput

func (RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyOutputWithContext 

func (i RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyOutputWithContext(ctx context.Context) RepositoryLifecyclePolicyOutput

func (RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyPtrOutput 

func (i RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyPtrOutput() RepositoryLifecyclePolicyPtrOutput

func (RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyPtrOutputWithContext 

func (i RepositoryLifecyclePolicyArgs) ToRepositoryLifecyclePolicyPtrOutputWithContext(ctx context.Context) RepositoryLifecyclePolicyPtrOutput

type RepositoryLifecyclePolicyInput 

type RepositoryLifecyclePolicyInput interface {
	pulumi.Input

	ToRepositoryLifecyclePolicyOutput() RepositoryLifecyclePolicyOutput
	ToRepositoryLifecyclePolicyOutputWithContext(context.Context) RepositoryLifecyclePolicyOutput
}

RepositoryLifecyclePolicyInput is an input type that accepts RepositoryLifecyclePolicyArgs and RepositoryLifecyclePolicyOutput values. You can construct a concrete instance of `RepositoryLifecyclePolicyInput` via: 

RepositoryLifecyclePolicyArgs{...}

type RepositoryLifecyclePolicyOutput 

type RepositoryLifecyclePolicyOutput struct{ *pulumi.OutputState }

The “LifecyclePolicy“ property type specifies a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html) in the *Amazon ECR User Guide*.

func (RepositoryLifecyclePolicyOutput) ElementType 

func (RepositoryLifecyclePolicyOutput) ElementType() reflect.Type

func (RepositoryLifecyclePolicyOutput) LifecyclePolicyText 

func (o RepositoryLifecyclePolicyOutput) LifecyclePolicyText() pulumi.StringPtrOutput

The JSON repository policy text to apply to the repository.

func (RepositoryLifecyclePolicyOutput) RegistryId 

func (o RepositoryLifecyclePolicyOutput) RegistryId() pulumi.StringPtrOutput

The AWS account ID associated with the registry that contains the repository. If you do 

not specify a registry, the default registry is assumed.

func (RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyOutput 

func (o RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyOutput() RepositoryLifecyclePolicyOutput

func (RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyOutputWithContext 

func (o RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyOutputWithContext(ctx context.Context) RepositoryLifecyclePolicyOutput

func (RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyPtrOutput 

func (o RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyPtrOutput() RepositoryLifecyclePolicyPtrOutput

func (RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyPtrOutputWithContext 

func (o RepositoryLifecyclePolicyOutput) ToRepositoryLifecyclePolicyPtrOutputWithContext(ctx context.Context) RepositoryLifecyclePolicyPtrOutput

type RepositoryLifecyclePolicyPtrInput 

type RepositoryLifecyclePolicyPtrInput interface {
	pulumi.Input

	ToRepositoryLifecyclePolicyPtrOutput() RepositoryLifecyclePolicyPtrOutput
	ToRepositoryLifecyclePolicyPtrOutputWithContext(context.Context) RepositoryLifecyclePolicyPtrOutput
}

RepositoryLifecyclePolicyPtrInput is an input type that accepts RepositoryLifecyclePolicyArgs, RepositoryLifecyclePolicyPtr and RepositoryLifecyclePolicyPtrOutput values. You can construct a concrete instance of `RepositoryLifecyclePolicyPtrInput` via: 

        RepositoryLifecyclePolicyArgs{...}

or:

        nil

func RepositoryLifecyclePolicyPtr 

func RepositoryLifecyclePolicyPtr(v *RepositoryLifecyclePolicyArgs) RepositoryLifecyclePolicyPtrInput

type RepositoryLifecyclePolicyPtrOutput 

type RepositoryLifecyclePolicyPtrOutput struct{ *pulumi.OutputState }

func (RepositoryLifecyclePolicyPtrOutput) Elem 

func (o RepositoryLifecyclePolicyPtrOutput) Elem() RepositoryLifecyclePolicyOutput

func (RepositoryLifecyclePolicyPtrOutput) ElementType 

func (RepositoryLifecyclePolicyPtrOutput) ElementType() reflect.Type

func (RepositoryLifecyclePolicyPtrOutput) LifecyclePolicyText 

func (o RepositoryLifecyclePolicyPtrOutput) LifecyclePolicyText() pulumi.StringPtrOutput

The JSON repository policy text to apply to the repository.

func (RepositoryLifecyclePolicyPtrOutput) RegistryId 

func (o RepositoryLifecyclePolicyPtrOutput) RegistryId() pulumi.StringPtrOutput

The AWS account ID associated with the registry that contains the repository. If you do 

not specify a registry, the default registry is assumed.

func (RepositoryLifecyclePolicyPtrOutput) ToRepositoryLifecyclePolicyPtrOutput 

func (o RepositoryLifecyclePolicyPtrOutput) ToRepositoryLifecyclePolicyPtrOutput() RepositoryLifecyclePolicyPtrOutput

func (RepositoryLifecyclePolicyPtrOutput) ToRepositoryLifecyclePolicyPtrOutputWithContext 

func (o RepositoryLifecyclePolicyPtrOutput) ToRepositoryLifecyclePolicyPtrOutputWithContext(ctx context.Context) RepositoryLifecyclePolicyPtrOutput

type RepositoryOutput 

type RepositoryOutput struct{ *pulumi.OutputState }

func (RepositoryOutput) Arn added in v0.17.0 

func (o RepositoryOutput) Arn() pulumi.StringOutput

func (RepositoryOutput) ElementType 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) EmptyOnDelete added in v0.73.1 

func (o RepositoryOutput) EmptyOnDelete() pulumi.BoolPtrOutput

If true, deleting the repository force deletes the contents of the repository. If false, the repository must be empty before attempting to delete it.

func (RepositoryOutput) EncryptionConfiguration added in v0.17.0 

func (o RepositoryOutput) EncryptionConfiguration() RepositoryEncryptionConfigurationPtrOutput

The encryption configuration for the repository. This determines how the contents of your repository are encrypted at rest.

func (RepositoryOutput) ImageScanningConfiguration added in v0.17.0 

func (o RepositoryOutput) ImageScanningConfiguration() RepositoryImageScanningConfigurationPtrOutput

The image scanning configuration for the repository. This determines whether images are scanned for known vulnerabilities after being pushed to the repository.

func (RepositoryOutput) ImageTagMutability added in v0.17.0 

func (o RepositoryOutput) ImageTagMutability() RepositoryImageTagMutabilityPtrOutput

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.

func (RepositoryOutput) LifecyclePolicy added in v0.17.0 

func (o RepositoryOutput) LifecyclePolicy() RepositoryLifecyclePolicyPtrOutput

Creates or updates a lifecycle policy. For information about lifecycle policy syntax, see [Lifecycle policy template](https://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html).

func (RepositoryOutput) RepositoryName added in v0.17.0 

func (o RepositoryOutput) RepositoryName() pulumi.StringPtrOutput

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“). If you don't specify a name, CFNlong generates a unique physical ID and uses that ID for the repository name. For more information, see [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html). 

The repository name must start with a letter and can only contain lowercase letters, numbers, hyphens, underscores, and forward slashes.
 If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

func (RepositoryOutput) RepositoryPolicyText added in v0.17.0 

func (o RepositoryOutput) RepositoryPolicyText() pulumi.AnyOutput

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*.

Search the [CloudFormation User Guide](https://docs.aws.amazon.com/cloudformation/) for `AWS::ECR::Repository` for more information about the expected schema for this property.

func (RepositoryOutput) RepositoryUri added in v0.17.0 

func (o RepositoryOutput) RepositoryUri() pulumi.StringOutput

func (RepositoryOutput) Tags added in v0.17.0 

func (o RepositoryOutput) Tags() aws.TagArrayOutput

An array of key-value pairs to apply to this resource.

func (RepositoryOutput) ToRepositoryOutput 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext 

func (o RepositoryOutput) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

type RepositoryState 

type RepositoryState struct {
}

func (RepositoryState) ElementType 

func (RepositoryState) ElementType() reflect.Type

type RepositoryTag 

type RepositoryTag 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 `pulumi:"key"`
	// A “value“ acts as a descriptor within a tag category (key).
	Value string `pulumi:"value"`
}

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.

Source Files

View all Source files

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.