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

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()
            .engine("pg")
            .nodeCount(1)
            .region("nyc1")
            .size("db-s-1vcpu-1gb")
            .version("15")
            .build());
    }
}
Content copied to clipboard

Create a new MySQL database cluster

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()
            .engine("mysql")
            .nodeCount(1)
            .region("nyc1")
            .size("db-s-1vcpu-1gb")
            .version("8")
            .build());
    }
}
Content copied to clipboard

Create a new Redis database cluster

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 redis_example = new DatabaseCluster("redis-example", DatabaseClusterArgs.builder()
            .engine("redis")
            .nodeCount(1)
            .region("nyc1")
            .size("db-s-1vcpu-1gb")
            .version("6")
            .build());
    }
}
Content copied to clipboard

Create a new MongoDB database cluster

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()
            .engine("mongodb")
            .nodeCount(1)
            .region("nyc3")
            .size("db-s-1vcpu-1gb")
            .version("4")
            .build());
    }
}
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", {
    engine: "pg",
    version: "11",
    size: "db-s-1vcpu-2gb",
    region: "nyc1",
    nodeCount: 1,
    tags: ["production"],
});
const dobyBackup = new digitalocean.DatabaseCluster("dobyBackup", {
    engine: "pg",
    version: "11",
    size: "db-s-1vcpu-2gb",
    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",
    engine="pg",
    version="11",
    size="db-s-1vcpu-2gb",
    region="nyc1",
    node_count=1,
    tags=["production"])
doby_backup = digitalocean.DatabaseCluster("dobyBackup",
    engine="pg",
    version="11",
    size="db-s-1vcpu-2gb",
    region="nyc1",
    node_count=1,
    tags=["production"],
    backup_restore=digitalocean.DatabaseClusterBackupRestoreArgs(
        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()
    {
        Engine = "pg",
        Version = "11",
        Size = "db-s-1vcpu-2gb",
        Region = "nyc1",
        NodeCount = 1,
        Tags = new[]
        {
            "production",
        },
    });
    var dobyBackup = new DigitalOcean.DatabaseCluster("dobyBackup", new()
    {
        Engine = "pg",
        Version = "11",
        Size = "db-s-1vcpu-2gb",
        Region = "nyc1",
        NodeCount = 1,
        Tags = new[]
        {
            "production",
        },
        BackupRestore = new DigitalOcean.Inputs.DatabaseClusterBackupRestoreArgs
        {
            DatabaseName = "dobydb",
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            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{
			Engine:    pulumi.String("pg"),
			Version:   pulumi.String("11"),
			Size:      pulumi.String("db-s-1vcpu-2gb"),
			Region:    pulumi.String("nyc1"),
			NodeCount: pulumi.Int(1),
			Tags: pulumi.StringArray{
				pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		_, err = digitalocean.NewDatabaseCluster(ctx, "dobyBackup", &digitalocean.DatabaseClusterArgs{
			Engine:    pulumi.String("pg"),
			Version:   pulumi.String("11"),
			Size:      pulumi.String("db-s-1vcpu-2gb"),
			Region:    pulumi.String("nyc1"),
			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()
            .engine("pg")
            .version("11")
            .size("db-s-1vcpu-2gb")
            .region("nyc1")
            .nodeCount(1)
            .tags("production")
            .build());
        var dobyBackup = new DatabaseCluster("dobyBackup", DatabaseClusterArgs.builder()
            .engine("pg")
            .version("11")
            .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:
      engine: pg
      version: '11'
      size: db-s-1vcpu-2gb
      region: nyc1
      nodeCount: 1
      tags:
        - production
  dobyBackup:
    type: digitalocean:DatabaseCluster
    properties:
      engine: pg
      version: '11'
      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
val backupRestore: Output<DatabaseClusterBackupRestore>?

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

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 PostreSQL, mysql for MySQL, redis for Redis, or mongodb for MongoDB).

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

A string specifying the eviction policy for a Redis 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.

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 here 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 tags: Output<List<String>>?

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

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.