ecr

package
v3.37.0 Latest Latest
Warning

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

 Go to latest Published: Apr 11, 2021 License: Apache-2.0 Imports: 7 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GetAuthorizationTokenArgs 

type GetAuthorizationTokenArgs struct {
	// AWS account ID of the ECR Repository. If not specified the default account is assumed.
	RegistryId *string `pulumi:"registryId"`
}

A collection of arguments for invoking getAuthorizationToken.

type GetAuthorizationTokenResult 

type GetAuthorizationTokenResult struct {
	// Temporary IAM authentication credentials to access the ECR repository encoded in base64 in the form of `user_name:password`.
	AuthorizationToken string `pulumi:"authorizationToken"`
	// The time in UTC RFC3339 format when the authorization token expires.
	ExpiresAt string `pulumi:"expiresAt"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Password decoded from the authorization token.
	Password string `pulumi:"password"`
	// The registry URL to use in the docker login command.
	ProxyEndpoint string  `pulumi:"proxyEndpoint"`
	RegistryId    *string `pulumi:"registryId"`
	// User name decoded from the authorization token.
	UserName string `pulumi:"userName"`
}

A collection of values returned by getAuthorizationToken.

func GetAuthorizationToken 

func GetAuthorizationToken(ctx *pulumi.Context, args *GetAuthorizationTokenArgs, opts ...pulumi.InvokeOption) (*GetAuthorizationTokenResult, error)

The ECR Authorization Token data source allows the authorization token, proxy endpoint, token expiration date, user name and password to be retrieved for an ECR repository.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.GetAuthorizationToken(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetCredentialsArgs 

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

A collection of arguments for invoking getCredentials.

type GetCredentialsResult 

type GetCredentialsResult struct {
	AuthorizationToken string `pulumi:"authorizationToken"`
	ExpiresAt          string `pulumi:"expiresAt"`
	// The provider-assigned unique ID for this managed resource.
	Id            string `pulumi:"id"`
	ProxyEndpoint string `pulumi:"proxyEndpoint"`
	RegistryId    string `pulumi:"registryId"`
}

A collection of values returned by getCredentials.

func GetCredentials 

func GetCredentials(ctx *pulumi.Context, args *GetCredentialsArgs, opts ...pulumi.InvokeOption) (*GetCredentialsResult, error)

type GetImageArgs 

type GetImageArgs struct {
	// The sha256 digest of the image manifest. At least one of `imageDigest` or `imageTag` must be specified.
	ImageDigest *string `pulumi:"imageDigest"`
	// The tag associated with this image. At least one of `imageDigest` or `imageTag` must be specified.
	ImageTag *string `pulumi:"imageTag"`
	// The ID of the Registry where the repository resides.
	RegistryId *string `pulumi:"registryId"`
	// The name of the ECR Repository.
	RepositoryName string `pulumi:"repositoryName"`
}

A collection of arguments for invoking getImage.

type GetImageResult 

type GetImageResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id          string `pulumi:"id"`
	ImageDigest string `pulumi:"imageDigest"`
	// The date and time, expressed as a unix timestamp, at which the current image was pushed to the repository.
	ImagePushedAt int `pulumi:"imagePushedAt"`
	// The size, in bytes, of the image in the repository.
	ImageSizeInBytes int     `pulumi:"imageSizeInBytes"`
	ImageTag         *string `pulumi:"imageTag"`
	// The list of tags associated with this image.
	ImageTags      []string `pulumi:"imageTags"`
	RegistryId     string   `pulumi:"registryId"`
	RepositoryName string   `pulumi:"repositoryName"`
}

A collection of values returned by getImage.

func GetImage 

func GetImage(ctx *pulumi.Context, args *GetImageArgs, opts ...pulumi.InvokeOption) (*GetImageResult, error)

The ECR Image data source allows the details of an image with a particular tag or digest to be retrieved.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "latest"
		_, err := ecr.GetImage(ctx, &ecr.GetImageArgs{
			ImageTag:       &opt0,
			RepositoryName: "my/service",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetRepositoryEncryptionConfiguration added in v3.1.0 

type GetRepositoryEncryptionConfiguration struct {
	// The encryption type to use for the repository, either `AES256` or `KMS`.
	EncryptionType string `pulumi:"encryptionType"`
	// If `encryptionType` is `KMS`, the ARN of the KMS key used.
	KmsKey string `pulumi:"kmsKey"`
}

type GetRepositoryEncryptionConfigurationArgs added in v3.1.0 

type GetRepositoryEncryptionConfigurationArgs struct {
	// The encryption type to use for the repository, either `AES256` or `KMS`.
	EncryptionType pulumi.StringInput `pulumi:"encryptionType"`
	// If `encryptionType` is `KMS`, the ARN of the KMS key used.
	KmsKey pulumi.StringInput `pulumi:"kmsKey"`
}

func (GetRepositoryEncryptionConfigurationArgs) ElementType added in v3.1.0 

func (GetRepositoryEncryptionConfigurationArgs) ElementType() reflect.Type

func (GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutput added in v3.1.0 

func (i GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput

func (GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutputWithContext added in v3.1.0 

func (i GetRepositoryEncryptionConfigurationArgs) ToGetRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationOutput

type GetRepositoryEncryptionConfigurationArray added in v3.1.0 

type GetRepositoryEncryptionConfigurationArray []GetRepositoryEncryptionConfigurationInput

func (GetRepositoryEncryptionConfigurationArray) ElementType added in v3.1.0 

func (GetRepositoryEncryptionConfigurationArray) ElementType() reflect.Type

func (GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

func (i GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput

func (GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext added in v3.1.0 

func (i GetRepositoryEncryptionConfigurationArray) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationArrayOutput

type GetRepositoryEncryptionConfigurationArrayInput added in v3.1.0 

type GetRepositoryEncryptionConfigurationArrayInput interface {
	pulumi.Input

	ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput
	ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(context.Context) GetRepositoryEncryptionConfigurationArrayOutput
}

GetRepositoryEncryptionConfigurationArrayInput is an input type that accepts GetRepositoryEncryptionConfigurationArray and GetRepositoryEncryptionConfigurationArrayOutput values. You can construct a concrete instance of `GetRepositoryEncryptionConfigurationArrayInput` via: 

GetRepositoryEncryptionConfigurationArray{ GetRepositoryEncryptionConfigurationArgs{...} }

type GetRepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

type GetRepositoryEncryptionConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetRepositoryEncryptionConfigurationArrayOutput) ElementType added in v3.1.0 

func (GetRepositoryEncryptionConfigurationArrayOutput) ElementType() reflect.Type

func (GetRepositoryEncryptionConfigurationArrayOutput) Index added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationArrayOutput) Index(i pulumi.IntInput) GetRepositoryEncryptionConfigurationOutput

func (GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutput() GetRepositoryEncryptionConfigurationArrayOutput

func (GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationArrayOutput) ToGetRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationArrayOutput

type GetRepositoryEncryptionConfigurationInput added in v3.1.0 

type GetRepositoryEncryptionConfigurationInput interface {
	pulumi.Input

	ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput
	ToGetRepositoryEncryptionConfigurationOutputWithContext(context.Context) GetRepositoryEncryptionConfigurationOutput
}

GetRepositoryEncryptionConfigurationInput is an input type that accepts GetRepositoryEncryptionConfigurationArgs and GetRepositoryEncryptionConfigurationOutput values. You can construct a concrete instance of `GetRepositoryEncryptionConfigurationInput` via: 

GetRepositoryEncryptionConfigurationArgs{...}

type GetRepositoryEncryptionConfigurationOutput added in v3.1.0 

type GetRepositoryEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (GetRepositoryEncryptionConfigurationOutput) ElementType added in v3.1.0 

func (GetRepositoryEncryptionConfigurationOutput) ElementType() reflect.Type

func (GetRepositoryEncryptionConfigurationOutput) EncryptionType added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationOutput) EncryptionType() pulumi.StringOutput

The encryption type to use for the repository, either `AES256` or `KMS`.

func (GetRepositoryEncryptionConfigurationOutput) KmsKey added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationOutput) KmsKey() pulumi.StringOutput

If `encryptionType` is `KMS`, the ARN of the KMS key used.

func (GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutput added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutput() GetRepositoryEncryptionConfigurationOutput

func (GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutputWithContext added in v3.1.0 

func (o GetRepositoryEncryptionConfigurationOutput) ToGetRepositoryEncryptionConfigurationOutputWithContext(ctx context.Context) GetRepositoryEncryptionConfigurationOutput

type GetRepositoryImageScanningConfiguration added in v3.1.0 

type GetRepositoryImageScanningConfiguration struct {
	// Indicates whether images are scanned after being pushed to the repository.
	ScanOnPush bool `pulumi:"scanOnPush"`
}

type GetRepositoryImageScanningConfigurationArgs added in v3.1.0 

type GetRepositoryImageScanningConfigurationArgs struct {
	// Indicates whether images are scanned after being pushed to the repository.
	ScanOnPush pulumi.BoolInput `pulumi:"scanOnPush"`
}

func (GetRepositoryImageScanningConfigurationArgs) ElementType added in v3.1.0 

func (GetRepositoryImageScanningConfigurationArgs) ElementType() reflect.Type

func (GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutput added in v3.1.0 

func (i GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput

func (GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutputWithContext added in v3.1.0 

func (i GetRepositoryImageScanningConfigurationArgs) ToGetRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationOutput

type GetRepositoryImageScanningConfigurationArray added in v3.1.0 

type GetRepositoryImageScanningConfigurationArray []GetRepositoryImageScanningConfigurationInput

func (GetRepositoryImageScanningConfigurationArray) ElementType added in v3.1.0 

func (GetRepositoryImageScanningConfigurationArray) ElementType() reflect.Type

func (GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutput added in v3.1.0 

func (i GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput

func (GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext added in v3.1.0 

func (i GetRepositoryImageScanningConfigurationArray) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationArrayOutput

type GetRepositoryImageScanningConfigurationArrayInput added in v3.1.0 

type GetRepositoryImageScanningConfigurationArrayInput interface {
	pulumi.Input

	ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput
	ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(context.Context) GetRepositoryImageScanningConfigurationArrayOutput
}

GetRepositoryImageScanningConfigurationArrayInput is an input type that accepts GetRepositoryImageScanningConfigurationArray and GetRepositoryImageScanningConfigurationArrayOutput values. You can construct a concrete instance of `GetRepositoryImageScanningConfigurationArrayInput` via: 

GetRepositoryImageScanningConfigurationArray{ GetRepositoryImageScanningConfigurationArgs{...} }

type GetRepositoryImageScanningConfigurationArrayOutput added in v3.1.0 

type GetRepositoryImageScanningConfigurationArrayOutput struct{ *pulumi.OutputState }

func (GetRepositoryImageScanningConfigurationArrayOutput) ElementType added in v3.1.0 

func (GetRepositoryImageScanningConfigurationArrayOutput) ElementType() reflect.Type

func (GetRepositoryImageScanningConfigurationArrayOutput) Index added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationArrayOutput) Index(i pulumi.IntInput) GetRepositoryImageScanningConfigurationOutput

func (GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutput added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutput() GetRepositoryImageScanningConfigurationArrayOutput

func (GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationArrayOutput) ToGetRepositoryImageScanningConfigurationArrayOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationArrayOutput

type GetRepositoryImageScanningConfigurationInput added in v3.1.0 

type GetRepositoryImageScanningConfigurationInput interface {
	pulumi.Input

	ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput
	ToGetRepositoryImageScanningConfigurationOutputWithContext(context.Context) GetRepositoryImageScanningConfigurationOutput
}

GetRepositoryImageScanningConfigurationInput is an input type that accepts GetRepositoryImageScanningConfigurationArgs and GetRepositoryImageScanningConfigurationOutput values. You can construct a concrete instance of `GetRepositoryImageScanningConfigurationInput` via: 

GetRepositoryImageScanningConfigurationArgs{...}

type GetRepositoryImageScanningConfigurationOutput added in v3.1.0 

type GetRepositoryImageScanningConfigurationOutput struct{ *pulumi.OutputState }

func (GetRepositoryImageScanningConfigurationOutput) ElementType added in v3.1.0 

func (GetRepositoryImageScanningConfigurationOutput) ElementType() reflect.Type

func (GetRepositoryImageScanningConfigurationOutput) ScanOnPush added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationOutput) ScanOnPush() pulumi.BoolOutput

Indicates whether images are scanned after being pushed to the repository.

func (GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutput added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutput() GetRepositoryImageScanningConfigurationOutput

func (GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutputWithContext added in v3.1.0 

func (o GetRepositoryImageScanningConfigurationOutput) ToGetRepositoryImageScanningConfigurationOutputWithContext(ctx context.Context) GetRepositoryImageScanningConfigurationOutput

type LifecyclePolicy 

type LifecyclePolicy struct {
	pulumi.CustomResourceState

	// The policy document. This is a JSON formatted string. See more details about [Policy Parameters](http://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html#lifecycle_policy_parameters) in the official AWS docs.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// The registry ID where the repository was created.
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
	// Name of the repository to apply the policy.
	Repository pulumi.StringOutput `pulumi:"repository"`
}

Manages an ECR repository lifecycle policy.

> **NOTE:** Only one `ecr.LifecyclePolicy` resource can be used with the same ECR repository. To apply multiple rules, they must be combined in the `policy` JSON.

> **NOTE:** The AWS ECR API seems to reorder rules based on `rulePriority`. If you define multiple rules that are not sorted in ascending `rulePriority` order in the this provider code, the resource will be flagged for recreation every deployment.

## Example Usage ### Policy on untagged image

```go package main

import ( 

"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := ecr.NewRepository(ctx, "foo", nil)
		if err != nil {
			return err
		}
		_, err = ecr.NewLifecyclePolicy(ctx, "foopolicy", &ecr.LifecyclePolicyArgs{
			Repository: foo.Name,
			Policy:     pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"rules\": [\n", "        {\n", "            \"rulePriority\": 1,\n", "            \"description\": \"Expire images older than 14 days\",\n", "            \"selection\": {\n", "                \"tagStatus\": \"untagged\",\n", "                \"countType\": \"sinceImagePushed\",\n", "                \"countUnit\": \"days\",\n", "                \"countNumber\": 14\n", "            },\n", "            \"action\": {\n", "                \"type\": \"expire\"\n", "            }\n", "        }\n", "    ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Policy on tagged image

```go package main

import ( 

"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := ecr.NewRepository(ctx, "foo", nil)
		if err != nil {
			return err
		}
		_, err = ecr.NewLifecyclePolicy(ctx, "foopolicy", &ecr.LifecyclePolicyArgs{
			Repository: foo.Name,
			Policy:     pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"rules\": [\n", "        {\n", "            \"rulePriority\": 1,\n", "            \"description\": \"Keep last 30 images\",\n", "            \"selection\": {\n", "                \"tagStatus\": \"tagged\",\n", "                \"tagPrefixList\": [\"v\"],\n", "                \"countType\": \"imageCountMoreThan\",\n", "                \"countNumber\": 30\n", "            },\n", "            \"action\": {\n", "                \"type\": \"expire\"\n", "            }\n", "        }\n", "    ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ECR Lifecycle Policy can be imported using the name of the repository, e.g.

```sh 

$ pulumi import aws:ecr/lifecyclePolicy:LifecyclePolicy example tf-example

```

func GetLifecyclePolicy 

func GetLifecyclePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LifecyclePolicyState, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

GetLifecyclePolicy gets an existing LifecyclePolicy 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 NewLifecyclePolicy 

func NewLifecyclePolicy(ctx *pulumi.Context,
	name string, args *LifecyclePolicyArgs, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

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

func (*LifecyclePolicy) ElementType added in v3.13.0 

func (*LifecyclePolicy) ElementType() reflect.Type

func (*LifecyclePolicy) ToLifecyclePolicyOutput added in v3.13.0 

func (i *LifecyclePolicy) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyOutputWithContext added in v3.13.0 

func (i *LifecyclePolicy) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyPtrOutput added in v3.25.0 

func (i *LifecyclePolicy) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (*LifecyclePolicy) ToLifecyclePolicyPtrOutputWithContext added in v3.25.0 

func (i *LifecyclePolicy) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyArgs 

type LifecyclePolicyArgs struct {
	// The policy document. This is a JSON formatted string. See more details about [Policy Parameters](http://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html#lifecycle_policy_parameters) in the official AWS docs.
	Policy pulumi.Input
	// Name of the repository to apply the policy.
	Repository pulumi.StringInput
}

The set of arguments for constructing a LifecyclePolicy resource.

func (LifecyclePolicyArgs) ElementType 

func (LifecyclePolicyArgs) ElementType() reflect.Type

type LifecyclePolicyArray added in v3.25.0 

type LifecyclePolicyArray []LifecyclePolicyInput

func (LifecyclePolicyArray) ElementType added in v3.25.0 

func (LifecyclePolicyArray) ElementType() reflect.Type

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutput added in v3.25.0 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext added in v3.25.0 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyArrayInput added in v3.25.0 

type LifecyclePolicyArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput
	ToLifecyclePolicyArrayOutputWithContext(context.Context) LifecyclePolicyArrayOutput
}

LifecyclePolicyArrayInput is an input type that accepts LifecyclePolicyArray and LifecyclePolicyArrayOutput values. You can construct a concrete instance of `LifecyclePolicyArrayInput` via: 

LifecyclePolicyArray{ LifecyclePolicyArgs{...} }

type LifecyclePolicyArrayOutput added in v3.25.0 

type LifecyclePolicyArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyArrayOutput) ElementType added in v3.25.0 

func (LifecyclePolicyArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyArrayOutput) Index added in v3.25.0 

func (o LifecyclePolicyArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput added in v3.25.0 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext added in v3.25.0 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyInput added in v3.13.0 

type LifecyclePolicyInput interface {
	pulumi.Input

	ToLifecyclePolicyOutput() LifecyclePolicyOutput
	ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput
}

type LifecyclePolicyMap added in v3.25.0 

type LifecyclePolicyMap map[string]LifecyclePolicyInput

func (LifecyclePolicyMap) ElementType added in v3.25.0 

func (LifecyclePolicyMap) ElementType() reflect.Type

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutput added in v3.25.0 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext added in v3.25.0 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyMapInput added in v3.25.0 

type LifecyclePolicyMapInput interface {
	pulumi.Input

	ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput
	ToLifecyclePolicyMapOutputWithContext(context.Context) LifecyclePolicyMapOutput
}

LifecyclePolicyMapInput is an input type that accepts LifecyclePolicyMap and LifecyclePolicyMapOutput values. You can construct a concrete instance of `LifecyclePolicyMapInput` via: 

LifecyclePolicyMap{ "key": LifecyclePolicyArgs{...} }

type LifecyclePolicyMapOutput added in v3.25.0 

type LifecyclePolicyMapOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyMapOutput) ElementType added in v3.25.0 

func (LifecyclePolicyMapOutput) ElementType() reflect.Type

func (LifecyclePolicyMapOutput) MapIndex added in v3.25.0 

func (o LifecyclePolicyMapOutput) MapIndex(k pulumi.StringInput) LifecyclePolicyOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput added in v3.25.0 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext added in v3.25.0 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyOutput added in v3.13.0 

type LifecyclePolicyOutput struct {
	*pulumi.OutputState
}

func (LifecyclePolicyOutput) ElementType added in v3.13.0 

func (LifecyclePolicyOutput) ElementType() reflect.Type

func (LifecyclePolicyOutput) ToLifecyclePolicyOutput added in v3.13.0 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext added in v3.13.0 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyPtrOutput added in v3.25.0 

func (o LifecyclePolicyOutput) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyPtrOutputWithContext added in v3.25.0 

func (o LifecyclePolicyOutput) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyPtrInput added in v3.25.0 

type LifecyclePolicyPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput
	ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput
}

type LifecyclePolicyPtrOutput added in v3.25.0 

type LifecyclePolicyPtrOutput struct {
	*pulumi.OutputState
}

func (LifecyclePolicyPtrOutput) ElementType added in v3.25.0 

func (LifecyclePolicyPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutput added in v3.25.0 

func (o LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutputWithContext added in v3.25.0 

func (o LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyState 

type LifecyclePolicyState struct {
	// The policy document. This is a JSON formatted string. See more details about [Policy Parameters](http://docs.aws.amazon.com/AmazonECR/latest/userguide/LifecyclePolicies.html#lifecycle_policy_parameters) in the official AWS docs.
	Policy pulumi.StringPtrInput
	// The registry ID where the repository was created.
	RegistryId pulumi.StringPtrInput
	// Name of the repository to apply the policy.
	Repository pulumi.StringPtrInput
}

func (LifecyclePolicyState) ElementType 

func (LifecyclePolicyState) ElementType() reflect.Type

type LookupRepositoryArgs 

type LookupRepositoryArgs struct {
	// The name of the ECR Repository.
	Name string `pulumi:"name"`
	// The registry ID where the repository was created.
	RegistryId *string `pulumi:"registryId"`
	// A map of tags assigned to the resource.
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getRepository.

type LookupRepositoryResult 

type LookupRepositoryResult struct {
	// Full ARN of the repository.
	Arn string `pulumi:"arn"`
	// Encryption configuration for the repository. See Encryption Configuration below.
	EncryptionConfigurations []GetRepositoryEncryptionConfiguration `pulumi:"encryptionConfigurations"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Configuration block that defines image scanning configuration for the repository. See Image Scanning Configuration below.
	ImageScanningConfigurations []GetRepositoryImageScanningConfiguration `pulumi:"imageScanningConfigurations"`
	// The tag mutability setting for the repository.
	ImageTagMutability string `pulumi:"imageTagMutability"`
	Name               string `pulumi:"name"`
	RegistryId         string `pulumi:"registryId"`
	// The URL of the repository (in the form `aws_account_id.dkr.ecr.region.amazonaws.com/repositoryName`).
	RepositoryUrl string `pulumi:"repositoryUrl"`
	// A map of tags assigned to the resource.
	Tags map[string]string `pulumi:"tags"`
}

A collection of values returned by getRepository.

func LookupRepository 

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

The ECR Repository data source allows the ARN, Repository URI and Registry ID to be retrieved for an ECR repository.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.LookupRepository(ctx, &ecr.LookupRepositoryArgs{
			Name: "ecr-repository",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type RegistryPolicy added in v3.37.0 

type RegistryPolicy struct {
	pulumi.CustomResourceState

	Policy pulumi.StringOutput `pulumi:"policy"`
	// The registry ID where the registry was created.
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
}

Provides an Elastic Container Registry Policy.

## Example Usage

```go package main

import ( 

"encoding/json"
"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		currentCallerIdentity, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		currentRegion, err := aws.GetRegion(ctx, nil, nil)
		if err != nil {
			return err
		}
		currentPartition, err := aws.GetPartition(ctx, nil, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Sid":    "testpolicy",
					"Effect": "Allow",
					"Principal": map[string]interface{}{
						"AWS": fmt.Sprintf("%v%v%v%v%v", "arn:", currentPartition.Partition, ":iam::", currentCallerIdentity.AccountId, ":root"),
					},
					"Action": []string{
						"ecr:ReplicateImage",
					},
					"Resource": []string{
						fmt.Sprintf("%v%v%v%v%v%v%v", "arn:", currentPartition.Partition, ":ecr:", currentRegion.Name, ":", currentCallerIdentity.AccountId, ":repository/*"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = ecr.NewRegistryPolicy(ctx, "example", &ecr.RegistryPolicyArgs{
			Policy: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ECR Registry Policy can be imported using the registry id, e.g.

```sh 

$ pulumi import aws:ecr/registryPolicy:RegistryPolicy example 123456789012

```

func GetRegistryPolicy added in v3.37.0 

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 added in v3.37.0 

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 added in v3.37.0 

func (*RegistryPolicy) ElementType() reflect.Type

func (*RegistryPolicy) ToRegistryPolicyOutput added in v3.37.0 

func (i *RegistryPolicy) ToRegistryPolicyOutput() RegistryPolicyOutput

func (*RegistryPolicy) ToRegistryPolicyOutputWithContext added in v3.37.0 

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

func (*RegistryPolicy) ToRegistryPolicyPtrOutput added in v3.37.0 

func (i *RegistryPolicy) ToRegistryPolicyPtrOutput() RegistryPolicyPtrOutput

func (*RegistryPolicy) ToRegistryPolicyPtrOutputWithContext added in v3.37.0 

func (i *RegistryPolicy) ToRegistryPolicyPtrOutputWithContext(ctx context.Context) RegistryPolicyPtrOutput

type RegistryPolicyArgs added in v3.37.0 

type RegistryPolicyArgs struct {
	Policy pulumi.StringInput
}

The set of arguments for constructing a RegistryPolicy resource.

func (RegistryPolicyArgs) ElementType added in v3.37.0 

func (RegistryPolicyArgs) ElementType() reflect.Type

type RegistryPolicyArray added in v3.37.0 

type RegistryPolicyArray []RegistryPolicyInput

func (RegistryPolicyArray) ElementType added in v3.37.0 

func (RegistryPolicyArray) ElementType() reflect.Type

func (RegistryPolicyArray) ToRegistryPolicyArrayOutput added in v3.37.0 

func (i RegistryPolicyArray) ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput

func (RegistryPolicyArray) ToRegistryPolicyArrayOutputWithContext added in v3.37.0 

func (i RegistryPolicyArray) ToRegistryPolicyArrayOutputWithContext(ctx context.Context) RegistryPolicyArrayOutput

type RegistryPolicyArrayInput added in v3.37.0 

type RegistryPolicyArrayInput interface {
	pulumi.Input

	ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput
	ToRegistryPolicyArrayOutputWithContext(context.Context) RegistryPolicyArrayOutput
}

RegistryPolicyArrayInput is an input type that accepts RegistryPolicyArray and RegistryPolicyArrayOutput values. You can construct a concrete instance of `RegistryPolicyArrayInput` via: 

RegistryPolicyArray{ RegistryPolicyArgs{...} }

type RegistryPolicyArrayOutput added in v3.37.0 

type RegistryPolicyArrayOutput struct{ *pulumi.OutputState }

func (RegistryPolicyArrayOutput) ElementType added in v3.37.0 

func (RegistryPolicyArrayOutput) ElementType() reflect.Type

func (RegistryPolicyArrayOutput) Index added in v3.37.0 

func (o RegistryPolicyArrayOutput) Index(i pulumi.IntInput) RegistryPolicyOutput

func (RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutput added in v3.37.0 

func (o RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput

func (RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutputWithContext added in v3.37.0 

func (o RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutputWithContext(ctx context.Context) RegistryPolicyArrayOutput

type RegistryPolicyInput added in v3.37.0 

type RegistryPolicyInput interface {
	pulumi.Input

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

type RegistryPolicyMap added in v3.37.0 

type RegistryPolicyMap map[string]RegistryPolicyInput

func (RegistryPolicyMap) ElementType added in v3.37.0 

func (RegistryPolicyMap) ElementType() reflect.Type

func (RegistryPolicyMap) ToRegistryPolicyMapOutput added in v3.37.0 

func (i RegistryPolicyMap) ToRegistryPolicyMapOutput() RegistryPolicyMapOutput

func (RegistryPolicyMap) ToRegistryPolicyMapOutputWithContext added in v3.37.0 

func (i RegistryPolicyMap) ToRegistryPolicyMapOutputWithContext(ctx context.Context) RegistryPolicyMapOutput

type RegistryPolicyMapInput added in v3.37.0 

type RegistryPolicyMapInput interface {
	pulumi.Input

	ToRegistryPolicyMapOutput() RegistryPolicyMapOutput
	ToRegistryPolicyMapOutputWithContext(context.Context) RegistryPolicyMapOutput
}

RegistryPolicyMapInput is an input type that accepts RegistryPolicyMap and RegistryPolicyMapOutput values. You can construct a concrete instance of `RegistryPolicyMapInput` via: 

RegistryPolicyMap{ "key": RegistryPolicyArgs{...} }

type RegistryPolicyMapOutput added in v3.37.0 

type RegistryPolicyMapOutput struct{ *pulumi.OutputState }

func (RegistryPolicyMapOutput) ElementType added in v3.37.0 

func (RegistryPolicyMapOutput) ElementType() reflect.Type

func (RegistryPolicyMapOutput) MapIndex added in v3.37.0 

func (o RegistryPolicyMapOutput) MapIndex(k pulumi.StringInput) RegistryPolicyOutput

func (RegistryPolicyMapOutput) ToRegistryPolicyMapOutput added in v3.37.0 

func (o RegistryPolicyMapOutput) ToRegistryPolicyMapOutput() RegistryPolicyMapOutput

func (RegistryPolicyMapOutput) ToRegistryPolicyMapOutputWithContext added in v3.37.0 

func (o RegistryPolicyMapOutput) ToRegistryPolicyMapOutputWithContext(ctx context.Context) RegistryPolicyMapOutput

type RegistryPolicyOutput added in v3.37.0 

type RegistryPolicyOutput struct {
	*pulumi.OutputState
}

func (RegistryPolicyOutput) ElementType added in v3.37.0 

func (RegistryPolicyOutput) ElementType() reflect.Type

func (RegistryPolicyOutput) ToRegistryPolicyOutput added in v3.37.0 

func (o RegistryPolicyOutput) ToRegistryPolicyOutput() RegistryPolicyOutput

func (RegistryPolicyOutput) ToRegistryPolicyOutputWithContext added in v3.37.0 

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

func (RegistryPolicyOutput) ToRegistryPolicyPtrOutput added in v3.37.0 

func (o RegistryPolicyOutput) ToRegistryPolicyPtrOutput() RegistryPolicyPtrOutput

func (RegistryPolicyOutput) ToRegistryPolicyPtrOutputWithContext added in v3.37.0 

func (o RegistryPolicyOutput) ToRegistryPolicyPtrOutputWithContext(ctx context.Context) RegistryPolicyPtrOutput

type RegistryPolicyPtrInput added in v3.37.0 

type RegistryPolicyPtrInput interface {
	pulumi.Input

	ToRegistryPolicyPtrOutput() RegistryPolicyPtrOutput
	ToRegistryPolicyPtrOutputWithContext(ctx context.Context) RegistryPolicyPtrOutput
}

type RegistryPolicyPtrOutput added in v3.37.0 

type RegistryPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (RegistryPolicyPtrOutput) ElementType added in v3.37.0 

func (RegistryPolicyPtrOutput) ElementType() reflect.Type

func (RegistryPolicyPtrOutput) ToRegistryPolicyPtrOutput added in v3.37.0 

func (o RegistryPolicyPtrOutput) ToRegistryPolicyPtrOutput() RegistryPolicyPtrOutput

func (RegistryPolicyPtrOutput) ToRegistryPolicyPtrOutputWithContext added in v3.37.0 

func (o RegistryPolicyPtrOutput) ToRegistryPolicyPtrOutputWithContext(ctx context.Context) RegistryPolicyPtrOutput

type RegistryPolicyState added in v3.37.0 

type RegistryPolicyState struct {
	Policy pulumi.StringPtrInput
	// The registry ID where the registry was created.
	RegistryId pulumi.StringPtrInput
}

func (RegistryPolicyState) ElementType added in v3.37.0 

func (RegistryPolicyState) ElementType() reflect.Type

type ReplicationConfiguration added in v3.37.0 

type ReplicationConfiguration struct {
	pulumi.CustomResourceState

	// The account ID of the destination registry to replicate to.
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
	// Replication configuration for a registry. See Replication Configuration.
	ReplicationConfiguration ReplicationConfigurationReplicationConfigurationPtrOutput `pulumi:"replicationConfiguration"`
}

Provides an Elastic Container Registry Replication Configuration.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleRegions, err := aws.GetRegions(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = ecr.NewReplicationConfiguration(ctx, "exampleReplicationConfiguration", &ecr.ReplicationConfigurationArgs{
			ReplicationConfiguration: &ecr.ReplicationConfigurationReplicationConfigurationArgs{
				Rule: &ecr.ReplicationConfigurationReplicationConfigurationRuleArgs{
					Destinations: ecr.ReplicationConfigurationReplicationConfigurationRuleDestinationArray{
						&ecr.ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{
							Region:     pulumi.String(exampleRegions.Names[0]),
							RegistryId: pulumi.String(current.AccountId),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ECR Replication Configuration can be imported using the `registry_id`, e.g.

```sh 

$ pulumi import aws:ecr/replicationConfiguration:ReplicationConfiguration service 012345678912

```

func GetReplicationConfiguration added in v3.37.0 

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 added in v3.37.0 

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 added in v3.37.0 

func (*ReplicationConfiguration) ElementType() reflect.Type

func (*ReplicationConfiguration) ToReplicationConfigurationOutput added in v3.37.0 

func (i *ReplicationConfiguration) ToReplicationConfigurationOutput() ReplicationConfigurationOutput

func (*ReplicationConfiguration) ToReplicationConfigurationOutputWithContext added in v3.37.0 

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

func (*ReplicationConfiguration) ToReplicationConfigurationPtrOutput added in v3.37.0 

func (i *ReplicationConfiguration) ToReplicationConfigurationPtrOutput() ReplicationConfigurationPtrOutput

func (*ReplicationConfiguration) ToReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (i *ReplicationConfiguration) ToReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationPtrOutput

type ReplicationConfigurationArgs added in v3.37.0 

type ReplicationConfigurationArgs struct {
	// Replication configuration for a registry. See Replication Configuration.
	ReplicationConfiguration ReplicationConfigurationReplicationConfigurationPtrInput
}

The set of arguments for constructing a ReplicationConfiguration resource.

func (ReplicationConfigurationArgs) ElementType added in v3.37.0 

func (ReplicationConfigurationArgs) ElementType() reflect.Type

type ReplicationConfigurationArray added in v3.37.0 

type ReplicationConfigurationArray []ReplicationConfigurationInput

func (ReplicationConfigurationArray) ElementType added in v3.37.0 

func (ReplicationConfigurationArray) ElementType() reflect.Type

func (ReplicationConfigurationArray) ToReplicationConfigurationArrayOutput added in v3.37.0 

func (i ReplicationConfigurationArray) ToReplicationConfigurationArrayOutput() ReplicationConfigurationArrayOutput

func (ReplicationConfigurationArray) ToReplicationConfigurationArrayOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationArray) ToReplicationConfigurationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationArrayOutput

type ReplicationConfigurationArrayInput added in v3.37.0 

type ReplicationConfigurationArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationArrayOutput() ReplicationConfigurationArrayOutput
	ToReplicationConfigurationArrayOutputWithContext(context.Context) ReplicationConfigurationArrayOutput
}

ReplicationConfigurationArrayInput is an input type that accepts ReplicationConfigurationArray and ReplicationConfigurationArrayOutput values. You can construct a concrete instance of `ReplicationConfigurationArrayInput` via: 

ReplicationConfigurationArray{ ReplicationConfigurationArgs{...} }

type ReplicationConfigurationArrayOutput added in v3.37.0 

type ReplicationConfigurationArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationArrayOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationArrayOutput) ElementType() reflect.Type

func (ReplicationConfigurationArrayOutput) Index added in v3.37.0 

func (o ReplicationConfigurationArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationOutput

func (ReplicationConfigurationArrayOutput) ToReplicationConfigurationArrayOutput added in v3.37.0 

func (o ReplicationConfigurationArrayOutput) ToReplicationConfigurationArrayOutput() ReplicationConfigurationArrayOutput

func (ReplicationConfigurationArrayOutput) ToReplicationConfigurationArrayOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationArrayOutput) ToReplicationConfigurationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationArrayOutput

type ReplicationConfigurationInput added in v3.37.0 

type ReplicationConfigurationInput interface {
	pulumi.Input

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

type ReplicationConfigurationMap added in v3.37.0 

type ReplicationConfigurationMap map[string]ReplicationConfigurationInput

func (ReplicationConfigurationMap) ElementType added in v3.37.0 

func (ReplicationConfigurationMap) ElementType() reflect.Type

func (ReplicationConfigurationMap) ToReplicationConfigurationMapOutput added in v3.37.0 

func (i ReplicationConfigurationMap) ToReplicationConfigurationMapOutput() ReplicationConfigurationMapOutput

func (ReplicationConfigurationMap) ToReplicationConfigurationMapOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationMap) ToReplicationConfigurationMapOutputWithContext(ctx context.Context) ReplicationConfigurationMapOutput

type ReplicationConfigurationMapInput added in v3.37.0 

type ReplicationConfigurationMapInput interface {
	pulumi.Input

	ToReplicationConfigurationMapOutput() ReplicationConfigurationMapOutput
	ToReplicationConfigurationMapOutputWithContext(context.Context) ReplicationConfigurationMapOutput
}

ReplicationConfigurationMapInput is an input type that accepts ReplicationConfigurationMap and ReplicationConfigurationMapOutput values. You can construct a concrete instance of `ReplicationConfigurationMapInput` via: 

ReplicationConfigurationMap{ "key": ReplicationConfigurationArgs{...} }

type ReplicationConfigurationMapOutput added in v3.37.0 

type ReplicationConfigurationMapOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationMapOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationMapOutput) ElementType() reflect.Type

func (ReplicationConfigurationMapOutput) MapIndex added in v3.37.0 

func (o ReplicationConfigurationMapOutput) MapIndex(k pulumi.StringInput) ReplicationConfigurationOutput

func (ReplicationConfigurationMapOutput) ToReplicationConfigurationMapOutput added in v3.37.0 

func (o ReplicationConfigurationMapOutput) ToReplicationConfigurationMapOutput() ReplicationConfigurationMapOutput

func (ReplicationConfigurationMapOutput) ToReplicationConfigurationMapOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationMapOutput) ToReplicationConfigurationMapOutputWithContext(ctx context.Context) ReplicationConfigurationMapOutput

type ReplicationConfigurationOutput added in v3.37.0 

type ReplicationConfigurationOutput struct {
	*pulumi.OutputState
}

func (ReplicationConfigurationOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationOutput) ElementType() reflect.Type

func (ReplicationConfigurationOutput) ToReplicationConfigurationOutput added in v3.37.0 

func (o ReplicationConfigurationOutput) ToReplicationConfigurationOutput() ReplicationConfigurationOutput

func (ReplicationConfigurationOutput) ToReplicationConfigurationOutputWithContext added in v3.37.0 

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

func (ReplicationConfigurationOutput) ToReplicationConfigurationPtrOutput added in v3.37.0 

func (o ReplicationConfigurationOutput) ToReplicationConfigurationPtrOutput() ReplicationConfigurationPtrOutput

func (ReplicationConfigurationOutput) ToReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationOutput) ToReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationPtrOutput

type ReplicationConfigurationPtrInput added in v3.37.0 

type ReplicationConfigurationPtrInput interface {
	pulumi.Input

	ToReplicationConfigurationPtrOutput() ReplicationConfigurationPtrOutput
	ToReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationPtrOutput
}

type ReplicationConfigurationPtrOutput added in v3.37.0 

type ReplicationConfigurationPtrOutput struct {
	*pulumi.OutputState
}

func (ReplicationConfigurationPtrOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationPtrOutput) ElementType() reflect.Type

func (ReplicationConfigurationPtrOutput) ToReplicationConfigurationPtrOutput added in v3.37.0 

func (o ReplicationConfigurationPtrOutput) ToReplicationConfigurationPtrOutput() ReplicationConfigurationPtrOutput

func (ReplicationConfigurationPtrOutput) ToReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationPtrOutput) ToReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationPtrOutput

type ReplicationConfigurationReplicationConfiguration added in v3.37.0 

type ReplicationConfigurationReplicationConfiguration struct {
	// The replication rules for a replication configuration. See Rule.
	Rule ReplicationConfigurationReplicationConfigurationRule `pulumi:"rule"`
}

type ReplicationConfigurationReplicationConfigurationArgs added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationArgs struct {
	// The replication rules for a replication configuration. See Rule.
	Rule ReplicationConfigurationReplicationConfigurationRuleInput `pulumi:"rule"`
}

func (ReplicationConfigurationReplicationConfigurationArgs) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationArgs) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput

func (ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationOutput

func (ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput

func (ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationArgs) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput

type ReplicationConfigurationReplicationConfigurationInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput
	ToReplicationConfigurationReplicationConfigurationOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationOutput
}

ReplicationConfigurationReplicationConfigurationInput is an input type that accepts ReplicationConfigurationReplicationConfigurationArgs and ReplicationConfigurationReplicationConfigurationOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationInput` via: 

ReplicationConfigurationReplicationConfigurationArgs{...}

type ReplicationConfigurationReplicationConfigurationOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationOutput) Rule added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationOutput) Rule() ReplicationConfigurationReplicationConfigurationRuleOutput

The replication rules for a replication configuration. See Rule.

func (ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutput() ReplicationConfigurationReplicationConfigurationOutput

func (ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationOutput

func (ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput

func (ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput

type ReplicationConfigurationReplicationConfigurationPtrInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationPtrInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput
	ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput
}

ReplicationConfigurationReplicationConfigurationPtrInput is an input type that accepts ReplicationConfigurationReplicationConfigurationArgs, ReplicationConfigurationReplicationConfigurationPtr and ReplicationConfigurationReplicationConfigurationPtrOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationPtrInput` via: 

        ReplicationConfigurationReplicationConfigurationArgs{...}

or:

        nil

func ReplicationConfigurationReplicationConfigurationPtr added in v3.37.0 

func ReplicationConfigurationReplicationConfigurationPtr(v *ReplicationConfigurationReplicationConfigurationArgs) ReplicationConfigurationReplicationConfigurationPtrInput

type ReplicationConfigurationReplicationConfigurationPtrOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationPtrOutput) Elem added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) Elem() ReplicationConfigurationReplicationConfigurationOutput

func (ReplicationConfigurationReplicationConfigurationPtrOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationPtrOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationPtrOutput) Rule added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) Rule() ReplicationConfigurationReplicationConfigurationRulePtrOutput

The replication rules for a replication configuration. See Rule.

func (ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutput() ReplicationConfigurationReplicationConfigurationPtrOutput

func (ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationPtrOutput) ToReplicationConfigurationReplicationConfigurationPtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationPtrOutput

type ReplicationConfigurationReplicationConfigurationRule added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRule struct {
	// the details of a replication destination. See Destination.
	Destinations []ReplicationConfigurationReplicationConfigurationRuleDestination `pulumi:"destinations"`
}

type ReplicationConfigurationReplicationConfigurationRuleArgs added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleArgs struct {
	// the details of a replication destination. See Destination.
	Destinations ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput `pulumi:"destinations"`
}

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRulePtrOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRulePtrOutput() ReplicationConfigurationReplicationConfigurationRulePtrOutput

func (ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleArgs) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRulePtrOutput

type ReplicationConfigurationReplicationConfigurationRuleDestination added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestination struct {
	// A Region to replicate to.
	Region string `pulumi:"region"`
	// The account ID of the destination registry to replicate to.
	RegistryId string `pulumi:"registryId"`
}

type ReplicationConfigurationReplicationConfigurationRuleDestinationArgs added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationArgs struct {
	// A Region to replicate to.
	Region pulumi.StringInput `pulumi:"region"`
	// The account ID of the destination registry to replicate to.
	RegistryId pulumi.StringInput `pulumi:"registryId"`
}

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArgs) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput

type ReplicationConfigurationReplicationConfigurationRuleDestinationArray added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationArray []ReplicationConfigurationReplicationConfigurationRuleDestinationInput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext added in v3.37.0 

func (i ReplicationConfigurationReplicationConfigurationRuleDestinationArray) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput
	ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput
}

ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleDestinationArray and ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleDestinationArrayInput` via: 

ReplicationConfigurationReplicationConfigurationRuleDestinationArray{ ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{...} }

type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) Index added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) Index(i pulumi.IntInput) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

type ReplicationConfigurationReplicationConfigurationRuleDestinationInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput
	ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput
}

ReplicationConfigurationReplicationConfigurationRuleDestinationInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleDestinationArgs and ReplicationConfigurationReplicationConfigurationRuleDestinationOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleDestinationInput` via: 

ReplicationConfigurationReplicationConfigurationRuleDestinationArgs{...}

type ReplicationConfigurationReplicationConfigurationRuleDestinationOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleDestinationOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) Region added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) Region() pulumi.StringOutput

A Region to replicate to.

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) RegistryId added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) RegistryId() pulumi.StringOutput

The account ID of the destination registry to replicate to.

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutput() ReplicationConfigurationReplicationConfigurationRuleDestinationOutput

func (ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleDestinationOutput) ToReplicationConfigurationReplicationConfigurationRuleDestinationOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleDestinationOutput

type ReplicationConfigurationReplicationConfigurationRuleInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput
	ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput
}

ReplicationConfigurationReplicationConfigurationRuleInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleArgs and ReplicationConfigurationReplicationConfigurationRuleOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRuleInput` via: 

ReplicationConfigurationReplicationConfigurationRuleArgs{...}

type ReplicationConfigurationReplicationConfigurationRuleOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRuleOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRuleOutput) Destinations added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) Destinations() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

the details of a replication destination. See Destination.

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutput() ReplicationConfigurationReplicationConfigurationRuleOutput

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRuleOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRuleOutput

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutput() ReplicationConfigurationReplicationConfigurationRulePtrOutput

func (ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRuleOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRulePtrOutput

type ReplicationConfigurationReplicationConfigurationRulePtrInput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRulePtrInput interface {
	pulumi.Input

	ToReplicationConfigurationReplicationConfigurationRulePtrOutput() ReplicationConfigurationReplicationConfigurationRulePtrOutput
	ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext(context.Context) ReplicationConfigurationReplicationConfigurationRulePtrOutput
}

ReplicationConfigurationReplicationConfigurationRulePtrInput is an input type that accepts ReplicationConfigurationReplicationConfigurationRuleArgs, ReplicationConfigurationReplicationConfigurationRulePtr and ReplicationConfigurationReplicationConfigurationRulePtrOutput values. You can construct a concrete instance of `ReplicationConfigurationReplicationConfigurationRulePtrInput` via: 

        ReplicationConfigurationReplicationConfigurationRuleArgs{...}

or:

        nil

func ReplicationConfigurationReplicationConfigurationRulePtr added in v3.37.0 

func ReplicationConfigurationReplicationConfigurationRulePtr(v *ReplicationConfigurationReplicationConfigurationRuleArgs) ReplicationConfigurationReplicationConfigurationRulePtrInput

type ReplicationConfigurationReplicationConfigurationRulePtrOutput added in v3.37.0 

type ReplicationConfigurationReplicationConfigurationRulePtrOutput struct{ *pulumi.OutputState }

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) Destinations added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRulePtrOutput) Destinations() ReplicationConfigurationReplicationConfigurationRuleDestinationArrayOutput

