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 type, storage allocation, networking placement, and initial configuration. This guide focuses on three capabilities: InfluxDB V2 and V3 cluster creation, VPC networking prerequisites, and S3 log delivery configuration.

Timestream for InfluxDB clusters require VPC infrastructure and optionally S3 buckets with IAM policies for log delivery. This resource requires a subscription to Timestream for InfluxDB Read Replicas on AWS Marketplace. The examples are intentionally small. Combine them with your own VPC resources, security policies, and monitoring infrastructure.

Create a V2 cluster with initial admin credentials

Most InfluxDB V2 deployments start by creating a cluster with an initial organization, bucket, and admin user for accessing the InfluxDB UI and CLI.

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

const example = new aws.timestreaminfluxdb.DbCluster("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    failoverMode: "AUTOMATIC",
    username: "admin",
    password: "example-password",
    port: 8086,
    organization: "organization",
    vpcSubnetIds: [
        example1.id,
        example2.id,
    ],
    vpcSecurityGroupIds: [exampleAwsSecurityGroup.id],
    name: "example-db-cluster",
});

import pulumi
import pulumi_aws as aws

example = aws.timestreaminfluxdb.DbCluster("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    failover_mode="AUTOMATIC",
    username="admin",
    password="example-password",
    port=8086,
    organization="organization",
    vpc_subnet_ids=[
        example1["id"],
        example2["id"],
    ],
    vpc_security_group_ids=[example_aws_security_group["id"]],
    name="example-db-cluster")

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{
			AllocatedStorage: pulumi.Int(20),
			Bucket:           pulumi.String("example-bucket-name"),
			DbInstanceType:   pulumi.String("db.influx.medium"),
			FailoverMode:     pulumi.String("AUTOMATIC"),
			Username:         pulumi.String("admin"),
			Password:         pulumi.String("example-password"),
			Port:             pulumi.Int(8086),
			Organization:     pulumi.String("organization"),
			VpcSubnetIds: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.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.TimestreamInfluxDB.DbCluster("example", new()
    {
        AllocatedStorage = 20,
        Bucket = "example-bucket-name",
        DbInstanceType = "db.influx.medium",
        FailoverMode = "AUTOMATIC",
        Username = "admin",
        Password = "example-password",
        Port = 8086,
        Organization = "organization",
        VpcSubnetIds = new[]
        {
            example1.Id,
            example2.Id,
        },
        VpcSecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.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.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()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .failoverMode("AUTOMATIC")
            .username("admin")
            .password("example-password")
            .port(8086)
            .organization("organization")
            .vpcSubnetIds(            
                example1.id(),
                example2.id())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .name("example-db-cluster")
            .build());

    }
}

resources:
  example:
    type: aws:timestreaminfluxdb:DbCluster
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      failoverMode: AUTOMATIC
      username: admin
      password: example-password
      port: 8086
      organization: organization
      vpcSubnetIds:
        - ${example1.id}
        - ${example2.id}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      name: example-db-cluster

The cluster provisions storage (allocatedStorage), creates an initial bucket for time-series data, and establishes admin credentials (username, password, organization). These credentials are automatically stored in AWS Secrets Manager, referenced by the influxAuthParametersSecretArn output. The vpcSubnetIds must reference at least two subnets in different availability zones.

Provision VPC infrastructure alongside the cluster

Teams creating their first cluster need to understand the networking prerequisites: a VPC, at least two subnets, and a security group.

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

This configuration creates the complete networking foundation. The Vpc defines the network boundary, two Subnets provide multi-AZ placement, and the SecurityGroup controls inbound access. The cluster references these resources via vpcSubnetIds and vpcSecurityGroupIds.

Send InfluxDB engine logs to S3

Production deployments often route engine logs to S3 for centralized analysis and long-term retention.

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. The BucketPolicy grants the Timestream for InfluxDB service principal (timestream-influxdb.amazonaws.com) permission to write logs. The s3Configuration specifies the target bucket and enables delivery.

Create a V3 cluster with parameter group

InfluxDB V3 clusters use a different configuration model that omits V2-specific properties like organization and bucket.

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 selects the InfluxDB V3 engine by specifying “InfluxDBV3Core”. V3 clusters do not accept allocatedStorage, bucket, organization, username, password, or deploymentType properties. The cluster still requires VPC networking configuration.

Beyond these examples

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

The examples reference pre-existing infrastructure such as VPC, subnets (at least two in different AZs), security groups, and S3 buckets with appropriate IAM policies for log delivery. They focus on configuring the cluster rather than provisioning all surrounding infrastructure.

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

Failover mode configuration (failoverMode)
Custom port assignment (port)
Storage type selection (dbStorageType) and IOPS tuning
Public accessibility and internet gateway setup
Tags for cost allocation and organization

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 an AWS Marketplace subscription to use Timestream for InfluxDB?

Yes, you must subscribe to Timestream for InfluxDB Read Replicas (Add-On) on the AWS Marketplace before creating clusters.

What VPC resources do I need to create a cluster?

You need a VPC, at least two subnets in different availability zones, and a security group. The vpcSubnetIds property requires at least two subnet IDs for Multi-AZ deployments.

Cluster Types & Configuration

What's the difference between InfluxDB V2 and V3 clusters?

V2 clusters (default) require allocatedStorage, bucket, deploymentType, organization, password, and username. V3 clusters use dbParameterGroupIdentifier (like “InfluxDBV3Core”) and forbid those V2-specific fields.

What happens if I remove dbParameterGroupIdentifier from an existing cluster?

Removing dbParameterGroupIdentifier causes the cluster to be destroyed and recreated. Adding or changing it triggers an in-place update, but removal requires recreation.

Where are my InfluxDB credentials stored?

Credentials are stored in AWS Secrets Manager. For V2 clusters, the secret contains bucket, organization, username, and password as JSON. For V3 clusters, it contains the admin token. Access the secret ARN via the influxAuthParametersSecretArn attribute.

Storage & Performance

What are the storage configuration options and limits?

Storage ranges from 20 GiB (minimum) to 16,384 GiB (maximum). Three storage types are available:

InfluxIOIncludedT1: 3000 IOPS, minimum 20 GiB
InfluxIOIncludedT2: 12,000 IOPS, minimum 400 GiB
InfluxIOIncludedT3: 16,000 IOPS, minimum 400 GiB

Networking & Ports

Which ports can I use for my cluster?

Valid ports range from 1024 to 65535, excluding 2375-2376, 7788-7799, 8090, and 51678-51680.

Naming & Validation

What are the naming rules for cluster names?

Cluster names must start with a letter, cannot contain consecutive hyphens, and cannot end with a hyphen. Names must be unique per customer and region.

What are the username constraints for the initial admin user?

Usernames must start with a letter, can’t end with a hyphen, and can’t contain two consecutive hyphens.

Optional Features

How do I enable S3 log delivery for my cluster?

Configure logDeliveryConfiguration.s3Configuration with bucketName and enabled: true. You must also create an S3 bucket policy allowing timestream-influxdb.amazonaws.com to perform s3:PutObject on your bucket.

Using a different cloud?

Explore database guides for other cloud providers:

Azure Guides GCP Guides