Create AWS Timestream for InfluxDB Instances

The aws:timestreaminfluxdb/dbInstance:DbInstance resource, part of the Pulumi AWS provider, provisions a Timestream for InfluxDB database instance: its compute size, storage capacity, network placement, and initial InfluxDB configuration. This guide focuses on three capabilities: VPC networking and subnet placement, S3 log delivery, and Multi-AZ deployment.

Timestream for InfluxDB instances require VPC infrastructure and may reference S3 buckets for log delivery. The examples are intentionally small. Combine them with your own VPC configuration, security groups, and monitoring infrastructure.

Create an instance with VPC networking

Timestream for InfluxDB instances require VPC infrastructure to control network access and placement.

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 exampleSubnet = new aws.ec2.Subnet("example", {
    vpcId: example.id,
    cidrBlock: "10.0.1.0/24",
});
const exampleSecurityGroup = new aws.ec2.SecurityGroup("example", {
    name: "example",
    vpcId: example.id,
});
const exampleDbInstance = new aws.timestreaminfluxdb.DbInstance("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    username: "admin",
    password: "example-password",
    organization: "organization",
    vpcSubnetIds: [exampleSubnet.id],
    vpcSecurityGroupIds: [exampleSecurityGroup.id],
    name: "example-db-instance",
});

import pulumi
import pulumi_aws as aws

example = aws.ec2.Vpc("example", cidr_block="10.0.0.0/16")
example_subnet = aws.ec2.Subnet("example",
    vpc_id=example.id,
    cidr_block="10.0.1.0/24")
example_security_group = aws.ec2.SecurityGroup("example",
    name="example",
    vpc_id=example.id)
example_db_instance = aws.timestreaminfluxdb.DbInstance("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    username="admin",
    password="example-password",
    organization="organization",
    vpc_subnet_ids=[example_subnet.id],
    vpc_security_group_ids=[example_security_group.id],
    name="example-db-instance")

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
		}
		exampleSubnet, err := ec2.NewSubnet(ctx, "example", &ec2.SubnetArgs{
			VpcId:     example.ID(),
			CidrBlock: pulumi.String("10.0.1.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.NewDbInstance(ctx, "example", &timestreaminfluxdb.DbInstanceArgs{
			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{
				exampleSubnet.ID(),
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleSecurityGroup.ID(),
			},
			Name: pulumi.String("example-db-instance"),
		})
		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 exampleSubnet = new Aws.Ec2.Subnet("example", new()
    {
        VpcId = example.Id,
        CidrBlock = "10.0.1.0/24",
    });

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

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

});

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.DbInstance;
import com.pulumi.aws.timestreaminfluxdb.DbInstanceArgs;
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 exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
            .vpcId(example.id())
            .cidrBlock("10.0.1.0/24")
            .build());

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

        var exampleDbInstance = new DbInstance("exampleDbInstance", DbInstanceArgs.builder()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .username("admin")
            .password("example-password")
            .organization("organization")
            .vpcSubnetIds(exampleSubnet.id())
            .vpcSecurityGroupIds(exampleSecurityGroup.id())
            .name("example-db-instance")
            .build());

    }
}

resources:
  example:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
  exampleSubnet:
    type: aws:ec2:Subnet
    name: example
    properties:
      vpcId: ${example.id}
      cidrBlock: 10.0.1.0/24
  exampleSecurityGroup:
    type: aws:ec2:SecurityGroup
    name: example
    properties:
      name: example
      vpcId: ${example.id}
  exampleDbInstance:
    type: aws:timestreaminfluxdb:DbInstance
    name: example
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      username: admin
      password: example-password
      organization: organization
      vpcSubnetIds:
        - ${exampleSubnet.id}
      vpcSecurityGroupIds:
        - ${exampleSecurityGroup.id}
      name: example-db-instance

The vpcSubnetIds property places the instance in specified subnets, while vpcSecurityGroupIds controls inbound and outbound traffic. The bucket, organization, username, and password properties initialize InfluxDB’s first organization and admin user; these credentials are stored in AWS Secrets Manager and referenced via the influxAuthParametersSecretArn output. The allocatedStorage property sets storage capacity in GiB (minimum 20, maximum 16384), and dbInstanceType determines compute resources.

