> **Experimental**
>
> `@aws-cdk/aws-imagebuilder-alpha` is an [**experimental**](/stability) (alpha) package: its API may change in any release, without a major version bump.
# LifecyclePolicyCountFilter

The count-based filtering to apply in a lifecycle policy rule.

- Stability: [Experimental](/cdk/api/stability.html)
- Source: [`lib/lifecycle-policy.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/@aws-cdk/aws-imagebuilder-alpha/lib/lifecycle-policy.ts#L147)

## Example

TypeScript:

```ts
const excludeImagesPolicy = new imagebuilder.LifecyclePolicy(this, 'ExcludeImagesPolicy', {
  resourceType: imagebuilder.LifecyclePolicyResourceType.CONTAINER_IMAGE,
  details: [
    {
      action: { type: imagebuilder.LifecyclePolicyActionType.DELETE },
      filter: { countFilter: { count: 20 } },
      exclusionRules: {
        imageExclusionRules: {
          tags: {
            DoNotDelete: 'true',
            Critical: 'baseline'
          }
        }
      }
    }
  ],
  resourceSelection: {
    tags: { Application: 'frontend' }
  }
});
```

Python:

```python
exclude_images_policy = imagebuilder.LifecyclePolicy(self, "ExcludeImagesPolicy",
    resource_type=imagebuilder.LifecyclePolicyResourceType.CONTAINER_IMAGE,
    details=[imagebuilder.LifecyclePolicyDetail(
        action=imagebuilder.LifecyclePolicyAction(type=imagebuilder.LifecyclePolicyActionType.DELETE),
        filter=imagebuilder.LifecyclePolicyFilter(count_filter=imagebuilder.LifecyclePolicyCountFilter(count=20)),
        exclusion_rules=imagebuilder.LifecyclePolicyExclusionRules(
            image_exclusion_rules=imagebuilder.LifecyclePolicyImageExclusionRules(
                tags={
                    "DoNotDelete": "true",
                    "Critical": "baseline"
                }
            )
        )
    )
    ],
    resource_selection=imagebuilder.LifecyclePolicyResourceSelection(
        tags={"Application": "frontend"}
    )
)
```

Java:

```java
LifecyclePolicy excludeImagesPolicy = LifecyclePolicy.Builder.create(this, "ExcludeImagesPolicy")
        .resourceType(LifecyclePolicyResourceType.CONTAINER_IMAGE)
        .details(List.of(LifecyclePolicyDetail.builder()
                .action(LifecyclePolicyAction.builder().type(LifecyclePolicyActionType.DELETE).build())
                .filter(LifecyclePolicyFilter.builder().countFilter(LifecyclePolicyCountFilter.builder().count(20).build()).build())
                .exclusionRules(LifecyclePolicyExclusionRules.builder()
                        .imageExclusionRules(LifecyclePolicyImageExclusionRules.builder()
                                .tags(Map.of(
                                        "DoNotDelete", "true",
                                        "Critical", "baseline"))
                                .build())
                        .build())
                .build()))
        .resourceSelection(LifecyclePolicyResourceSelection.builder()
                .tags(Map.of("Application", "frontend"))
                .build())
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.AWS.ImageBuilder.Alpha
var excludeImagesPolicy = new LifecyclePolicy(this, "ExcludeImagesPolicy", new LifecyclePolicyProps {
    ResourceType = LifecyclePolicyResourceType.CONTAINER_IMAGE,
    Details = new [] { new LifecyclePolicyDetail {
        Action = new LifecyclePolicyAction { Type = LifecyclePolicyActionType.DELETE },
        Filter = new LifecyclePolicyFilter { CountFilter = new LifecyclePolicyCountFilter { Count = 20 } },
        ExclusionRules = new LifecyclePolicyExclusionRules {
            ImageExclusionRules = new LifecyclePolicyImageExclusionRules {
                Tags = new Dictionary<string, string> {
                    { "DoNotDelete", "true" },
                    { "Critical", "baseline" }
                }
            }
        }
    } },
    ResourceSelection = new LifecyclePolicyResourceSelection {
        Tags = new Dictionary<string, string> { { "Application", "frontend" } }
    }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awsimagebuilderalpha/v2
excludeImagesPolicy := imagebuilder.NewLifecyclePolicy(this, jsii.String("ExcludeImagesPolicy"), &LifecyclePolicyProps{
	ResourceType: imagebuilder.LifecyclePolicyResourceType_CONTAINER_IMAGE,
	Details: []LifecyclePolicyDetail{
		&LifecyclePolicyDetail{
			Action: &LifecyclePolicyAction{
				Type: imagebuilder.LifecyclePolicyActionType_DELETE,
			},
			Filter: &LifecyclePolicyFilter{
				CountFilter: &LifecyclePolicyCountFilter{
					Count: jsii.Number(20),
				},
			},
			ExclusionRules: &LifecyclePolicyExclusionRules{
				ImageExclusionRules: &LifecyclePolicyImageExclusionRules{
					Tags: map[string]*string{
						"DoNotDelete": jsii.String("true"),
						"Critical": jsii.String("baseline"),
					},
				},
			},
		},
	},
	ResourceSelection: &LifecyclePolicyResourceSelection{
		Tags: map[string]*string{
			"Application": jsii.String("frontend"),
		},
	},
})
```

## Properties

- `count`: number (required) — The minimum number of resources to keep on hand as part of resource filtering.
