
subaud is authored by Court Schuett (he/him). While Court is an AWS employee, opinions and statements on this blog are his own.


Court Schuett


```typescript
import { RemovalPolicy, IgnoreMode } from 'aws-cdk-lib';
import { Bucket, ObjectOwnership } from 'aws-cdk-lib/aws-s3';
import { Source, BucketDeployment } from 'aws-cdk-lib/aws-s3-deployment';
import { Construct } from 'constructs';

export class BucketDeploymentExample extends Construct {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    const assetBucket = new Bucket(this, 'assetBucket', {
      publicReadAccess: false,
      removalPolicy: RemovalPolicy.DESTROY,
      objectOwnership: ObjectOwnership.BUCKET_OWNER_PREFERRED,
      autoDeleteObjects: true,
    });

    new BucketDeployment(this, 'assetBucketDeployment', {
      sources: [
        Source.asset('src/resources/server/assets', {
          exclude: ['**/node_modules/**', '**/dist/**'],
          ignoreMode: IgnoreMode.GIT,
        }),
      ],
      destinationBucket: assetBucket,
      retainOnDelete: false,
      memoryLimit: 512,
    });
  }
}
```

Here we can see an example of how to prevent some files and directories from being uploaded as part of the bucket deployment. In this case, we want to prevent `**/node_modules/**` and `**/dist/**` from being uploaded as they are part of the local development and not needed in the bucket. We are going to use [`IgnoreMode`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IgnoreMode.html) to use the [`.gitignore specification`](https://git-scm.com/docs/gitignore).

Now, when using [`BucketDeployment`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3_deployment.BucketDeployment.html) with a [`Source`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3_deployment.Source.html), we can use [`AssetOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3_assets.AssetOptions.html) to prevent those entire directories from being included in the upload.


When uploading files and directories during a CDK bucket deployment, `exclude` can be used.  This samples shows how to use that feature.

Excluding files and directories from a CDK Bucket Deployment


In this demo, we will show how to conditionally deploy resources using environment variables.

## Passing Environment Variables

This CDK uses a Stack with several inputs. Besides the standard `env` input, we are also defining `StackProps` that will be used to pass the `bucketName` from the environment to the Stack.

```typescript
const devEnv = {
  account: process.env.CDK_DEFAULT_ACCOUNT,
  region: process.env.CDK_DEFAULT_REGION,
};

const stackProps = {
  bucketName: process.env.BUCKET_NAME || '',
};

new ConditionalDeployment(app, 'ConditionalDeployment', {
  ...stackProps,
  env: devEnv,
});
```

Here we see the standard `projen` created `devEnv` and the App that is being deployed. We are additionally adding `stackProps` to the Stack that is being created and passing the environment variable `BUCKET_NAME` to it if it is present.

## Stack and StackProps

```typescript
interface ConditionalDeploymentProps extends StackProps {
  bucketName?: string;
}

let deploymentBucket: IBucket;

export class ConditionalDeployment extends Stack {
  constructor(scope: Construct, id: string, props: ConditionalDeploymentProps) {
    super(scope, id, props);
```

Here we have defined `ConditionalDeploymentProps` as a `StackProps` to be passed to the Stack as well as `deploymentBucket`. This will be used later with either a new bucket or the existing bucket.

## Condition

```typescript
if (props.bucketName) {
  deploymentBucket = Bucket.fromBucketName(this, 'Bucket', props.bucketName);
} else {
  deploymentBucket = new Bucket(this, 'Bucket', {
    encryption: BucketEncryption.S3_MANAGED,
    blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
    removalPolicy: RemovalPolicy.DESTROY,
    autoDeleteObjects: true,
  });
}
```

This is where we will check to see if a string has been passed as a prop named `bucketName` to the Stack. It is not required to be passed, but if it is, we want to use that bucket as the deployment destination. To do that, we need to get the [`IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html) using [`Bucket.fromBucketName`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html#static-fromwbrbucketwbrnamescope-id-bucketname).

If no prop named `bucketName` was passed to the Stack, we will create a bucket. In either case, the bucket that we will be deploying to is referenced by `deploymentBucket`.

## Deploying to the Bucket

```typescript
const data = {
  bucketName: deploymentBucket.bucketName,
  text: 'Hello World',
};

new BucketDeployment(this, 'Deployment', {
  sources: [Source.jsonData('config.json', data)],
  destinationBucket: deploymentBucket,
});
```

Now, we will create a simple JSON file using `Source.jsonData` and upload this file to the bucket. This will either be an existing bucket referenced in the environment variables, or a newly created bucket. In either case, we can use `deplyomentBucket` as the `destinationBucket` because we are always creating an `IBucket`. If the bucket already exists, we use `fromBucketName` and if the bucket does not exist, `new Bucket` will return an `IBucket`.

## Deploying with Environment Variables

> Note: You must replace `conditional-cdk-deploy-demo` with a unique name

```bash
export BUCKET_NAME=conditional-cdk-deploy-demo
yarn launch
```

or

```bash
BUCKET_NAME=conditional-cdk-deploy-demo yarn launch
```

Once completed, we can see that an existing S3 bucket has the `config.json` file in it.

```bash
aws s3 ls s3://conditional-cdk-deploy-demo
aws s3 cp s3://conditional-cdk-deploy-demo/config.json ./
cat config.json
```

## Deploying without Environment Variables

```
unset BUCKET_NAME
yarn launch
```

When the CDK is deployed, a new bucket will be created. This bucket name will be in the output of the CDK and can be used to verify the creation of the bucket and the deployment of the `config.json` file.

## Testing the CDK

In order to verify that our CDK is correct, we should test it. This is done as part of a projen build. In this demo, we are using Snapshots to test.

```typescript
test('Snapshot', () => {
  const app = new App();
  const stack = new ConditionalDeployment(app, 'test', {});

  const template = Template.fromStack(stack);
  expect(template.toJSON()).toMatchSnapshot();
});

test('SnapshotWithBucketName', () => {
  const app = new App();
  const stack = new ConditionalDeployment(app, 'test', {
    bucketName: 'test-bucket',
  });

  const template = Template.fromStack(stack);
  expect(template.toJSON()).toMatchSnapshot();
});
```

This will now create snapshots for both scenarios. Without the second snapshot, we would have uncovered lines in the test.


This demo will describe how to create a CDK with conditional resource deployment and how to use Environment Variables with that conditional deployment

Conditional Resource Deployment and Environment Variables with CDK


This simple script will look through a bucket to find all objects that match a `LastModified` date and delete. This can be adjusted to delete objects before, after, or matching the date specified. Use at your own risk.

```python
import boto3
from datetime import datetime, timezone

s3 = boto3.client("s3")
bucket = "INSERT_BUCKET_NAME"
paginator = s3.get_paginator("list_objects_v2")
pages = paginator.paginate(Bucket=bucket)
date_check = datetime(2021, 11, 1)

keys_to_delete = []
for page in pages:
    for object in page["Contents"]:
        if object["LastModified"] > date_check.replace(tzinfo=timezone.utc):
            keys_to_delete.append({"Key": object["Key"]})

s3.delete_objects(Bucket=bucket, Delete={"Objects": keys_to_delete})
```

Gist [here](https://gist.github.com/schuettc/83c2ef71b5604eff69d1248553a8ef2c).


This simple script will look through a bucket to find all objects that match a `LastModified` date and delete.  This can be adjusted to delete objects before, after, or matching the date specified.  Use at your own risk.

S3

Excluding files and directories from a CDK Bucket Deployment

Conditional Resource Deployment and Environment Variables with CDK

Bulk Delete S3 Objects by LastModified Date