Send InfluxDB engine logs to S3

Teams monitoring database health route InfluxDB engine logs to S3 for centralized analysis.

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 exampleDbInstance = new aws.timestreaminfluxdb.DbInstance("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    username: "admin",
    password: "example-password",
    organization: "organization",
    vpcSubnetIds: [exampleAwsSubnet.id],
    vpcSecurityGroupIds: [exampleAwsSecurityGroup.id],
    name: "example-db-instance",
    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_instance = aws.timestreaminfluxdb.DbInstance("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    username="admin",
    password="example-password",
    organization="organization",
    vpc_subnet_ids=[example_aws_subnet["id"]],
    vpc_security_group_ids=[example_aws_security_group["id"]],
    name="example-db-instance",
    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.NewDbInstance(ctx, "example", &timestreaminfluxdb.DbInstanceArgs{
			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{
				exampleAwsSubnet.Id,
			},
			VpcSecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
			Name: pulumi.String("example-db-instance"),
			LogDeliveryConfiguration: &timestreaminfluxdb.DbInstanceLogDeliveryConfigurationArgs{
				S3Configuration: &timestreaminfluxdb.DbInstanceLogDeliveryConfigurationS3ConfigurationArgs{
					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 exampleDbInstance = new Aws.TimestreamInfluxDB.DbInstance("example", new()
    {
        AllocatedStorage = 20,
        Bucket = "example-bucket-name",
        DbInstanceType = "db.influx.medium",
        Username = "admin",
        Password = "example-password",
        Organization = "organization",
        VpcSubnetIds = new[]
        {
            exampleAwsSubnet.Id,
        },
        VpcSecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
        Name = "example-db-instance",
        LogDeliveryConfiguration = new Aws.TimestreamInfluxDB.Inputs.DbInstanceLogDeliveryConfigurationArgs
        {
            S3Configuration = new Aws.TimestreamInfluxDB.Inputs.DbInstanceLogDeliveryConfigurationS3ConfigurationArgs
            {
                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.DbInstance;
import com.pulumi.aws.timestreaminfluxdb.DbInstanceArgs;
import com.pulumi.aws.timestreaminfluxdb.inputs.DbInstanceLogDeliveryConfigurationArgs;
import com.pulumi.aws.timestreaminfluxdb.inputs.DbInstanceLogDeliveryConfigurationS3ConfigurationArgs;
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 exampleDbInstance = new DbInstance("exampleDbInstance", DbInstanceArgs.builder()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .username("admin")
            .password("example-password")
            .organization("organization")
            .vpcSubnetIds(exampleAwsSubnet.id())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .name("example-db-instance")
            .logDeliveryConfiguration(DbInstanceLogDeliveryConfigurationArgs.builder()
                .s3Configuration(DbInstanceLogDeliveryConfigurationS3ConfigurationArgs.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}
  exampleDbInstance:
    type: aws:timestreaminfluxdb:DbInstance
    name: example
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      username: admin
      password: example-password
      organization: organization
      vpcSubnetIds:
        - ${exampleAwsSubnet.id}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      name: example-db-instance
      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 a bucket name and setting enabled to true. The S3 bucket requires a policy that grants the timestream-influxdb.amazonaws.com service principal PutObject permissions. Logs flow continuously to the specified bucket, allowing integration with log analysis tools.

Deploy with Multi-AZ standby for high availability

Production workloads use Multi-AZ deployments to maintain availability during infrastructure failures.

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

const example1 = new aws.ec2.Subnet("example_1", {
    vpcId: exampleAwsVpc.id,
    cidrBlock: "10.0.1.0/24",
    availabilityZone: "us-west-2a",
});
const example2 = new aws.ec2.Subnet("example_2", {
    vpcId: exampleAwsVpc.id,
    cidrBlock: "10.0.2.0/24",
    availabilityZone: "us-west-2b",
});
const example = new aws.timestreaminfluxdb.DbInstance("example", {
    allocatedStorage: 20,
    bucket: "example-bucket-name",
    dbInstanceType: "db.influx.medium",
    deploymentType: "WITH_MULTIAZ_STANDBY",
    username: "admin",
    password: "example-password",
    organization: "organization",
    vpcSubnetIds: [
        example1.id,
        example2.id,
    ],
    vpcSecurityGroupIds: [exampleAwsSecurityGroup.id],
    name: "example-db-instance",
});

import pulumi
import pulumi_aws as aws

example1 = aws.ec2.Subnet("example_1",
    vpc_id=example_aws_vpc["id"],
    cidr_block="10.0.1.0/24",
    availability_zone="us-west-2a")
example2 = aws.ec2.Subnet("example_2",
    vpc_id=example_aws_vpc["id"],
    cidr_block="10.0.2.0/24",
    availability_zone="us-west-2b")
example = aws.timestreaminfluxdb.DbInstance("example",
    allocated_storage=20,
    bucket="example-bucket-name",
    db_instance_type="db.influx.medium",
    deployment_type="WITH_MULTIAZ_STANDBY",
    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-instance")

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 {
		example1, err := ec2.NewSubnet(ctx, "example_1", &ec2.SubnetArgs{
			VpcId:            pulumi.Any(exampleAwsVpc.Id),
			CidrBlock:        pulumi.String("10.0.1.0/24"),
			AvailabilityZone: pulumi.String("us-west-2a"),
		})
		if err != nil {
			return err
		}
		example2, err := ec2.NewSubnet(ctx, "example_2", &ec2.SubnetArgs{
			VpcId:            pulumi.Any(exampleAwsVpc.Id),
			CidrBlock:        pulumi.String("10.0.2.0/24"),
			AvailabilityZone: pulumi.String("us-west-2b"),
		})
		if err != nil {
			return err
		}
		_, err = timestreaminfluxdb.NewDbInstance(ctx, "example", &timestreaminfluxdb.DbInstanceArgs{
			AllocatedStorage: pulumi.Int(20),
			Bucket:           pulumi.String("example-bucket-name"),
			DbInstanceType:   pulumi.String("db.influx.medium"),
			DeploymentType:   pulumi.String("WITH_MULTIAZ_STANDBY"),
			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-instance"),
		})
		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 example1 = new Aws.Ec2.Subnet("example_1", new()
    {
        VpcId = exampleAwsVpc.Id,
        CidrBlock = "10.0.1.0/24",
        AvailabilityZone = "us-west-2a",
    });

    var example2 = new Aws.Ec2.Subnet("example_2", new()
    {
        VpcId = exampleAwsVpc.Id,
        CidrBlock = "10.0.2.0/24",
        AvailabilityZone = "us-west-2b",
    });

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

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Subnet;
import com.pulumi.aws.ec2.SubnetArgs;
import com.pulumi.aws.timestreaminfluxdb.DbInstance;
import com.pulumi.aws.timestreaminfluxdb.DbInstanceArgs;
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 example1 = new Subnet("example1", SubnetArgs.builder()
            .vpcId(exampleAwsVpc.id())
            .cidrBlock("10.0.1.0/24")
            .availabilityZone("us-west-2a")
            .build());

        var example2 = new Subnet("example2", SubnetArgs.builder()
            .vpcId(exampleAwsVpc.id())
            .cidrBlock("10.0.2.0/24")
            .availabilityZone("us-west-2b")
            .build());

        var example = new DbInstance("example", DbInstanceArgs.builder()
            .allocatedStorage(20)
            .bucket("example-bucket-name")
            .dbInstanceType("db.influx.medium")
            .deploymentType("WITH_MULTIAZ_STANDBY")
            .username("admin")
            .password("example-password")
            .organization("organization")
            .vpcSubnetIds(            
                example1.id(),
                example2.id())
            .vpcSecurityGroupIds(exampleAwsSecurityGroup.id())
            .name("example-db-instance")
            .build());

    }
}

resources:
  example1:
    type: aws:ec2:Subnet
    name: example_1
    properties:
      vpcId: ${exampleAwsVpc.id}
      cidrBlock: 10.0.1.0/24
      availabilityZone: us-west-2a
  example2:
    type: aws:ec2:Subnet
    name: example_2
    properties:
      vpcId: ${exampleAwsVpc.id}
      cidrBlock: 10.0.2.0/24
      availabilityZone: us-west-2b
  example:
    type: aws:timestreaminfluxdb:DbInstance
    properties:
      allocatedStorage: 20
      bucket: example-bucket-name
      dbInstanceType: db.influx.medium
      deploymentType: WITH_MULTIAZ_STANDBY
      username: admin
      password: example-password
      organization: organization
      vpcSubnetIds:
        - ${example1.id}
        - ${example2.id}
      vpcSecurityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      name: example-db-instance

The deploymentType property set to WITH_MULTIAZ_STANDBY creates a standby instance in a second availability zone. The vpcSubnetIds array must include subnets from at least two different zones. During a failure, Timestream for InfluxDB automatically fails over to the standby instance, minimizing downtime.

Beyond these examples

These snippets focus on specific instance-level features: VPC networking and subnet placement, S3 log delivery with IAM policies, and Multi-AZ deployment for high availability. They’re intentionally minimal rather than full time-series database deployments.

The examples reference pre-existing infrastructure such as VPC, subnets, and security groups, and S3 buckets with appropriate IAM policies for logging. They focus on configuring the database instance rather than provisioning everything around it.

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

Storage type selection (dbStorageType) and IOPS tiers
Public internet access configuration (publiclyAccessible)
DB parameter groups (dbParameterGroupIdentifier)
Network type selection (networkType for IPv4/IPv6)

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

Let's create AWS Timestream for InfluxDB Instances

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

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration Updates & Lifecycle

Why was my instance destroyed when I removed the DB parameter group?

Removing dbParameterGroupIdentifier after it’s been set causes the instance to be destroyed and recreated, not updated in-place. Once you’ve assigned a parameter group, keep it set or plan for instance recreation.

Why can't I update my storage type again?

For single instances, dbStorageType has a 6-hour cooldown after each update. You must wait 6 hours between storage type changes.

Storage & Performance

What are the storage limits and how do they relate to storage type?

Storage ranges from 20 to 16,384 GiB via allocatedStorage. However, the minimum depends on dbStorageType:

InfluxIOIncludedT1 (3000 IOPS): 20 GiB minimum
InfluxIOIncludedT2 (12000 IOPS): 400 GiB minimum
InfluxIOIncludedT3 (16000 IOPS): 400 GiB minimum

What instance types are available?

Valid dbInstanceType values are: db.influx.medium, db.influx.large, db.influx.xlarge, db.influx.2xlarge, db.influx.4xlarge, db.influx.8xlarge, db.influx.12xlarge, and db.influx.16xlarge.

High Availability & Networking

How do I configure Multi-AZ deployment for high availability?

Set deploymentType to WITH_MULTIAZ_STANDBY and provide at least two subnet IDs in different availability zones via vpcSubnetIds.

What networking resources are required?

All instances require a VPC, at least one subnet, and security groups (specified via vpcSubnetIds and vpcSecurityGroupIds). For public internet access, you also need an internet gateway and route table with appropriate routes.

Can I make my instance publicly accessible?

Yes, set publiclyAccessible to true. However, you must also configure a VPC, subnet, internet gateway, and route table to enable actual public access.

Security & Access

Where are my InfluxDB credentials stored?

The username, password, bucket, and organization values are automatically stored in AWS Secrets Manager. Access the secret ARN via the influxAuthParametersSecretArn output attribute.

What ports can I use for my InfluxDB instance?

Valid ports range from 1024 to 65535, but you cannot use: 2375-2376, 7788-7799, 8090, or 51678-51680.

What are the naming requirements for the instance?

The name must start with a letter, cannot contain consecutive hyphens, and cannot end with a hyphen.

Logging & Monitoring

How do I enable S3 log delivery?

Configure logDeliveryConfiguration.s3Configuration with bucketName and enabled: true. Your S3 bucket must have a policy allowing the timestream-influxdb.amazonaws.com service principal to perform s3:PutObject actions.

Using a different cloud?

Explore database guides for other cloud providers:

Azure Guides GCP Guides