Create AWS Timestream for InfluxDB Clusters

The aws:timestreaminfluxdb/dbCluster:DbCluster resource, part of the Pulumi AWS provider, provisions a Timestream for InfluxDB cluster: its compute instance, storage, networking, and authentication configuration. This guide focuses on three capabilities: VPC networking setup, S3 log delivery, and InfluxDB V2 vs V3 configuration models.

Clusters require VPC infrastructure and an active AWS Marketplace subscription to Timestream for InfluxDB Read Replicas. InfluxDB V2 clusters need storage and authentication parameters; V3 clusters use parameter group identifiers instead. The examples are intentionally small. Combine them with your own VPC infrastructure and security policies.

Create a cluster with VPC networking

Timestream for InfluxDB clusters run inside a VPC with subnets across multiple availability zones for high availability.

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

const example = new aws.ec2.Vpc("example", {cidrBlock: "10.0.0.0/16"});
const example1 = new aws.ec2.Subnet("example_1", {
    vpcId: example.id,
    cidrBlock: "10.0.1.0/24",
});
const example2 = new aws.ec2.Subnet("example_2", {
    vpcId: example.id,
    cidrBlock: "10.0.2.0/24",
});
const exampleSecurityGroup = new aws.ec2.SecurityGroup("example", {
    name: "example",
    vpcId: example.id,
});
const exampleDbCluster = new aws.timestreaminfluxdb.DbCluster("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    username: "admin",
    password: "example-password",
    organization: "organization",
    vpcSubnetIds: [
        example1.id,
        example2.id,
    ],
    vpcSecurityGroupIds: [exampleSecurityGroup.id],
    name: "example-db-cluster",
});

import pulumi
import pulumi_aws as aws

example = aws.ec2.Vpc("example", cidr_block="10.0.0.0/16")
example1 = aws.ec2.Subnet("example_1",
    vpc_id=example.id,
    cidr_block="10.0.1.0/24")
example2 = aws.ec2.Subnet("example_2",
    vpc_id=example.id,
    cidr_block="10.0.2.0/24")
example_security_group = aws.ec2.SecurityGroup("example",
    name="example",
    vpc_id=example.id)
