pulumi-digitalocean-kotlin/com.pulumi.digitalocean.kotlin/DatabaseCluster

DatabaseCluster

class DatabaseCluster : KotlinCustomResource

Provides a DigitalOcean database cluster resource.

Example Usage

Create a new PostgreSQL database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const postgres_example = new digitalocean.DatabaseCluster("postgres-example", {
    name: "example-postgres-cluster",
    engine: "pg",
    version: "15",
    size: digitalocean.DatabaseSlug.DB_1VPCU1GB,
    region: digitalocean.Region.NYC1,
    nodeCount: 1,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
postgres_example = digitalocean.DatabaseCluster("postgres-example",
    name="example-postgres-cluster",
    engine="pg",
    version="15",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
    region=digitalocean.Region.NYC1,
    node_count=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var postgres_example = new DigitalOcean.DatabaseCluster("postgres-example", new()
    {
        Name = "example-postgres-cluster",
        Engine = "pg",
        Version = "15",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU1GB,
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "postgres-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-postgres-cluster"),
			Engine:    pulumi.String("pg"),
			Version:   pulumi.String("15"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU1GB),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 postgres_example = new DatabaseCluster("postgres-example", DatabaseClusterArgs.builder()
            .name("example-postgres-cluster")
            .engine("pg")
            .version("15")
            .size("db-s-1vcpu-1gb")
            .region("nyc1")
            .nodeCount(1)
            .build());
    }
}
Content copied to clipboard
resources:
  postgres-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-postgres-cluster
      engine: pg
      version: '15'
      size: db-s-1vcpu-1gb
      region: nyc1
      nodeCount: 1
Content copied to clipboard

Create a new MySQL database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const mysql_example = new digitalocean.DatabaseCluster("mysql-example", {
    name: "example-mysql-cluster",
    engine: "mysql",
    version: "8",
    size: digitalocean.DatabaseSlug.DB_1VPCU1GB,
    region: digitalocean.Region.NYC1,
    nodeCount: 1,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
mysql_example = digitalocean.DatabaseCluster("mysql-example",
    name="example-mysql-cluster",
    engine="mysql",
    version="8",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
    region=digitalocean.Region.NYC1,
    node_count=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var mysql_example = new DigitalOcean.DatabaseCluster("mysql-example", new()
    {
        Name = "example-mysql-cluster",
        Engine = "mysql",
        Version = "8",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU1GB,
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "mysql-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-mysql-cluster"),
			Engine:    pulumi.String("mysql"),
			Version:   pulumi.String("8"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU1GB),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 mysql_example = new DatabaseCluster("mysql-example", DatabaseClusterArgs.builder()
            .name("example-mysql-cluster")
            .engine("mysql")
            .version("8")
            .size("db-s-1vcpu-1gb")
            .region("nyc1")
            .nodeCount(1)
            .build());
    }
}
Content copied to clipboard
resources:
  mysql-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-mysql-cluster
      engine: mysql
      version: '8'
      size: db-s-1vcpu-1gb
      region: nyc1
      nodeCount: 1
Content copied to clipboard

Create a new Valkey database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const valkey_example = new digitalocean.DatabaseCluster("valkey-example", {
    name: "example-valkey-cluster",
    engine: "valkey",
    version: "8",
    size: digitalocean.DatabaseSlug.DB_1VPCU1GB,
    region: digitalocean.Region.NYC1,
    nodeCount: 1,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
valkey_example = digitalocean.DatabaseCluster("valkey-example",
    name="example-valkey-cluster",
    engine="valkey",
    version="8",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
    region=digitalocean.Region.NYC1,
    node_count=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var valkey_example = new DigitalOcean.DatabaseCluster("valkey-example", new()
    {
        Name = "example-valkey-cluster",
        Engine = "valkey",
        Version = "8",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU1GB,
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "valkey-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-valkey-cluster"),
			Engine:    pulumi.String("valkey"),
			Version:   pulumi.String("8"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU1GB),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 valkey_example = new DatabaseCluster("valkey-example", DatabaseClusterArgs.builder()
            .name("example-valkey-cluster")
            .engine("valkey")
            .version("8")
            .size("db-s-1vcpu-1gb")
            .region("nyc1")
            .nodeCount(1)
            .build());
    }
}
Content copied to clipboard
resources:
  valkey-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-valkey-cluster
      engine: valkey
      version: '8'
      size: db-s-1vcpu-1gb
      region: nyc1
      nodeCount: 1
Content copied to clipboard

Create a new Kafka database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const kafka_example = new digitalocean.DatabaseCluster("kafka-example", {
    name: "example-kafka-cluster",
    engine: "kafka",
    version: "3.5",
    size: "db-s-2vcpu-2gb",
    region: digitalocean.Region.NYC1,
    nodeCount: 3,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
kafka_example = digitalocean.DatabaseCluster("kafka-example",
    name="example-kafka-cluster",
    engine="kafka",
    version="3.5",
    size="db-s-2vcpu-2gb",
    region=digitalocean.Region.NYC1,
    node_count=3)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var kafka_example = new DigitalOcean.DatabaseCluster("kafka-example", new()
    {
        Name = "example-kafka-cluster",
        Engine = "kafka",
        Version = "3.5",
        Size = "db-s-2vcpu-2gb",
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 3,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "kafka-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-kafka-cluster"),
			Engine:    pulumi.String("kafka"),
			Version:   pulumi.String("3.5"),
			Size:      pulumi.String("db-s-2vcpu-2gb"),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(3),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 kafka_example = new DatabaseCluster("kafka-example", DatabaseClusterArgs.builder()
            .name("example-kafka-cluster")
            .engine("kafka")
            .version("3.5")
            .size("db-s-2vcpu-2gb")
            .region("nyc1")
            .nodeCount(3)
            .build());
    }
}
Content copied to clipboard
resources:
  kafka-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-kafka-cluster
      engine: kafka
      version: '3.5'
      size: db-s-2vcpu-2gb
      region: nyc1
      nodeCount: 3
Content copied to clipboard

Create a new MongoDB database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const mongodb_example = new digitalocean.DatabaseCluster("mongodb-example", {
    name: "example-mongo-cluster",
    engine: "mongodb",
    version: "6",
    size: digitalocean.DatabaseSlug.DB_1VPCU1GB,
    region: digitalocean.Region.NYC3,
    nodeCount: 1,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
mongodb_example = digitalocean.DatabaseCluster("mongodb-example",
    name="example-mongo-cluster",
    engine="mongodb",
    version="6",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
    region=digitalocean.Region.NYC3,
    node_count=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var mongodb_example = new DigitalOcean.DatabaseCluster("mongodb-example", new()
    {
        Name = "example-mongo-cluster",
        Engine = "mongodb",
        Version = "6",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU1GB,
        Region = DigitalOcean.Region.NYC3,
        NodeCount = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "mongodb-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-mongo-cluster"),
			Engine:    pulumi.String("mongodb"),
			Version:   pulumi.String("6"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU1GB),
			Region:    pulumi.String(digitalocean.RegionNYC3),
			NodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 mongodb_example = new DatabaseCluster("mongodb-example", DatabaseClusterArgs.builder()
            .name("example-mongo-cluster")
            .engine("mongodb")
            .version("6")
            .size("db-s-1vcpu-1gb")
            .region("nyc3")
            .nodeCount(1)
            .build());
    }
}
Content copied to clipboard
resources:
  mongodb-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-mongo-cluster
      engine: mongodb
      version: '6'
      size: db-s-1vcpu-1gb
      region: nyc3
      nodeCount: 1
Content copied to clipboard

Create a new OpenSearch database cluster

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const opensearch_example = new digitalocean.DatabaseCluster("opensearch-example", {
    name: "example-opensearch-cluster",
    engine: "opensearch",
    version: "2",
    size: digitalocean.DatabaseSlug.DB_1VPCU2GB,
    region: digitalocean.Region.NYC3,
    nodeCount: 1,
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
opensearch_example = digitalocean.DatabaseCluster("opensearch-example",
    name="example-opensearch-cluster",
    engine="opensearch",
    version="2",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU2_GB,
    region=digitalocean.Region.NYC3,
    node_count=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var opensearch_example = new DigitalOcean.DatabaseCluster("opensearch-example", new()
    {
        Name = "example-opensearch-cluster",
        Engine = "opensearch",
        Version = "2",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU2GB,
        Region = DigitalOcean.Region.NYC3,
        NodeCount = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.NewDatabaseCluster(ctx, "opensearch-example", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("example-opensearch-cluster"),
			Engine:    pulumi.String("opensearch"),
			Version:   pulumi.String("2"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU2GB),
			Region:    pulumi.String(digitalocean.RegionNYC3),
			NodeCount: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
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 opensearch_example = new DatabaseCluster("opensearch-example", DatabaseClusterArgs.builder()
            .name("example-opensearch-cluster")
            .engine("opensearch")
            .version("2")
            .size("db-s-1vcpu-2gb")
            .region("nyc3")
            .nodeCount(1)
            .build());
    }
}
Content copied to clipboard
resources:
  opensearch-example:
    type: digitalocean:DatabaseCluster
    properties:
      name: example-opensearch-cluster
      engine: opensearch
      version: '2'
      size: db-s-1vcpu-2gb
      region: nyc3
      nodeCount: 1
Content copied to clipboard

Create a new database cluster based on a backup of an existing cluster.

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
const doby = new digitalocean.DatabaseCluster("doby", {
    name: "dobydb",
    engine: "pg",
    version: "15",
    size: digitalocean.DatabaseSlug.DB_1VPCU2GB,
    region: digitalocean.Region.NYC1,
    nodeCount: 1,
    tags: ["production"],
});
const dobyBackup = new digitalocean.DatabaseCluster("doby_backup", {
    name: "dobydupe",
    engine: "pg",
    version: "15",
    size: digitalocean.DatabaseSlug.DB_1VPCU2GB,
    region: digitalocean.Region.NYC1,
    nodeCount: 1,
    tags: ["production"],
    backupRestore: {
        databaseName: "dobydb",
    },
}, {
    dependsOn: [doby],
});
Content copied to clipboard
import pulumi
import pulumi_digitalocean as digitalocean
doby = digitalocean.DatabaseCluster("doby",
    name="dobydb",
    engine="pg",
    version="15",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU2_GB,
    region=digitalocean.Region.NYC1,
    node_count=1,
    tags=["production"])
doby_backup = digitalocean.DatabaseCluster("doby_backup",
    name="dobydupe",
    engine="pg",
    version="15",
    size=digitalocean.DatabaseSlug.D_B_1_VPCU2_GB,
    region=digitalocean.Region.NYC1,
    node_count=1,
    tags=["production"],
    backup_restore={
        "database_name": "dobydb",
    },
    opts = pulumi.ResourceOptions(depends_on=[doby]))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
return await Deployment.RunAsync(() =>
{
    var doby = new DigitalOcean.DatabaseCluster("doby", new()
    {
        Name = "dobydb",
        Engine = "pg",
        Version = "15",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU2GB,
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 1,
        Tags = new[]
        {
            "production",
        },
    });
    var dobyBackup = new DigitalOcean.DatabaseCluster("doby_backup", new()
    {
        Name = "dobydupe",
        Engine = "pg",
        Version = "15",
        Size = DigitalOcean.DatabaseSlug.DB_1VPCU2GB,
        Region = DigitalOcean.Region.NYC1,
        NodeCount = 1,
        Tags = new[]
        {
            "production",
        },
        BackupRestore = new DigitalOcean.Inputs.DatabaseClusterBackupRestoreArgs
        {
            DatabaseName = "dobydb",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            doby,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		doby, err := digitalocean.NewDatabaseCluster(ctx, "doby", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("dobydb"),
			Engine:    pulumi.String("pg"),
			Version:   pulumi.String("15"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU2GB),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(1),
			Tags: pulumi.StringArray{
				pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		_, err = digitalocean.NewDatabaseCluster(ctx, "doby_backup", &digitalocean.DatabaseClusterArgs{
			Name:      pulumi.String("dobydupe"),
			Engine:    pulumi.String("pg"),
			Version:   pulumi.String("15"),
			Size:      pulumi.String(digitalocean.DatabaseSlug_DB_1VPCU2GB),
			Region:    pulumi.String(digitalocean.RegionNYC1),
			NodeCount: pulumi.Int(1),
			Tags: pulumi.StringArray{
				pulumi.String("production"),
			},
			BackupRestore: &digitalocean.DatabaseClusterBackupRestoreArgs{
				DatabaseName: pulumi.String("dobydb"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			doby,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DatabaseCluster;
import com.pulumi.digitalocean.DatabaseClusterArgs;
import com.pulumi.digitalocean.inputs.DatabaseClusterBackupRestoreArgs;
import com.pulumi.resources.CustomResourceOptions;
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 doby = new DatabaseCluster("doby", DatabaseClusterArgs.builder()
            .name("dobydb")
            .engine("pg")
            .version("15")
            .size("db-s-1vcpu-2gb")
            .region("nyc1")
            .nodeCount(1)
            .tags("production")
            .build());
        var dobyBackup = new DatabaseCluster("dobyBackup", DatabaseClusterArgs.builder()
            .name("dobydupe")
            .engine("pg")
            .version("15")
            .size("db-s-1vcpu-2gb")
            .region("nyc1")
            .nodeCount(1)
            .tags("production")
            .backupRestore(DatabaseClusterBackupRestoreArgs.builder()
                .databaseName("dobydb")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(doby)
                .build());
    }
}
Content copied to clipboard
resources:
  doby:
    type: digitalocean:DatabaseCluster
    properties:
      name: dobydb
      engine: pg
      version: '15'
      size: db-s-1vcpu-2gb
      region: nyc1
      nodeCount: 1
      tags:
        - production
  dobyBackup:
    type: digitalocean:DatabaseCluster
    name: doby_backup
    properties:
      name: dobydupe
      engine: pg
      version: '15'
      size: db-s-1vcpu-2gb
      region: nyc1
      nodeCount: 1
      tags:
        - production
      backupRestore:
        databaseName: dobydb
    options:
      dependsOn:
        - ${doby}
Content copied to clipboard

Import

Database clusters can be imported using the id returned from DigitalOcean, e.g.

$ pulumi import digitalocean:index/databaseCluster:DatabaseCluster mycluster 245bcfd0-7f31-4ce6-a2bc-475a116cca97
Content copied to clipboard

Properties

Link copied to clipboard
Link copied to clipboard
val clusterUrn: Output<String>

The uniform resource name of the database cluster.

Link copied to clipboard
val database: Output<String>

Name of the cluster's default database.

Link copied to clipboard
val engine: Output<String>

Database engine used by the cluster (ex. pg for PostgreSQL, mysql for MySQL, valkey for Valkey, mongodb for MongoDB, or kafka for Kafka).

Link copied to clipboard
val evictionPolicy: Output<String>?

A string specifying the eviction policy for a Valkey cluster. Valid values are: noeviction, allkeys_lru, allkeys_random, volatile_lru, volatile_random, or volatile_ttl.

Link copied to clipboard
val host: Output<String>

Database cluster's hostname.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val maintenanceWindows: Output<List<DatabaseClusterMaintenanceWindow>>?

Defines when the automatic maintenance should be performed for the database cluster.

Link copied to clipboard
val name: Output<String>

The name of the database cluster.

Link copied to clipboard
val nodeCount: Output<Int>

Number of nodes that will be included in the cluster. For kafka clusters, this must be 3.

Link copied to clipboard
val password: Output<String>

Password for the cluster's default user.

Link copied to clipboard
val port: Output<Int>

Network port that the database cluster is listening on.

Link copied to clipboard
val privateHost: Output<String>

Same as host, but only accessible from resources within the account and in the same region.

Link copied to clipboard
val privateNetworkUuid: Output<String>

The ID of the VPC where the database cluster will be located.

Link copied to clipboard
val privateUri: Output<String>

Same as uri, but only accessible from resources within the account and in the same region.

Link copied to clipboard
val projectId: Output<String>

The ID of the project that the database cluster is assigned to. If excluded when creating a new database cluster, it will be assigned to your default project.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val region: Output<String>

DigitalOcean region where the cluster will reside.

Link copied to clipboard
val size: Output<String>

Database Droplet size associated with the cluster (ex. db-s-1vcpu-1gb). See the DigitalOcean API for a list of valid size slugs.

Link copied to clipboard
val sqlMode: Output<String>?

A comma separated string specifying the SQL modes for a MySQL cluster.

Link copied to clipboard
val storageSizeMib: Output<String>

Defines the disk size, in MiB, allocated to the cluster. This can be adjusted on MySQL and PostgreSQL clusters based on predefined ranges for each slug/droplet size.

Link copied to clipboard
val tags: Output<List<String>>?

A list of tag names to be applied to the database cluster.

Link copied to clipboard
val uiDatabase: Output<String>

Name of the OpenSearch dashboard db.

Link copied to clipboard
val uiHost: Output<String>

Hostname for the OpenSearch dashboard.

Link copied to clipboard
val uiPassword: Output<String>

Password for the OpenSearch dashboard's default user.

Link copied to clipboard
val uiPort: Output<Int>

Network port that the OpenSearch dashboard is listening on.

Link copied to clipboard
val uiUri: Output<String>

The full URI for connecting to the OpenSearch dashboard.

Link copied to clipboard
val uiUser: Output<String>

Username for OpenSearch dashboard's default user.

Link copied to clipboard
val uri: Output<String>

The full URI for connecting to the database cluster.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val user: Output<String>

Username for the cluster's default user.

Link copied to clipboard
val version: Output<String>?

Engine version used by the cluster (ex. 14 for PostgreSQL 14). When this value is changed, a call to the Upgrade major Version for a Database API operation is made with the new version.