LifecyclePolicy

Manages an ECR repository lifecycle policy.

NOTE: Only one aws.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

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var foo = new Aws.Ecr.Repository("foo", new Aws.Ecr.RepositoryArgs
        {
        });
        var foopolicy = new Aws.Ecr.LifecyclePolicy("foopolicy", new Aws.Ecr.LifecyclePolicyArgs
        {
            Repository = foo.Name,
            Policy = @"{
    ""rules"": [
        {
            ""rulePriority"": 1,
            ""description"": ""Expire images older than 14 days"",
            ""selection"": {
                ""tagStatus"": ""untagged"",
                ""countType"": ""sinceImagePushed"",
                ""countUnit"": ""days"",
                ""countNumber"": 14
            },
            ""action"": {
                ""type"": ""expire""
            }
        }
    ]
}
",
        });
    }

}
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/ecr"
	"github.com/pulumi/pulumi/sdk/v3/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.Any(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
	})
}
import pulumi
import pulumi_aws as aws

foo = aws.ecr.Repository("foo")
foopolicy = aws.ecr.LifecyclePolicy("foopolicy",
    repository=foo.name,
    policy="""{
    "rules": [
        {
            "rulePriority": 1,
            "description": "Expire images older than 14 days",
            "selection": {
                "tagStatus": "untagged",
                "countType": "sinceImagePushed",
                "countUnit": "days",
                "countNumber": 14
            },
            "action": {
                "type": "expire"
            }
        }
    ]
}
""")
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const foo = new aws.ecr.Repository("foo", {});
const foopolicy = new aws.ecr.LifecyclePolicy("foopolicy", {
    repository: foo.name,
    policy: `{
    "rules": [
        {
            "rulePriority": 1,
            "description": "Expire images older than 14 days",
            "selection": {
                "tagStatus": "untagged",
                "countType": "sinceImagePushed",
                "countUnit": "days",
                "countNumber": 14
            },
            "action": {
                "type": "expire"
            }
        }
    ]
}
`,
});

Policy on tagged image

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var foo = new Aws.Ecr.Repository("foo", new Aws.Ecr.RepositoryArgs
        {
        });
        var foopolicy = new Aws.Ecr.LifecyclePolicy("foopolicy", new Aws.Ecr.LifecyclePolicyArgs
        {
            Repository = foo.Name,
            Policy = @"{
    ""rules"": [
        {
            ""rulePriority"": 1,
            ""description"": ""Keep last 30 images"",
            ""selection"": {
                ""tagStatus"": ""tagged"",
                ""tagPrefixList"": [""v""],
                ""countType"": ""imageCountMoreThan"",
                ""countNumber"": 30
            },
            ""action"": {
                ""type"": ""expire""
            }
        }
    ]
}
",
        });
    }

}
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/ecr"
	"github.com/pulumi/pulumi/sdk/v3/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.Any(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 pulumi
import pulumi_aws as aws

foo = aws.ecr.Repository("foo")
foopolicy = aws.ecr.LifecyclePolicy("foopolicy",
    repository=foo.name,
    policy="""{
    "rules": [
        {
            "rulePriority": 1,
            "description": "Keep last 30 images",
            "selection": {
                "tagStatus": "tagged",
                "tagPrefixList": ["v"],
                "countType": "imageCountMoreThan",
                "countNumber": 30
            },
            "action": {
                "type": "expire"
            }
        }
    ]
}
""")
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const foo = new aws.ecr.Repository("foo", {});
const foopolicy = new aws.ecr.LifecyclePolicy("foopolicy", {
    repository: foo.name,
    policy: `{
    "rules": [
        {
            "rulePriority": 1,
            "description": "Keep last 30 images",
            "selection": {
                "tagStatus": "tagged",
                "tagPrefixList": ["v"],
                "countType": "imageCountMoreThan",
                "countNumber": 30
            },
            "action": {
                "type": "expire"
            }
        }
    ]
}
`,
});

Create a LifecyclePolicy Resource

new LifecyclePolicy(name: string, args: LifecyclePolicyArgs, opts?: CustomResourceOptions);
@overload
def LifecyclePolicy(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    policy: Optional[str] = None,
                    repository: Optional[str] = None)
@overload
def LifecyclePolicy(resource_name: str,
                    args: LifecyclePolicyArgs,
                    opts: Optional[ResourceOptions] = None)
func NewLifecyclePolicy(ctx *Context, name string, args LifecyclePolicyArgs, opts ...ResourceOption) (*LifecyclePolicy, error)
public LifecyclePolicy(string name, LifecyclePolicyArgs args, CustomResourceOptions? opts = null)
name string
The unique name of the resource.
args LifecyclePolicyArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name str
The unique name of the resource.
args LifecyclePolicyArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name string
The unique name of the resource.
args LifecyclePolicyArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name string
The unique name of the resource.
args LifecyclePolicyArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.

LifecyclePolicy Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The LifecyclePolicy resource accepts the following input properties:

Policy string | string
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
Repository string
Name of the repository to apply the policy.
Policy string | string
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
Repository string
Name of the repository to apply the policy.
policy string | LifecyclePolicyDocument
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
repository string
Name of the repository to apply the policy.
policy str | str
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
repository str
Name of the repository to apply the policy.

Outputs

All input properties are implicitly available as output properties. Additionally, the LifecyclePolicy resource produces the following output properties:

Id string
The provider-assigned unique ID for this managed resource.
RegistryId string
The registry ID where the repository was created.
Id string
The provider-assigned unique ID for this managed resource.
RegistryId string
The registry ID where the repository was created.
id string
The provider-assigned unique ID for this managed resource.
registryId string
The registry ID where the repository was created.
id str
The provider-assigned unique ID for this managed resource.
registry_id str
The registry ID where the repository was created.

Look up an Existing LifecyclePolicy Resource

Get an existing LifecyclePolicy resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: LifecyclePolicyState, opts?: CustomResourceOptions): LifecyclePolicy
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        policy: Optional[str] = None,
        registry_id: Optional[str] = None,
        repository: Optional[str] = None) -> LifecyclePolicy
func GetLifecyclePolicy(ctx *Context, name string, id IDInput, state *LifecyclePolicyState, opts ...ResourceOption) (*LifecyclePolicy, error)
public static LifecyclePolicy Get(string name, Input<string> id, LifecyclePolicyState? state, CustomResourceOptions? opts = null)
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.

The following state arguments are supported:

Policy string | string
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
RegistryId string
The registry ID where the repository was created.
Repository string
Name of the repository to apply the policy.
Policy string | string
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
RegistryId string
The registry ID where the repository was created.
Repository string
Name of the repository to apply the policy.
policy string | LifecyclePolicyDocument
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
registryId string
The registry ID where the repository was created.
repository string
Name of the repository to apply the policy.
policy str | str
The policy document. This is a JSON formatted string. See more details about Policy Parameters in the official AWS docs.
registry_id str
The registry ID where the repository was created.
repository str
Name of the repository to apply the policy.

Import

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

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

Package Details

Repository
https://github.com/pulumi/pulumi-aws
License
Apache-2.0
Notes
This Pulumi package is based on the aws Terraform Provider.