example_db_cluster = aws.timestreaminfluxdb.DbCluster("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    username="admin",
    password="example-password",
    organization="organization",
    vpc_subnet_ids=[
        example1.id,
        example2.id,
    ],
    vpc_security_group_ids=[example_security_group.id],
    name="example-db-cluster")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewVpc(ctx, "example", &ec2.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		example1, err := ec2.NewSubnet(ctx, "example_1", &ec2.SubnetArgs{
			VpcId:     example.ID(),
			CidrBlock: pulumi.String("10.0.1.0/24"),
		})
		if err != nil {
			return err
		}
		example2, err := ec2.NewSubnet(ctx, "example_2", &ec2.SubnetArgs{
			VpcId:     example.ID(),
			CidrBlock: pulumi.String("10.0.2.0/24"),
		})
		if err != nil {
			return err
		}
		exampleSecurityGroup, err := ec2.NewSecurityGroup(ctx, "example", &ec2.SecurityGroupArgs{
			Name:  pulumi.String("example"),
			VpcId: example.ID(),
		})
		if err != nil {
			return err
		}
		_, err = timestreaminfluxdb.NewDbCluster(ctx, "example", &timestreaminfluxdb.DbClusterArgs{
			AllocatedStorage: pulumi.Int(20),
			Bucket:           pulumi.String("example-bucket-name"),
			DbInstanceType:   pulumi.String("db.influx.medium"),
			Username:         pulumi.String("admin"),
			Password:         pulumi.String("example-password"),
			Organization:     pulumi.String("organization"),
			VpcSubnetIds: pulumi.StringArray{
				example1.ID(),
				example2.ID(),
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleSecurityGroup.ID(),
			},
			Name: pulumi.String("example-db-cluster"),
		})
		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.Ec2.Vpc("example", new()
    {
        CidrBlock = "10.0.0.0/16",
    });

    var example1 = new Aws.Ec2.Subnet("example_1", new()
    {
        VpcId = example.Id,
        CidrBlock = "10.0.1.0/24",
    });

    var example2 = new Aws.Ec2.Subnet("example_2", new()
    {
        VpcId = example.Id,
        CidrBlock = "10.0.2.0/24",
    });

    var exampleSecurityGroup = new Aws.Ec2.SecurityGroup("example", new()
    {
        Name = "example",
        VpcId = example.Id,
    });

    var exampleDbCluster = new Aws.TimestreamInfluxDB.DbCluster("example", new()
    {
        AllocatedStorage = 20,
        Bucket = "example-bucket-name",
        DbInstanceType = "db.influx.medium",
        Username = "admin",
        Password = "example-password",
        Organization = "organization",
        VpcSubnetIds = new[]
        {
            example1.Id,
            example2.Id,
        },
        VpcSecurityGroupIds = new[]
        {
            exampleSecurityGroup.Id,
        },
        Name = "example-db-cluster",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.ec2.Subnet;
import com.pulumi.aws.ec2.SubnetArgs;
import com.pulumi.aws.ec2.SecurityGroup;
import com.pulumi.aws.ec2.SecurityGroupArgs;
import com.pulumi.aws.timestreaminfluxdb.DbCluster;
import com.pulumi.aws.timestreaminfluxdb.DbClusterArgs;
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 Vpc("example", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .build());

        var example1 = new Subnet("example1", SubnetArgs.builder()
            .vpcId(example.id())
            .cidrBlock("10.0.1.0/24")
            .build());

        var example2 = new Subnet("example2", SubnetArgs.builder()
            .vpcId(example.id())
            .cidrBlock("10.0.2.0/24")
            .build());

        var exampleSecurityGroup = new SecurityGroup("exampleSecurityGroup", SecurityGroupArgs.builder()
            .name("example")
            .vpcId(example.id())
            .build());

        var exampleDbCluster = new DbCluster("exampleDbCluster", DbClusterArgs.builder()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .username("admin")
            .password("example-password")
            .organization("organization")
            .vpcSubnetIds(            
                example1.id(),
                example2.id())
            .vpcSecurityGroupIds(exampleSecurityGroup.id())
            .name("example-db-cluster")
            .build());

    }
}

resources:
  example:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
  example1:
    type: aws:ec2:Subnet
    name: example_1
    properties:
      vpcId: ${example.id}
      cidrBlock: 10.0.1.0/24
  example2:
    type: aws:ec2:Subnet
    name: example_2
    properties:
      vpcId: ${example.id}
      cidrBlock: 10.0.2.0/24
  exampleSecurityGroup:
    type: aws:ec2:SecurityGroup
    name: example
    properties:
      name: example
      vpcId: ${example.id}
  exampleDbCluster:
    type: aws:timestreaminfluxdb:DbCluster
    name: example
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      username: admin
      password: example-password
      organization: organization
      vpcSubnetIds:
        - ${example1.id}
        - ${example2.id}
      vpcSecurityGroupIds:
        - ${exampleSecurityGroup.id}
      name: example-db-cluster

The cluster launches in the specified subnets with attached security groups controlling network access. For InfluxDB V2 clusters, you must provide allocatedStorage (minimum 20 GiB), bucket name, organization, username, and password. These authentication parameters are stored in AWS Secrets Manager, with the ARN available in the influxAuthParametersSecretArn output attribute.

Send InfluxDB engine logs to S3

To retain or analyze InfluxDB engine logs, configure the cluster to deliver logs to an S3 bucket.

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

const exampleBucket = new aws.s3.Bucket("example", {
    bucket: "example-s3-bucket",
    forceDestroy: true,
});
const example = aws.iam.getPolicyDocumentOutput({
    statements: [{
        actions: ["s3:PutObject"],
        principals: [{
            type: "Service",
            identifiers: ["timestream-influxdb.amazonaws.com"],
        }],
        resources: [pulumi.interpolate`${exampleBucket.arn}/*`],
    }],
});
const exampleBucketPolicy = new aws.s3.BucketPolicy("example", {
    bucket: exampleBucket.id,
    policy: example.apply(example => example.json),
});
const exampleDbCluster = new aws.timestreaminfluxdb.DbCluster("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    username: "admin",
    password: "example-password",
    organization: "organization",
    vpcSubnetIds: [
        example1.id,
        example2.id,
    ],
    vpcSecurityGroupIds: [exampleAwsSecurityGroup.id],
    name: "example-db-cluster",
    logDeliveryConfiguration: {
        s3Configuration: {
            bucketName: exampleBucket.bucket,
            enabled: true,
        },
    },
});

import pulumi
import pulumi_aws as aws

example_bucket = aws.s3.Bucket("example",
    bucket="example-s3-bucket",
    force_destroy=True)
example = aws.iam.get_policy_document_output(statements=[{
    "actions": ["s3:PutObject"],
    "principals": [{
        "type": "Service",
        "identifiers": ["timestream-influxdb.amazonaws.com"],
    }],
    "resources": [example_bucket.arn.apply(lambda arn: f"{arn}/*")],
}])
example_bucket_policy = aws.s3.BucketPolicy("example",
    bucket=example_bucket.id,
    policy=example.json)