the details of a replication destination. See Destination.

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) Elem added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRulePtrOutput) Elem() ReplicationConfigurationReplicationConfigurationRuleOutput

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) ElementType added in v3.37.0 

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) ElementType() reflect.Type

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutput added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRulePtrOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutput() ReplicationConfigurationReplicationConfigurationRulePtrOutput

func (ReplicationConfigurationReplicationConfigurationRulePtrOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext added in v3.37.0 

func (o ReplicationConfigurationReplicationConfigurationRulePtrOutput) ToReplicationConfigurationReplicationConfigurationRulePtrOutputWithContext(ctx context.Context) ReplicationConfigurationReplicationConfigurationRulePtrOutput

type ReplicationConfigurationState added in v3.37.0 

type ReplicationConfigurationState struct {
	// The account ID of the destination registry to replicate to.
	RegistryId pulumi.StringPtrInput
	// Replication configuration for a registry. See Replication Configuration.
	ReplicationConfiguration ReplicationConfigurationReplicationConfigurationPtrInput
}

func (ReplicationConfigurationState) ElementType added in v3.37.0 

func (ReplicationConfigurationState) ElementType() reflect.Type

type Repository 

type Repository struct {
	pulumi.CustomResourceState

	// Full ARN of the repository.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// Encryption configuration for the repository. See below for schema.
	EncryptionConfigurations RepositoryEncryptionConfigurationArrayOutput `pulumi:"encryptionConfigurations"`
	// Configuration block that defines image scanning configuration for the repository. By default, image scanning must be manually triggered. See the [ECR User Guide](https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html) for more information about image scanning.
	ImageScanningConfiguration RepositoryImageScanningConfigurationPtrOutput `pulumi:"imageScanningConfiguration"`
	// The tag mutability setting for the repository. Must be one of: `MUTABLE` or `IMMUTABLE`. Defaults to `MUTABLE`.
	ImageTagMutability pulumi.StringPtrOutput `pulumi:"imageTagMutability"`
	// Name of the repository.
	Name pulumi.StringOutput `pulumi:"name"`
	// The registry ID where the repository was created.
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
	// The URL of the repository (in the form `aws_account_id.dkr.ecr.region.amazonaws.com/repositoryName`).
	RepositoryUrl pulumi.StringOutput `pulumi:"repositoryUrl"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides an Elastic Container Registry Repository.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecr.NewRepository(ctx, "foo", &ecr.RepositoryArgs{
			ImageScanningConfiguration: &ecr.RepositoryImageScanningConfigurationArgs{
				ScanOnPush: pulumi.Bool(true),
			},
			ImageTagMutability: pulumi.String("MUTABLE"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ECR Repositories can be imported using the `name`, e.g.

```sh 

$ pulumi import aws:ecr/repository:Repository service test-service

```

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 added in v3.13.0 

func (*Repository) ElementType() reflect.Type

func (*Repository) ToRepositoryOutput added in v3.13.0 

func (i *Repository) ToRepositoryOutput() RepositoryOutput

func (*Repository) ToRepositoryOutputWithContext added in v3.13.0 

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

func (*Repository) ToRepositoryPtrOutput added in v3.25.0 

func (i *Repository) ToRepositoryPtrOutput() RepositoryPtrOutput

func (*Repository) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (i *Repository) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryArgs 

type RepositoryArgs struct {
	// Encryption configuration for the repository. See below for schema.
	EncryptionConfigurations RepositoryEncryptionConfigurationArrayInput
	// Configuration block that defines image scanning configuration for the repository. By default, image scanning must be manually triggered. See the [ECR User Guide](https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html) for more information about image scanning.
	ImageScanningConfiguration RepositoryImageScanningConfigurationPtrInput
	// The tag mutability setting for the repository. Must be one of: `MUTABLE` or `IMMUTABLE`. Defaults to `MUTABLE`.
	ImageTagMutability pulumi.StringPtrInput
	// Name of the repository.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Repository resource.

func (RepositoryArgs) ElementType 

func (RepositoryArgs) ElementType() reflect.Type

type RepositoryArray added in v3.25.0 

type RepositoryArray []RepositoryInput

func (RepositoryArray) ElementType added in v3.25.0 

func (RepositoryArray) ElementType() reflect.Type

func (RepositoryArray) ToRepositoryArrayOutput added in v3.25.0 

func (i RepositoryArray) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArray) ToRepositoryArrayOutputWithContext added in v3.25.0 

func (i RepositoryArray) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryArrayInput added in v3.25.0 

type RepositoryArrayInput interface {
	pulumi.Input

	ToRepositoryArrayOutput() RepositoryArrayOutput
	ToRepositoryArrayOutputWithContext(context.Context) RepositoryArrayOutput
}

RepositoryArrayInput is an input type that accepts RepositoryArray and RepositoryArrayOutput values. You can construct a concrete instance of `RepositoryArrayInput` via: 

RepositoryArray{ RepositoryArgs{...} }

type RepositoryArrayOutput added in v3.25.0 

type RepositoryArrayOutput struct{ *pulumi.OutputState }

func (RepositoryArrayOutput) ElementType added in v3.25.0 

func (RepositoryArrayOutput) ElementType() reflect.Type

func (RepositoryArrayOutput) Index added in v3.25.0 

func (o RepositoryArrayOutput) Index(i pulumi.IntInput) RepositoryOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutput added in v3.25.0 

func (o RepositoryArrayOutput) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutputWithContext added in v3.25.0 

func (o RepositoryArrayOutput) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryEncryptionConfiguration added in v3.1.0 

type RepositoryEncryptionConfiguration struct {
	// The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.
	EncryptionType *string `pulumi:"encryptionType"`
	// The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.
	KmsKey *string `pulumi:"kmsKey"`
}

type RepositoryEncryptionConfigurationArgs added in v3.1.0 

type RepositoryEncryptionConfigurationArgs struct {
	// The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.
	EncryptionType pulumi.StringPtrInput `pulumi:"encryptionType"`
	// The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.
	KmsKey pulumi.StringPtrInput `pulumi:"kmsKey"`
}

func (RepositoryEncryptionConfigurationArgs) ElementType added in v3.1.0 

func (RepositoryEncryptionConfigurationArgs) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutput added in v3.1.0 

func (i RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationArgs) ToRepositoryEncryptionConfigurationOutputWithContext added in v3.1.0 

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

type RepositoryEncryptionConfigurationArray added in v3.1.0 

type RepositoryEncryptionConfigurationArray []RepositoryEncryptionConfigurationInput

func (RepositoryEncryptionConfigurationArray) ElementType added in v3.1.0 

func (RepositoryEncryptionConfigurationArray) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

func (i RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput

func (RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutputWithContext added in v3.1.0 

func (i RepositoryEncryptionConfigurationArray) ToRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationArrayOutput

type RepositoryEncryptionConfigurationArrayInput added in v3.1.0 

type RepositoryEncryptionConfigurationArrayInput interface {
	pulumi.Input

	ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput
	ToRepositoryEncryptionConfigurationArrayOutputWithContext(context.Context) RepositoryEncryptionConfigurationArrayOutput
}

RepositoryEncryptionConfigurationArrayInput is an input type that accepts RepositoryEncryptionConfigurationArray and RepositoryEncryptionConfigurationArrayOutput values. You can construct a concrete instance of `RepositoryEncryptionConfigurationArrayInput` via: 

RepositoryEncryptionConfigurationArray{ RepositoryEncryptionConfigurationArgs{...} }

type RepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

type RepositoryEncryptionConfigurationArrayOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionConfigurationArrayOutput) ElementType added in v3.1.0 

func (RepositoryEncryptionConfigurationArrayOutput) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationArrayOutput) Index added in v3.1.0 

func (o RepositoryEncryptionConfigurationArrayOutput) Index(i pulumi.IntInput) RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutput added in v3.1.0 

func (o RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutput() RepositoryEncryptionConfigurationArrayOutput

func (RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutputWithContext added in v3.1.0 

func (o RepositoryEncryptionConfigurationArrayOutput) ToRepositoryEncryptionConfigurationArrayOutputWithContext(ctx context.Context) RepositoryEncryptionConfigurationArrayOutput

type RepositoryEncryptionConfigurationInput added in v3.1.0 

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 added in v3.1.0 

type RepositoryEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (RepositoryEncryptionConfigurationOutput) ElementType added in v3.1.0 

func (RepositoryEncryptionConfigurationOutput) ElementType() reflect.Type

func (RepositoryEncryptionConfigurationOutput) EncryptionType added in v3.1.0 

func (o RepositoryEncryptionConfigurationOutput) EncryptionType() pulumi.StringPtrOutput

The encryption type to use for the repository. Valid values are `AES256` or `KMS`. Defaults to `AES256`.

func (RepositoryEncryptionConfigurationOutput) KmsKey added in v3.1.0 

func (o RepositoryEncryptionConfigurationOutput) KmsKey() pulumi.StringPtrOutput

The ARN of the KMS key to use when `encryptionType` is `KMS`. If not specified, uses the default AWS managed key for ECR.

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutput added in v3.1.0 

func (o RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutput() RepositoryEncryptionConfigurationOutput

func (RepositoryEncryptionConfigurationOutput) ToRepositoryEncryptionConfigurationOutputWithContext added in v3.1.0 

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

type RepositoryImageScanningConfiguration 

type RepositoryImageScanningConfiguration struct {
	// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
	ScanOnPush bool `pulumi:"scanOnPush"`
}

type RepositoryImageScanningConfigurationArgs 

type RepositoryImageScanningConfigurationArgs struct {
	// Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).
	ScanOnPush pulumi.BoolInput `pulumi:"scanOnPush"`
}

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 }

func (RepositoryImageScanningConfigurationOutput) ElementType 

func (RepositoryImageScanningConfigurationOutput) ElementType() reflect.Type

func (RepositoryImageScanningConfigurationOutput) ScanOnPush 

func (o RepositoryImageScanningConfigurationOutput) ScanOnPush() pulumi.BoolOutput

Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).

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

Indicates whether images are scanned after being pushed to the repository (true) or not scanned (false).

func (RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutput 

func (o RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutput() RepositoryImageScanningConfigurationPtrOutput

func (RepositoryImageScanningConfigurationPtrOutput) ToRepositoryImageScanningConfigurationPtrOutputWithContext 

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

type RepositoryInput added in v3.13.0 

type RepositoryInput interface {
	pulumi.Input

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

type RepositoryMap added in v3.25.0 

type RepositoryMap map[string]RepositoryInput

func (RepositoryMap) ElementType added in v3.25.0 

func (RepositoryMap) ElementType() reflect.Type

func (RepositoryMap) ToRepositoryMapOutput added in v3.25.0 

func (i RepositoryMap) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMap) ToRepositoryMapOutputWithContext added in v3.25.0 

func (i RepositoryMap) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryMapInput added in v3.25.0 

type RepositoryMapInput interface {
	pulumi.Input

	ToRepositoryMapOutput() RepositoryMapOutput
	ToRepositoryMapOutputWithContext(context.Context) RepositoryMapOutput
}

RepositoryMapInput is an input type that accepts RepositoryMap and RepositoryMapOutput values. You can construct a concrete instance of `RepositoryMapInput` via: 

RepositoryMap{ "key": RepositoryArgs{...} }

type RepositoryMapOutput added in v3.25.0 

type RepositoryMapOutput struct{ *pulumi.OutputState }

func (RepositoryMapOutput) ElementType added in v3.25.0 

func (RepositoryMapOutput) ElementType() reflect.Type

func (RepositoryMapOutput) MapIndex added in v3.25.0 

func (o RepositoryMapOutput) MapIndex(k pulumi.StringInput) RepositoryOutput

func (RepositoryMapOutput) ToRepositoryMapOutput added in v3.25.0 

func (o RepositoryMapOutput) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMapOutput) ToRepositoryMapOutputWithContext added in v3.25.0 

func (o RepositoryMapOutput) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryOutput added in v3.13.0 

type RepositoryOutput struct {
	*pulumi.OutputState
}

func (RepositoryOutput) ElementType added in v3.13.0 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) ToRepositoryOutput added in v3.13.0 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext added in v3.13.0 

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

func (RepositoryOutput) ToRepositoryPtrOutput added in v3.25.0 

func (o RepositoryOutput) ToRepositoryPtrOutput() RepositoryPtrOutput

func (RepositoryOutput) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (o RepositoryOutput) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryPolicy 

type RepositoryPolicy struct {
	pulumi.CustomResourceState

	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// The registry ID where the repository was created.
	RegistryId pulumi.StringOutput `pulumi:"registryId"`
	// Name of the repository to apply the policy.
	Repository pulumi.StringOutput `pulumi:"repository"`
}

Provides an Elastic Container Registry Repository Policy.

Note that currently only one policy may be applied to a repository.

## Example Usage

```go package main

import ( 

"fmt"

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := ecr.NewRepository(ctx, "foo", nil)
		if err != nil {
			return err
		}
		_, err = ecr.NewRepositoryPolicy(ctx, "foopolicy", &ecr.RepositoryPolicyArgs{
			Repository: foo.Name,
			Policy:     pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2008-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Sid\": \"new policy\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Action\": [\n", "                \"ecr:GetDownloadUrlForLayer\",\n", "                \"ecr:BatchGetImage\",\n", "                \"ecr:BatchCheckLayerAvailability\",\n", "                \"ecr:PutImage\",\n", "                \"ecr:InitiateLayerUpload\",\n", "                \"ecr:UploadLayerPart\",\n", "                \"ecr:CompleteLayerUpload\",\n", "                \"ecr:DescribeRepositories\",\n", "                \"ecr:GetRepositoryPolicy\",\n", "                \"ecr:ListImages\",\n", "                \"ecr:DeleteRepository\",\n", "                \"ecr:BatchDeleteImage\",\n", "                \"ecr:SetRepositoryPolicy\",\n", "                \"ecr:DeleteRepositoryPolicy\"\n", "            ]\n", "        }\n", "    ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ECR Repository Policy can be imported using the repository name, e.g.

```sh 

$ pulumi import aws:ecr/repositoryPolicy:RepositoryPolicy example example

```

func GetRepositoryPolicy 

func GetRepositoryPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryPolicyState, opts ...pulumi.ResourceOption) (*RepositoryPolicy, error)

GetRepositoryPolicy gets an existing RepositoryPolicy 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 NewRepositoryPolicy 

func NewRepositoryPolicy(ctx *pulumi.Context,
	name string, args *RepositoryPolicyArgs, opts ...pulumi.ResourceOption) (*RepositoryPolicy, error)

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

func (*RepositoryPolicy) ElementType added in v3.13.0 

func (*RepositoryPolicy) ElementType() reflect.Type

func (*RepositoryPolicy) ToRepositoryPolicyOutput added in v3.13.0 

func (i *RepositoryPolicy) ToRepositoryPolicyOutput() RepositoryPolicyOutput

func (*RepositoryPolicy) ToRepositoryPolicyOutputWithContext added in v3.13.0 

func (i *RepositoryPolicy) ToRepositoryPolicyOutputWithContext(ctx context.Context) RepositoryPolicyOutput

func (*RepositoryPolicy) ToRepositoryPolicyPtrOutput added in v3.25.0 

func (i *RepositoryPolicy) ToRepositoryPolicyPtrOutput() RepositoryPolicyPtrOutput

func (*RepositoryPolicy) ToRepositoryPolicyPtrOutputWithContext added in v3.25.0 

func (i *RepositoryPolicy) ToRepositoryPolicyPtrOutputWithContext(ctx context.Context) RepositoryPolicyPtrOutput

type RepositoryPolicyArgs 

type RepositoryPolicyArgs struct {
	// The policy document. This is a JSON formatted string.
	Policy pulumi.Input
	// Name of the repository to apply the policy.
	Repository pulumi.StringInput
}

The set of arguments for constructing a RepositoryPolicy resource.

func (RepositoryPolicyArgs) ElementType 

func (RepositoryPolicyArgs) ElementType() reflect.Type

type RepositoryPolicyArray added in v3.25.0 

type RepositoryPolicyArray []RepositoryPolicyInput

func (RepositoryPolicyArray) ElementType added in v3.25.0 

func (RepositoryPolicyArray) ElementType() reflect.Type

func (RepositoryPolicyArray) ToRepositoryPolicyArrayOutput added in v3.25.0 

func (i RepositoryPolicyArray) ToRepositoryPolicyArrayOutput() RepositoryPolicyArrayOutput

func (RepositoryPolicyArray) ToRepositoryPolicyArrayOutputWithContext added in v3.25.0 

func (i RepositoryPolicyArray) ToRepositoryPolicyArrayOutputWithContext(ctx context.Context) RepositoryPolicyArrayOutput

type RepositoryPolicyArrayInput added in v3.25.0 

type RepositoryPolicyArrayInput interface {
	pulumi.Input

	ToRepositoryPolicyArrayOutput() RepositoryPolicyArrayOutput
	ToRepositoryPolicyArrayOutputWithContext(context.Context) RepositoryPolicyArrayOutput
}

RepositoryPolicyArrayInput is an input type that accepts RepositoryPolicyArray and RepositoryPolicyArrayOutput values. You can construct a concrete instance of `RepositoryPolicyArrayInput` via: 

RepositoryPolicyArray{ RepositoryPolicyArgs{...} }

type RepositoryPolicyArrayOutput added in v3.25.0 

type RepositoryPolicyArrayOutput struct{ *pulumi.OutputState }

func (RepositoryPolicyArrayOutput) ElementType added in v3.25.0 

func (RepositoryPolicyArrayOutput) ElementType() reflect.Type

func (RepositoryPolicyArrayOutput) Index added in v3.25.0 

func (o RepositoryPolicyArrayOutput) Index(i pulumi.IntInput) RepositoryPolicyOutput

func (RepositoryPolicyArrayOutput) ToRepositoryPolicyArrayOutput added in v3.25.0 

func (o RepositoryPolicyArrayOutput) ToRepositoryPolicyArrayOutput() RepositoryPolicyArrayOutput

func (RepositoryPolicyArrayOutput) ToRepositoryPolicyArrayOutputWithContext added in v3.25.0 

func (o RepositoryPolicyArrayOutput) ToRepositoryPolicyArrayOutputWithContext(ctx context.Context) RepositoryPolicyArrayOutput

type RepositoryPolicyInput added in v3.13.0 

type RepositoryPolicyInput interface {
	pulumi.Input

	ToRepositoryPolicyOutput() RepositoryPolicyOutput
	ToRepositoryPolicyOutputWithContext(ctx context.Context) RepositoryPolicyOutput
}

type RepositoryPolicyMap added in v3.25.0 

type RepositoryPolicyMap map[string]RepositoryPolicyInput

func (RepositoryPolicyMap) ElementType added in v3.25.0 

func (RepositoryPolicyMap) ElementType() reflect.Type

func (RepositoryPolicyMap) ToRepositoryPolicyMapOutput added in v3.25.0 

func (i RepositoryPolicyMap) ToRepositoryPolicyMapOutput() RepositoryPolicyMapOutput

func (RepositoryPolicyMap) ToRepositoryPolicyMapOutputWithContext added in v3.25.0 

func (i RepositoryPolicyMap) ToRepositoryPolicyMapOutputWithContext(ctx context.Context) RepositoryPolicyMapOutput

type RepositoryPolicyMapInput added in v3.25.0 

type RepositoryPolicyMapInput interface {
	pulumi.Input

	ToRepositoryPolicyMapOutput() RepositoryPolicyMapOutput
	ToRepositoryPolicyMapOutputWithContext(context.Context) RepositoryPolicyMapOutput
}

RepositoryPolicyMapInput is an input type that accepts RepositoryPolicyMap and RepositoryPolicyMapOutput values. You can construct a concrete instance of `RepositoryPolicyMapInput` via: 

RepositoryPolicyMap{ "key": RepositoryPolicyArgs{...} }

type RepositoryPolicyMapOutput added in v3.25.0 

type RepositoryPolicyMapOutput struct{ *pulumi.OutputState }

func (RepositoryPolicyMapOutput) ElementType added in v3.25.0 

func (RepositoryPolicyMapOutput) ElementType() reflect.Type

func (RepositoryPolicyMapOutput) MapIndex added in v3.25.0 

func (o RepositoryPolicyMapOutput) MapIndex(k pulumi.StringInput) RepositoryPolicyOutput

func (RepositoryPolicyMapOutput) ToRepositoryPolicyMapOutput added in v3.25.0 

func (o RepositoryPolicyMapOutput) ToRepositoryPolicyMapOutput() RepositoryPolicyMapOutput

func (RepositoryPolicyMapOutput) ToRepositoryPolicyMapOutputWithContext added in v3.25.0 

func (o RepositoryPolicyMapOutput) ToRepositoryPolicyMapOutputWithContext(ctx context.Context) RepositoryPolicyMapOutput

type RepositoryPolicyOutput added in v3.13.0 

type RepositoryPolicyOutput struct {
	*pulumi.OutputState
}

func (RepositoryPolicyOutput) ElementType added in v3.13.0 

func (RepositoryPolicyOutput) ElementType() reflect.Type

func (RepositoryPolicyOutput) ToRepositoryPolicyOutput added in v3.13.0 

func (o RepositoryPolicyOutput) ToRepositoryPolicyOutput() RepositoryPolicyOutput

func (RepositoryPolicyOutput) ToRepositoryPolicyOutputWithContext added in v3.13.0 

func (o RepositoryPolicyOutput) ToRepositoryPolicyOutputWithContext(ctx context.Context) RepositoryPolicyOutput

func (RepositoryPolicyOutput) ToRepositoryPolicyPtrOutput added in v3.25.0 

func (o RepositoryPolicyOutput) ToRepositoryPolicyPtrOutput() RepositoryPolicyPtrOutput

func (RepositoryPolicyOutput) ToRepositoryPolicyPtrOutputWithContext added in v3.25.0 

func (o RepositoryPolicyOutput) ToRepositoryPolicyPtrOutputWithContext(ctx context.Context) RepositoryPolicyPtrOutput

type RepositoryPolicyPtrInput added in v3.25.0 

type RepositoryPolicyPtrInput interface {
	pulumi.Input

	ToRepositoryPolicyPtrOutput() RepositoryPolicyPtrOutput
	ToRepositoryPolicyPtrOutputWithContext(ctx context.Context) RepositoryPolicyPtrOutput
}

type RepositoryPolicyPtrOutput added in v3.25.0 

type RepositoryPolicyPtrOutput struct {
	*pulumi.OutputState
}

func (RepositoryPolicyPtrOutput) ElementType added in v3.25.0 

func (RepositoryPolicyPtrOutput) ElementType() reflect.Type

func (RepositoryPolicyPtrOutput) ToRepositoryPolicyPtrOutput added in v3.25.0 

func (o RepositoryPolicyPtrOutput) ToRepositoryPolicyPtrOutput() RepositoryPolicyPtrOutput

func (RepositoryPolicyPtrOutput) ToRepositoryPolicyPtrOutputWithContext added in v3.25.0 

func (o RepositoryPolicyPtrOutput) ToRepositoryPolicyPtrOutputWithContext(ctx context.Context) RepositoryPolicyPtrOutput

type RepositoryPolicyState 

type RepositoryPolicyState struct {
	// The policy document. This is a JSON formatted string.
	Policy pulumi.StringPtrInput
	// The registry ID where the repository was created.
	RegistryId pulumi.StringPtrInput
	// Name of the repository to apply the policy.
	Repository pulumi.StringPtrInput
}

func (RepositoryPolicyState) ElementType 

func (RepositoryPolicyState) ElementType() reflect.Type

type RepositoryPtrInput added in v3.25.0 

type RepositoryPtrInput interface {
	pulumi.Input

	ToRepositoryPtrOutput() RepositoryPtrOutput
	ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput
}

type RepositoryPtrOutput added in v3.25.0 

type RepositoryPtrOutput struct {
	*pulumi.OutputState
}

func (RepositoryPtrOutput) ElementType added in v3.25.0 

func (RepositoryPtrOutput) ElementType() reflect.Type

func (RepositoryPtrOutput) ToRepositoryPtrOutput added in v3.25.0 

func (o RepositoryPtrOutput) ToRepositoryPtrOutput() RepositoryPtrOutput

func (RepositoryPtrOutput) ToRepositoryPtrOutputWithContext added in v3.25.0 

func (o RepositoryPtrOutput) ToRepositoryPtrOutputWithContext(ctx context.Context) RepositoryPtrOutput

type RepositoryState 

type RepositoryState struct {
	// Full ARN of the repository.
	Arn pulumi.StringPtrInput
	// Encryption configuration for the repository. See below for schema.
	EncryptionConfigurations RepositoryEncryptionConfigurationArrayInput
	// Configuration block that defines image scanning configuration for the repository. By default, image scanning must be manually triggered. See the [ECR User Guide](https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html) for more information about image scanning.
	ImageScanningConfiguration RepositoryImageScanningConfigurationPtrInput
	// The tag mutability setting for the repository. Must be one of: `MUTABLE` or `IMMUTABLE`. Defaults to `MUTABLE`.
	ImageTagMutability pulumi.StringPtrInput
	// Name of the repository.
	Name pulumi.StringPtrInput
	// The registry ID where the repository was created.
	RegistryId pulumi.StringPtrInput
	// The URL of the repository (in the form `aws_account_id.dkr.ecr.region.amazonaws.com/repositoryName`).
	RepositoryUrl pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (RepositoryState) ElementType 

func (RepositoryState) ElementType() reflect.Type

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.