Configure AWS Connect Instance Storage

The aws:connect/instanceStorageConfig:InstanceStorageConfig resource, part of the Pulumi AWS provider, configures where Amazon Connect stores specific data types: chat transcripts, call recordings, contact trace records, and media streams. This guide focuses on three capabilities: S3 storage with KMS encryption, Kinesis streaming destinations, and resource type selection with retention policies.

Storage configurations require an existing Connect instance and destination resources such as S3 buckets or Kinesis streams. IAM permissions must allow Connect to write to these destinations. The examples are intentionally small. Combine them with your own IAM policies, bucket configurations, and stream settings.

Store chat transcripts in S3

Contact centers archive chat transcripts to S3 for compliance, analytics, and quality review.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.connect.InstanceStorageConfig("example", {
    instanceId: exampleAwsConnectInstance.id,
    resourceType: "CHAT_TRANSCRIPTS",
    storageConfig: {
        s3Config: {
            bucketName: exampleAwsS3Bucket.id,
            bucketPrefix: "example",
        },
        storageType: "S3",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.connect.InstanceStorageConfig("example",
    instance_id=example_aws_connect_instance["id"],
    resource_type="CHAT_TRANSCRIPTS",
    storage_config={
        "s3_config": {
            "bucket_name": example_aws_s3_bucket["id"],
            "bucket_prefix": "example",
        },
        "storage_type": "S3",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/connect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := connect.NewInstanceStorageConfig(ctx, "example", &connect.InstanceStorageConfigArgs{
			InstanceId:   pulumi.Any(exampleAwsConnectInstance.Id),
			ResourceType: pulumi.String("CHAT_TRANSCRIPTS"),
			StorageConfig: &connect.InstanceStorageConfigStorageConfigArgs{
				S3Config: &connect.InstanceStorageConfigStorageConfigS3ConfigArgs{
					BucketName:   pulumi.Any(exampleAwsS3Bucket.Id),
					BucketPrefix: pulumi.String("example"),
				},
				StorageType: pulumi.String("S3"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Connect.InstanceStorageConfig("example", new()
    {
        InstanceId = exampleAwsConnectInstance.Id,
        ResourceType = "CHAT_TRANSCRIPTS",
        StorageConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigArgs
        {
            S3Config = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigS3ConfigArgs
            {
                BucketName = exampleAwsS3Bucket.Id,
                BucketPrefix = "example",
            },
            StorageType = "S3",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.connect.InstanceStorageConfig;
import com.pulumi.aws.connect.InstanceStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigS3ConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new InstanceStorageConfig("example", InstanceStorageConfigArgs.builder()
            .instanceId(exampleAwsConnectInstance.id())
            .resourceType("CHAT_TRANSCRIPTS")
            .storageConfig(InstanceStorageConfigStorageConfigArgs.builder()
                .s3Config(InstanceStorageConfigStorageConfigS3ConfigArgs.builder()
                    .bucketName(exampleAwsS3Bucket.id())
                    .bucketPrefix("example")
                    .build())
                .storageType("S3")
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:connect:InstanceStorageConfig
    properties:
      instanceId: ${exampleAwsConnectInstance.id}
      resourceType: CHAT_TRANSCRIPTS
      storageConfig:
        s3Config:
          bucketName: ${exampleAwsS3Bucket.id}
          bucketPrefix: example
        storageType: S3

The resourceType property specifies what data to store; here, CHAT_TRANSCRIPTS captures customer chat conversations. The storageConfig block defines the destination: storageType selects S3, while s3Config provides the bucket name and optional prefix for organizing objects. Connect writes transcripts to this bucket as they’re generated.

Encrypt stored transcripts with KMS

Sensitive conversations require encryption at rest to meet security and compliance requirements.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.connect.InstanceStorageConfig("example", {
    instanceId: exampleAwsConnectInstance.id,
    resourceType: "CHAT_TRANSCRIPTS",
    storageConfig: {
        s3Config: {
            bucketName: exampleAwsS3Bucket.id,
            bucketPrefix: "example",
            encryptionConfig: {
                encryptionType: "KMS",
                keyId: exampleAwsKmsKey.arn,
            },
        },
        storageType: "S3",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.connect.InstanceStorageConfig("example",
    instance_id=example_aws_connect_instance["id"],
    resource_type="CHAT_TRANSCRIPTS",
    storage_config={
        "s3_config": {
            "bucket_name": example_aws_s3_bucket["id"],
            "bucket_prefix": "example",
            "encryption_config": {
                "encryption_type": "KMS",
                "key_id": example_aws_kms_key["arn"],
            },
        },
        "storage_type": "S3",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/connect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := connect.NewInstanceStorageConfig(ctx, "example", &connect.InstanceStorageConfigArgs{
			InstanceId:   pulumi.Any(exampleAwsConnectInstance.Id),
			ResourceType: pulumi.String("CHAT_TRANSCRIPTS"),
			StorageConfig: &connect.InstanceStorageConfigStorageConfigArgs{
				S3Config: &connect.InstanceStorageConfigStorageConfigS3ConfigArgs{
					BucketName:   pulumi.Any(exampleAwsS3Bucket.Id),
					BucketPrefix: pulumi.String("example"),
					EncryptionConfig: &connect.InstanceStorageConfigStorageConfigS3ConfigEncryptionConfigArgs{
						EncryptionType: pulumi.String("KMS"),
						KeyId:          pulumi.Any(exampleAwsKmsKey.Arn),
					},
				},
				StorageType: pulumi.String("S3"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Connect.InstanceStorageConfig("example", new()
    {
        InstanceId = exampleAwsConnectInstance.Id,
        ResourceType = "CHAT_TRANSCRIPTS",
        StorageConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigArgs
        {
            S3Config = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigS3ConfigArgs
            {
                BucketName = exampleAwsS3Bucket.Id,
                BucketPrefix = "example",
                EncryptionConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigS3ConfigEncryptionConfigArgs
                {
                    EncryptionType = "KMS",
                    KeyId = exampleAwsKmsKey.Arn,
                },
            },
            StorageType = "S3",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.connect.InstanceStorageConfig;
import com.pulumi.aws.connect.InstanceStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigS3ConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigS3ConfigEncryptionConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new InstanceStorageConfig("example", InstanceStorageConfigArgs.builder()
            .instanceId(exampleAwsConnectInstance.id())
            .resourceType("CHAT_TRANSCRIPTS")
            .storageConfig(InstanceStorageConfigStorageConfigArgs.builder()
                .s3Config(InstanceStorageConfigStorageConfigS3ConfigArgs.builder()
                    .bucketName(exampleAwsS3Bucket.id())
                    .bucketPrefix("example")
                    .encryptionConfig(InstanceStorageConfigStorageConfigS3ConfigEncryptionConfigArgs.builder()
                        .encryptionType("KMS")
                        .keyId(exampleAwsKmsKey.arn())
                        .build())
                    .build())
                .storageType("S3")
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:connect:InstanceStorageConfig
    properties:
      instanceId: ${exampleAwsConnectInstance.id}
      resourceType: CHAT_TRANSCRIPTS
      storageConfig:
        s3Config:
          bucketName: ${exampleAwsS3Bucket.id}
          bucketPrefix: example
          encryptionConfig:
            encryptionType: KMS
            keyId: ${exampleAwsKmsKey.arn}
        storageType: S3

Adding encryptionConfig to the s3Config block enables KMS encryption. The encryptionType must be “KMS”, and keyId references your KMS key ARN. Connect encrypts each object before writing to S3, protecting data at rest.

Stream contact trace records to Kinesis Firehose

Real-time analytics pipelines consume contact trace records as they’re generated, delivering them to S3, Redshift, or Elasticsearch.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.connect.InstanceStorageConfig("example", {
    instanceId: exampleAwsConnectInstance.id,
    resourceType: "CONTACT_TRACE_RECORDS",
    storageConfig: {
        kinesisFirehoseConfig: {
            firehoseArn: exampleAwsKinesisFirehoseDeliveryStream.arn,
        },
        storageType: "KINESIS_FIREHOSE",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.connect.InstanceStorageConfig("example",
    instance_id=example_aws_connect_instance["id"],
    resource_type="CONTACT_TRACE_RECORDS",
    storage_config={
        "kinesis_firehose_config": {
            "firehose_arn": example_aws_kinesis_firehose_delivery_stream["arn"],
        },
        "storage_type": "KINESIS_FIREHOSE",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/connect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := connect.NewInstanceStorageConfig(ctx, "example", &connect.InstanceStorageConfigArgs{
			InstanceId:   pulumi.Any(exampleAwsConnectInstance.Id),
			ResourceType: pulumi.String("CONTACT_TRACE_RECORDS"),
			StorageConfig: &connect.InstanceStorageConfigStorageConfigArgs{
				KinesisFirehoseConfig: &connect.InstanceStorageConfigStorageConfigKinesisFirehoseConfigArgs{
					FirehoseArn: pulumi.Any(exampleAwsKinesisFirehoseDeliveryStream.Arn),
				},
				StorageType: pulumi.String("KINESIS_FIREHOSE"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Connect.InstanceStorageConfig("example", new()
    {
        InstanceId = exampleAwsConnectInstance.Id,
        ResourceType = "CONTACT_TRACE_RECORDS",
        StorageConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigArgs
        {
            KinesisFirehoseConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigKinesisFirehoseConfigArgs
            {
                FirehoseArn = exampleAwsKinesisFirehoseDeliveryStream.Arn,
            },
            StorageType = "KINESIS_FIREHOSE",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.connect.InstanceStorageConfig;
import com.pulumi.aws.connect.InstanceStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigKinesisFirehoseConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new InstanceStorageConfig("example", InstanceStorageConfigArgs.builder()
            .instanceId(exampleAwsConnectInstance.id())
            .resourceType("CONTACT_TRACE_RECORDS")
            .storageConfig(InstanceStorageConfigStorageConfigArgs.builder()
                .kinesisFirehoseConfig(InstanceStorageConfigStorageConfigKinesisFirehoseConfigArgs.builder()
                    .firehoseArn(exampleAwsKinesisFirehoseDeliveryStream.arn())
                    .build())
                .storageType("KINESIS_FIREHOSE")
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:connect:InstanceStorageConfig
    properties:
      instanceId: ${exampleAwsConnectInstance.id}
      resourceType: CONTACT_TRACE_RECORDS
      storageConfig:
        kinesisFirehoseConfig:
          firehoseArn: ${exampleAwsKinesisFirehoseDeliveryStream.arn}
        storageType: KINESIS_FIREHOSE

When resourceType is CONTACT_TRACE_RECORDS and storageType is KINESIS_FIREHOSE, Connect streams each contact event to your Firehose delivery stream. The firehoseArn points to the stream that handles downstream delivery and transformation.

Stream contact trace records to Kinesis Data Streams

Custom processing applications consume contact trace records directly from Kinesis Data Streams for real-time transformation.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.connect.InstanceStorageConfig("example", {
    instanceId: exampleAwsConnectInstance.id,
    resourceType: "CONTACT_TRACE_RECORDS",
    storageConfig: {
        kinesisStreamConfig: {
            streamArn: exampleAwsKinesisStream.arn,
        },
        storageType: "KINESIS_STREAM",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.connect.InstanceStorageConfig("example",
    instance_id=example_aws_connect_instance["id"],
    resource_type="CONTACT_TRACE_RECORDS",
    storage_config={
        "kinesis_stream_config": {
            "stream_arn": example_aws_kinesis_stream["arn"],
        },
        "storage_type": "KINESIS_STREAM",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/connect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := connect.NewInstanceStorageConfig(ctx, "example", &connect.InstanceStorageConfigArgs{
			InstanceId:   pulumi.Any(exampleAwsConnectInstance.Id),
			ResourceType: pulumi.String("CONTACT_TRACE_RECORDS"),
			StorageConfig: &connect.InstanceStorageConfigStorageConfigArgs{
				KinesisStreamConfig: &connect.InstanceStorageConfigStorageConfigKinesisStreamConfigArgs{
					StreamArn: pulumi.Any(exampleAwsKinesisStream.Arn),
				},
				StorageType: pulumi.String("KINESIS_STREAM"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Connect.InstanceStorageConfig("example", new()
    {
        InstanceId = exampleAwsConnectInstance.Id,
        ResourceType = "CONTACT_TRACE_RECORDS",
        StorageConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigArgs
        {
            KinesisStreamConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigKinesisStreamConfigArgs
            {
                StreamArn = exampleAwsKinesisStream.Arn,
            },
            StorageType = "KINESIS_STREAM",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.connect.InstanceStorageConfig;
import com.pulumi.aws.connect.InstanceStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigKinesisStreamConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new InstanceStorageConfig("example", InstanceStorageConfigArgs.builder()
            .instanceId(exampleAwsConnectInstance.id())
            .resourceType("CONTACT_TRACE_RECORDS")
            .storageConfig(InstanceStorageConfigStorageConfigArgs.builder()
                .kinesisStreamConfig(InstanceStorageConfigStorageConfigKinesisStreamConfigArgs.builder()
                    .streamArn(exampleAwsKinesisStream.arn())
                    .build())
                .storageType("KINESIS_STREAM")
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:connect:InstanceStorageConfig
    properties:
      instanceId: ${exampleAwsConnectInstance.id}
      resourceType: CONTACT_TRACE_RECORDS
      storageConfig:
        kinesisStreamConfig:
          streamArn: ${exampleAwsKinesisStream.arn}
        storageType: KINESIS_STREAM

Using KINESIS_STREAM as the storageType sends contact events to a Kinesis Data Stream instead of Firehose. The streamArn identifies your stream. This gives you direct access to the event stream for custom consumers.

Capture media streams with retention and encryption

Video and audio recordings require specialized storage with configurable retention and encryption.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.connect.InstanceStorageConfig("example", {
    instanceId: exampleAwsConnectInstance.id,
    resourceType: "MEDIA_STREAMS",
    storageConfig: {
        kinesisVideoStreamConfig: {
            prefix: "example",
            retentionPeriodHours: 3,
            encryptionConfig: {
                encryptionType: "KMS",
                keyId: exampleAwsKmsKey.arn,
            },
        },
        storageType: "KINESIS_VIDEO_STREAM",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.connect.InstanceStorageConfig("example",
    instance_id=example_aws_connect_instance["id"],
    resource_type="MEDIA_STREAMS",
    storage_config={
        "kinesis_video_stream_config": {
            "prefix": "example",
            "retention_period_hours": 3,
            "encryption_config": {
                "encryption_type": "KMS",
                "key_id": example_aws_kms_key["arn"],
            },
        },
        "storage_type": "KINESIS_VIDEO_STREAM",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/connect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := connect.NewInstanceStorageConfig(ctx, "example", &connect.InstanceStorageConfigArgs{
			InstanceId:   pulumi.Any(exampleAwsConnectInstance.Id),
			ResourceType: pulumi.String("MEDIA_STREAMS"),
			StorageConfig: &connect.InstanceStorageConfigStorageConfigArgs{
				KinesisVideoStreamConfig: &connect.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigArgs{
					Prefix:               pulumi.String("example"),
					RetentionPeriodHours: pulumi.Int(3),
					EncryptionConfig: &connect.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigEncryptionConfigArgs{
						EncryptionType: pulumi.String("KMS"),
						KeyId:          pulumi.Any(exampleAwsKmsKey.Arn),
					},
				},
				StorageType: pulumi.String("KINESIS_VIDEO_STREAM"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Connect.InstanceStorageConfig("example", new()
    {
        InstanceId = exampleAwsConnectInstance.Id,
        ResourceType = "MEDIA_STREAMS",
        StorageConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigArgs
        {
            KinesisVideoStreamConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigArgs
            {
                Prefix = "example",
                RetentionPeriodHours = 3,
                EncryptionConfig = new Aws.Connect.Inputs.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigEncryptionConfigArgs
                {
                    EncryptionType = "KMS",
                    KeyId = exampleAwsKmsKey.Arn,
                },
            },
            StorageType = "KINESIS_VIDEO_STREAM",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.connect.InstanceStorageConfig;
import com.pulumi.aws.connect.InstanceStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigArgs;
import com.pulumi.aws.connect.inputs.InstanceStorageConfigStorageConfigKinesisVideoStreamConfigEncryptionConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new InstanceStorageConfig("example", InstanceStorageConfigArgs.builder()
            .instanceId(exampleAwsConnectInstance.id())
            .resourceType("MEDIA_STREAMS")
            .storageConfig(InstanceStorageConfigStorageConfigArgs.builder()
                .kinesisVideoStreamConfig(InstanceStorageConfigStorageConfigKinesisVideoStreamConfigArgs.builder()
                    .prefix("example")
                    .retentionPeriodHours(3)
                    .encryptionConfig(InstanceStorageConfigStorageConfigKinesisVideoStreamConfigEncryptionConfigArgs.builder()
                        .encryptionType("KMS")
                        .keyId(exampleAwsKmsKey.arn())
                        .build())
                    .build())
                .storageType("KINESIS_VIDEO_STREAM")
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:connect:InstanceStorageConfig
    properties:
      instanceId: ${exampleAwsConnectInstance.id}
      resourceType: MEDIA_STREAMS
      storageConfig:
        kinesisVideoStreamConfig:
          prefix: example
          retentionPeriodHours: 3
          encryptionConfig:
            encryptionType: KMS
            keyId: ${exampleAwsKmsKey.arn}
        storageType: KINESIS_VIDEO_STREAM

The MEDIA_STREAMS resource type captures audio and video from customer interactions. The kinesisVideoStreamConfig block sets a prefix for stream naming, retentionPeriodHours for how long to keep recordings, and encryptionConfig for KMS encryption. Connect creates video streams automatically and manages retention.

Beyond these examples

These snippets focus on specific storage configuration features: S3 storage with optional encryption, Kinesis streaming destinations, and resource type selection with retention policies. They’re intentionally minimal rather than full contact center deployments.

The examples reference pre-existing infrastructure such as Amazon Connect instances, S3 buckets or Kinesis streams, KMS keys for encryption, and IAM permissions for Connect to access storage destinations. They focus on configuring storage destinations rather than provisioning the surrounding infrastructure.

To keep things focused, common storage patterns are omitted, including:

IAM role and policy configuration for Connect
S3 bucket policies and lifecycle rules
Kinesis stream sharding and throughput tuning
Multiple storage configs per instance (different resource types)

These omissions are intentional: the goal is to illustrate how each storage destination is wired, not provide drop-in contact center modules. See the Connect Instance Storage Config resource reference for all available configuration options.

Let's configure AWS Connect Instance Storage

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Storage Types & Configuration

What types of data can I store with Instance Storage Config?

You can store 12 resource types: AGENT_EVENTS, ATTACHMENTS, CALL_RECORDINGS, CHAT_TRANSCRIPTS, CONTACT_EVALUATIONS, CONTACT_TRACE_RECORDS, EMAIL_MESSAGES, MEDIA_STREAMS, REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS, REAL_TIME_CONTACT_ANALYSIS_SEGMENTS, REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS, SCHEDULED_REPORTS, and SCREEN_RECORDINGS.

What storage backends are supported?

Four storage types are available: Kinesis Firehose (KINESIS_FIREHOSE), Kinesis Stream (KINESIS_STREAM), Kinesis Video Stream (KINESIS_VIDEO_STREAM), and S3 (S3).

How do I configure S3 storage for my Connect data?

Set storageType to S3 and configure s3Config with bucketName and an optional bucketPrefix, as shown in the S3 example.

How do I configure Kinesis Firehose for contact trace records?

Set storageType to KINESIS_FIREHOSE and provide kinesisFirehoseConfig with your Firehose delivery stream ARN.

Encryption & Security

How do I encrypt my stored Connect data?

Add encryptionConfig to your storage configuration with encryptionType set to KMS and provide your KMS keyId. This works with both S3 and Kinesis Video Stream storage.

Is encryption required for Connect storage?

No, encryption is optional. Examples show both encrypted and unencrypted configurations.

Resource Lifecycle

Can I change the storage type or resource type after creation?

No, both instanceId and resourceType are immutable. Changing them requires replacing the resource.

Using a different cloud?

Explore integration guides for other cloud providers:

Azure Guides GCP Guides