ecr

package
v2.13.1 Latest Latest
Warning

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

 Go to latest Published: Jul 22, 2020 License: Apache-2.0 Imports: 4 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GetAuthorizationTokenArgs added in v2.10.0 

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 added in v2.10.0 

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 added in v2.10.0 

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/v2/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/v2/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 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/v2/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{
			Policy:     pulumi.String(fmt.Sprintf("%v%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", "\n")),
			Repository: foo.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Policy on tagged image

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v2/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{
			Policy:     pulumi.String(fmt.Sprintf("%v%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", "\n")),
			Repository: foo.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 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"`
	// 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"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// The registry ID where the repository was created.
	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/v2/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 Repository 

type Repository struct {
	pulumi.CustomResourceState

	// Full ARN of the repository.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// 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/v2/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
	})
}

```

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.

type RepositoryArgs 

type RepositoryArgs struct {
	// 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 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 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/v2/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{
			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%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", "\n")),
			Repository: foo.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

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.

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 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 RepositoryState 

type RepositoryState struct {
	// Full ARN of the repository.
	Arn pulumi.StringPtrInput
	// 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.