example_db_cluster = aws.timestreaminfluxdb.DbCluster("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    username="admin",
    password="example-password",
    organization="organization",
    vpc_subnet_ids=[
        example1["id"],
        example2["id"],
    ],
    vpc_security_group_ids=[example_aws_security_group["id"]],
    name="example-db-cluster",
    log_delivery_configuration={
        "s3_configuration": {
            "bucket_name": example_bucket.bucket,
            "enabled": True,
        },
    })

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/timestreaminfluxdb"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleBucket, err := s3.NewBucket(ctx, "example", &s3.BucketArgs{
			Bucket:       pulumi.String("example-s3-bucket"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		example := iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
			Statements: iam.GetPolicyDocumentStatementArray{
				&iam.GetPolicyDocumentStatementArgs{
					Actions: pulumi.StringArray{
						pulumi.String("s3:PutObject"),
					},
					Principals: iam.GetPolicyDocumentStatementPrincipalArray{
						&iam.GetPolicyDocumentStatementPrincipalArgs{
							Type: pulumi.String("Service"),
							Identifiers: pulumi.StringArray{
								pulumi.String("timestream-influxdb.amazonaws.com"),
							},
						},
					},
					Resources: pulumi.StringArray{
						exampleBucket.Arn.ApplyT(func(arn string) (string, error) {
							return fmt.Sprintf("%v/*", arn), nil
						}).(pulumi.StringOutput),
					},
				},
			},
		}, nil)
		_, err = s3.NewBucketPolicy(ctx, "example", &s3.BucketPolicyArgs{
			Bucket: exampleBucket.ID(),
			Policy: pulumi.String(example.ApplyT(func(example iam.GetPolicyDocumentResult) (*string, error) {
				return &example.Json, nil
			}).(pulumi.StringPtrOutput)),
		})
		if err != nil {
			return err
		}
		_, err = timestreaminfluxdb.NewDbCluster(ctx, "example", &timestreaminfluxdb.DbClusterArgs{
			AllocatedStorage: pulumi.Int(20),
			Bucket:           pulumi.String("example-bucket-name"),
			DbInstanceType:   pulumi.String("db.influx.medium"),
			Username:         pulumi.String("admin"),
			Password:         pulumi.String("example-password"),
			Organization:     pulumi.String("organization"),
			VpcSubnetIds: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
			Name: pulumi.String("example-db-cluster"),
			LogDeliveryConfiguration: &timestreaminfluxdb.DbClusterLogDeliveryConfigurationArgs{
				S3Configuration: &timestreaminfluxdb.DbClusterLogDeliveryConfigurationS3ConfigurationArgs{
					BucketName: exampleBucket.Bucket,
					Enabled:    pulumi.Bool(true),
				},
			},
		})
		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 exampleBucket = new Aws.S3.Bucket("example", new()
    {
        BucketName = "example-s3-bucket",
        ForceDestroy = true,
    });

    var example = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Actions = new[]
                {
                    "s3:PutObject",
                },
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "Service",
                        Identifiers = new[]
                        {
                            "timestream-influxdb.amazonaws.com",
                        },
                    },
                },
                Resources = new[]
                {
                    $"{exampleBucket.Arn}/*",
                },
            },
        },
    });

    var exampleBucketPolicy = new Aws.S3.BucketPolicy("example", new()
    {
        Bucket = exampleBucket.Id,
        Policy = example.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

    var exampleDbCluster = new Aws.TimestreamInfluxDB.DbCluster("example", new()
    {
        AllocatedStorage = 20,
        Bucket = "example-bucket-name",
        DbInstanceType = "db.influx.medium",
        Username = "admin",
        Password = "example-password",
        Organization = "organization",
        VpcSubnetIds = new[]
        {
            example1.Id,
            example2.Id,
        },
        VpcSecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
        Name = "example-db-cluster",
        LogDeliveryConfiguration = new Aws.TimestreamInfluxDB.Inputs.DbClusterLogDeliveryConfigurationArgs
        {
            S3Configuration = new Aws.TimestreamInfluxDB.Inputs.DbClusterLogDeliveryConfigurationS3ConfigurationArgs
            {
                BucketName = exampleBucket.BucketName,
                Enabled = true,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.s3.BucketPolicy;
import com.pulumi.aws.s3.BucketPolicyArgs;
import com.pulumi.aws.timestreaminfluxdb.DbCluster;
import com.pulumi.aws.timestreaminfluxdb.DbClusterArgs;
import com.pulumi.aws.timestreaminfluxdb.inputs.DbClusterLogDeliveryConfigurationArgs;
import com.pulumi.aws.timestreaminfluxdb.inputs.DbClusterLogDeliveryConfigurationS3ConfigurationArgs;
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 exampleBucket = new Bucket("exampleBucket", BucketArgs.builder()
            .bucket("example-s3-bucket")
            .forceDestroy(true)
            .build());

        final var example = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .actions("s3:PutObject")
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("Service")
                    .identifiers("timestream-influxdb.amazonaws.com")
                    .build())
                .resources(exampleBucket.arn().applyValue(_arn -> String.format("%s/*", _arn)))
                .build())
            .build());

        var exampleBucketPolicy = new BucketPolicy("exampleBucketPolicy", BucketPolicyArgs.builder()
            .bucket(exampleBucket.id())
            .policy(example.applyValue(_example -> _example.json()))
            .build());

        var exampleDbCluster = new DbCluster("exampleDbCluster", DbClusterArgs.builder()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .username("admin")
            .password("example-password")
            .organization("organization")
            .vpcSubnetIds(            
                example1.id(),
                example2.id())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .name("example-db-cluster")
            .logDeliveryConfiguration(DbClusterLogDeliveryConfigurationArgs.builder()
                .s3Configuration(DbClusterLogDeliveryConfigurationS3ConfigurationArgs.builder()
                    .bucketName(exampleBucket.bucket())
                    .enabled(true)
                    .build())
                .build())
            .build());

    }
}

resources:
  exampleBucket:
    type: aws:s3:Bucket
    name: example
    properties:
      bucket: example-s3-bucket
      forceDestroy: true
  exampleBucketPolicy:
    type: aws:s3:BucketPolicy
    name: example
    properties:
      bucket: ${exampleBucket.id}
      policy: ${example.json}
  exampleDbCluster:
    type: aws:timestreaminfluxdb:DbCluster
    name: example
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      username: admin
      password: example-password
      organization: organization
      vpcSubnetIds:
        - ${example1.id}
        - ${example2.id}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      name: example-db-cluster
      logDeliveryConfiguration:
        s3Configuration:
          bucketName: ${exampleBucket.bucket}
          enabled: true
variables:
  example:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - actions:
              - s3:PutObject
            principals:
              - type: Service
                identifiers:
                  - timestream-influxdb.amazonaws.com
            resources:
              - ${exampleBucket.arn}/*

The logDeliveryConfiguration block enables S3 log delivery by specifying the bucket name and setting enabled to true. The S3 bucket policy must grant the timestream-influxdb.amazonaws.com service principal PutObject permissions. Logs flow continuously to the bucket as the cluster operates.

Deploy an InfluxDB V3 cluster

InfluxDB V3 clusters use a simplified configuration model based on parameter groups rather than explicit storage and authentication properties.

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

const example = new aws.timestreaminfluxdb.DbCluster("example", {
    name: "example-v3-cluster",
    dbInstanceType: "db.influx.large",
    dbParameterGroupIdentifier: "InfluxDBV3Core",
    vpcSubnetIds: [
        example1.id,
        example2.id,
    ],
    vpcSecurityGroupIds: [exampleAwsSecurityGroup.id],
});

import pulumi
import pulumi_aws as aws

example = aws.timestreaminfluxdb.DbCluster("example",
    name="example-v3-cluster",
    db_instance_type="db.influx.large",
    db_parameter_group_identifier="InfluxDBV3Core",
    vpc_subnet_ids=[
        example1["id"],
        example2["id"],
    ],
    vpc_security_group_ids=[example_aws_security_group["id"]])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := timestreaminfluxdb.NewDbCluster(ctx, "example", &timestreaminfluxdb.DbClusterArgs{
			Name:                       pulumi.String("example-v3-cluster"),
			DbInstanceType:             pulumi.String("db.influx.large"),
			DbParameterGroupIdentifier: pulumi.String("InfluxDBV3Core"),
			VpcSubnetIds: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
		})
		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.TimestreamInfluxDB.DbCluster("example", new()
    {
        Name = "example-v3-cluster",
        DbInstanceType = "db.influx.large",
        DbParameterGroupIdentifier = "InfluxDBV3Core",
        VpcSubnetIds = new[]
        {
            example1.Id,
            example2.Id,
        },
        VpcSecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.timestreaminfluxdb.DbCluster;
import com.pulumi.aws.timestreaminfluxdb.DbClusterArgs;
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 DbCluster("example", DbClusterArgs.builder()
            .name("example-v3-cluster")
            .dbInstanceType("db.influx.large")
            .dbParameterGroupIdentifier("InfluxDBV3Core")
            .vpcSubnetIds(            
                example1.id(),
                example2.id())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .build());

    }
}

resources:
  example:
    type: aws:timestreaminfluxdb:DbCluster
    properties:
      name: example-v3-cluster
      dbInstanceType: db.influx.large
      dbParameterGroupIdentifier: InfluxDBV3Core
      vpcSubnetIds:
        - ${example1.id}
        - ${example2.id}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}

The dbParameterGroupIdentifier property (set to “InfluxDBV3Core” or another V3 parameter group) tells Timestream to create a V3 cluster. When using a V3 parameter group, you cannot specify allocatedStorage, bucket, organization, username, password, or deploymentType; the API rejects these properties. Authentication for V3 clusters uses an admin token stored in Secrets Manager.

Beyond these examples

These snippets focus on specific cluster-level features: VPC networking and security group configuration, S3 log delivery with IAM policies, and InfluxDB V2 and V3 cluster variants. They’re intentionally minimal rather than full time-series database deployments.

The examples require pre-existing infrastructure such as VPC, subnets (minimum two in different AZs), security groups, S3 buckets with appropriate IAM policies (for log delivery), and an AWS Marketplace subscription to Timestream for InfluxDB Read Replicas. They focus on configuring the cluster rather than provisioning all surrounding infrastructure.

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

  • Public internet access configuration (publiclyAccessible)
  • Storage type selection and IOPS tuning (dbStorageType)
  • Instance type sizing (dbInstanceType variants)
  • Failover mode configuration (failoverMode)
  • Custom port configuration (port)

These omissions are intentional: the goal is to illustrate how each cluster feature is wired, not provide drop-in database modules. See the Timestream for InfluxDB DbCluster resource reference for all available configuration options.

Let's create AWS Timestream for InfluxDB Clusters

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

Try Pulumi Cloud for FREE

Frequently Asked Questions

Prerequisites & Setup
Do I need a marketplace subscription to use Timestream for InfluxDB clusters?
Yes, this resource requires an active subscription to Timestream for InfluxDB Read Replicas (Add-On) on AWS Marketplace before you can create clusters.
What VPC resources do I need for a Timestream InfluxDB cluster?
You need a VPC, at least two subnets in different availability zones, and a security group. Reference these in vpcSubnetIds and vpcSecurityGroupIds.
Cluster Types & Versions
What's the difference between InfluxDB V2 and V3 clusters?
V2 clusters require allocatedStorage, bucket, deploymentType, organization, password, and username. V3 clusters forbid all these fields and instead use dbParameterGroupIdentifier (like "InfluxDBV3Core"). Choose your cluster type carefully as the required fields are incompatible.
How do I create an InfluxDB V3 cluster?
Set dbParameterGroupIdentifier to "InfluxDBV3Core" and omit allocatedStorage, bucket, deploymentType, organization, password, and username.
Storage Configuration
What are the storage limits for Timestream InfluxDB clusters?
allocatedStorage ranges from 20 GiB (minimum) to 16384 GiB (maximum). However, if you use dbStorageType of "InfluxIOIncludedT2" or "InfluxIOIncludedT3", the minimum increases to 400 GiB.
What storage types are available and how do they differ?
Three IOPS tiers are available: "InfluxIOIncludedT1" (3000 IOPS, min 20 GiB), "InfluxIOIncludedT2" (12000 IOPS, min 400 GiB), and "InfluxIOIncludedT3" (16000 IOPS, min 400 GiB).
Networking & Access
What port restrictions apply to Timestream InfluxDB clusters?
Valid ports range from 1024 to 65535, but you cannot use 2375-2376, 7788-7799, 8090, or 51678-51680.
Authentication & Security
Where are my cluster credentials stored?
For V2 clusters, bucket, organization, username, and password are stored in AWS Secrets Manager (referenced by influxAuthParametersSecretArn). For V3 clusters, the secret contains the admin token.
What are the naming constraints for usernames and cluster names?
Both username and name must start with a letter, cannot contain consecutive hyphens, and cannot end with a hyphen.
How do I enable S3 log delivery for my cluster?
Configure logDeliveryConfiguration.s3Configuration with your bucket name and enabled: true. Your S3 bucket policy must allow s3:PutObject from the service principal timestream-influxdb.amazonaws.com.
Updates & Lifecycle
What happens if I remove dbParameterGroupIdentifier from my cluster?
Adding or changing dbParameterGroupIdentifier causes an in-place update. However, if your cluster already has a value and you remove it, the cluster will be destroyed and recreated.

Using a different cloud?

Explore database guides for other cloud providers:

Azure Guides GCP Guides