pulumi-azure-native-kotlin/com.pulumi.azurenative.documentdb.kotlin/DatabaseAccount

DatabaseAccount

class DatabaseAccount : KotlinCustomResource

An Azure Cosmos DB database account. Azure REST API version: 2023-04-15. Prior API version in Azure Native 1.x: 2021-03-15. Other available API versions: 2020-03-01, 2020-06-01-preview, 2020-09-01, 2021-04-01-preview, 2023-03-15-preview, 2023-09-15, 2023-09-15-preview.

Example Usage

CosmosDBDatabaseAccountCreateMin

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var databaseAccount = new AzureNative.DocumentDB.DatabaseAccount("databaseAccount", new()
    {
        AccountName = "ddb1",
        CreateMode = "Default",
        DatabaseAccountOfferType = AzureNative.DocumentDB.DatabaseAccountOfferType.Standard,
        Location = "westus",
        Locations = new[]
        {
            new AzureNative.DocumentDB.Inputs.LocationArgs
            {
                FailoverPriority = 0,
                IsZoneRedundant = false,
                LocationName = "southcentralus",
            },
        },
        ResourceGroupName = "rg1",
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/documentdb/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := documentdb.NewDatabaseAccount(ctx, "databaseAccount", &documentdb.DatabaseAccountArgs{
			AccountName:              pulumi.String("ddb1"),
			CreateMode:               pulumi.String("Default"),
			DatabaseAccountOfferType: documentdb.DatabaseAccountOfferTypeStandard,
			Location:                 pulumi.String("westus"),
			Locations: []documentdb.LocationArgs{
				{
					FailoverPriority: pulumi.Int(0),
					IsZoneRedundant:  pulumi.Bool(false),
					LocationName:     pulumi.String("southcentralus"),
				},
			},
			ResourceGroupName: pulumi.String("rg1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.documentdb.DatabaseAccount;
import com.pulumi.azurenative.documentdb.DatabaseAccountArgs;
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 databaseAccount = new DatabaseAccount("databaseAccount", DatabaseAccountArgs.builder()
            .accountName("ddb1")
            .createMode("Default")
            .databaseAccountOfferType("Standard")
            .location("westus")
            .locations(Map.ofEntries(
                Map.entry("failoverPriority", 0),
                Map.entry("isZoneRedundant", false),
                Map.entry("locationName", "southcentralus")
            ))
            .resourceGroupName("rg1")
            .build());
    }
}

CosmosDBRestoreDatabaseAccountCreateUpdate.json

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var databaseAccount = new AzureNative.DocumentDB.DatabaseAccount("databaseAccount", new()
    {
        AccountName = "ddb1",
        ApiProperties = new AzureNative.DocumentDB.Inputs.ApiPropertiesArgs
        {
            ServerVersion = "3.2",
        },
        BackupPolicy = new AzureNative.DocumentDB.Inputs.ContinuousModeBackupPolicyArgs
        {
            ContinuousModeProperties = new AzureNative.DocumentDB.Inputs.ContinuousModePropertiesArgs
            {
                Tier = "Continuous30Days",
            },
            Type = "Continuous",
        },
        ConsistencyPolicy = new AzureNative.DocumentDB.Inputs.ConsistencyPolicyArgs
        {
            DefaultConsistencyLevel = AzureNative.DocumentDB.DefaultConsistencyLevel.BoundedStaleness,
            MaxIntervalInSeconds = 10,
            MaxStalenessPrefix = 200,
        },
        CreateMode = "Restore",
        DatabaseAccountOfferType = AzureNative.DocumentDB.DatabaseAccountOfferType.Standard,
        EnableAnalyticalStorage = true,
        EnableFreeTier = false,
        KeyVaultKeyUri = "https://myKeyVault.vault.azure.net",
        Kind = "GlobalDocumentDB",
        Location = "westus",
        Locations = new[]
        {
            new AzureNative.DocumentDB.Inputs.LocationArgs
            {
                FailoverPriority = 0,
                IsZoneRedundant = false,
                LocationName = "southcentralus",
            },
        },
        MinimalTlsVersion = "Tls",
        ResourceGroupName = "rg1",
        RestoreParameters = new AzureNative.DocumentDB.Inputs.RestoreParametersArgs
        {
            DatabasesToRestore = new[]
            {
                new AzureNative.DocumentDB.Inputs.DatabaseRestoreResourceArgs
                {
                    CollectionNames = new[]
                    {
                        "collection1",
                        "collection2",
                    },
                    DatabaseName = "db1",
                },
                new AzureNative.DocumentDB.Inputs.DatabaseRestoreResourceArgs
                {
                    CollectionNames = new[]
                    {
                        "collection3",
                        "collection4",
                    },
                    DatabaseName = "db2",
                },
            },
            RestoreMode = "PointInTime",
            RestoreSource = "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc",
            RestoreTimestampInUtc = "2021-03-11T22:05:09Z",
        },
        Tags = null,
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/documentdb/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := documentdb.NewDatabaseAccount(ctx, "databaseAccount", &documentdb.DatabaseAccountArgs{
			AccountName: pulumi.String("ddb1"),
			ApiProperties: &documentdb.ApiPropertiesArgs{
				ServerVersion: pulumi.String("3.2"),
			},
			BackupPolicy: documentdb.ContinuousModeBackupPolicy{
				ContinuousModeProperties: documentdb.ContinuousModeProperties{
					Tier: "Continuous30Days",
				},
				Type: "Continuous",
			},
			ConsistencyPolicy: &documentdb.ConsistencyPolicyArgs{
				DefaultConsistencyLevel: documentdb.DefaultConsistencyLevelBoundedStaleness,
				MaxIntervalInSeconds:    pulumi.Int(10),
				MaxStalenessPrefix:      pulumi.Float64(200),
			},
			CreateMode:               pulumi.String("Restore"),
			DatabaseAccountOfferType: documentdb.DatabaseAccountOfferTypeStandard,
			EnableAnalyticalStorage:  pulumi.Bool(true),
			EnableFreeTier:           pulumi.Bool(false),
			KeyVaultKeyUri:           pulumi.String("https://myKeyVault.vault.azure.net"),
			Kind:                     pulumi.String("GlobalDocumentDB"),
			Location:                 pulumi.String("westus"),
			Locations: []documentdb.LocationArgs{
				{
					FailoverPriority: pulumi.Int(0),
					IsZoneRedundant:  pulumi.Bool(false),
					LocationName:     pulumi.String("southcentralus"),
				},
			},
			MinimalTlsVersion: pulumi.String("Tls"),
			ResourceGroupName: pulumi.String("rg1"),
			RestoreParameters: documentdb.RestoreParametersResponse{
				DatabasesToRestore: documentdb.DatabaseRestoreResourceArray{
					&documentdb.DatabaseRestoreResourceArgs{
						CollectionNames: pulumi.StringArray{
							pulumi.String("collection1"),
							pulumi.String("collection2"),
						},
						DatabaseName: pulumi.String("db1"),
					},
					&documentdb.DatabaseRestoreResourceArgs{
						CollectionNames: pulumi.StringArray{
							pulumi.String("collection3"),
							pulumi.String("collection4"),
						},
						DatabaseName: pulumi.String("db2"),
					},
				},
				RestoreMode:           pulumi.String("PointInTime"),
				RestoreSource:         pulumi.String("/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc"),
				RestoreTimestampInUtc: pulumi.String("2021-03-11T22:05:09Z"),
			},
			Tags: nil,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.documentdb.DatabaseAccount;
import com.pulumi.azurenative.documentdb.DatabaseAccountArgs;
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 databaseAccount = new DatabaseAccount("databaseAccount", DatabaseAccountArgs.builder()
            .accountName("ddb1")
            .apiProperties(Map.of("serverVersion", "3.2"))
            .backupPolicy(Map.ofEntries(
                Map.entry("continuousModeProperties", Map.of("tier", "Continuous30Days")),
                Map.entry("type", "Continuous")
            ))
            .consistencyPolicy(Map.ofEntries(
                Map.entry("defaultConsistencyLevel", "BoundedStaleness"),
                Map.entry("maxIntervalInSeconds", 10),
                Map.entry("maxStalenessPrefix", 200)
            ))
            .createMode("Restore")
            .databaseAccountOfferType("Standard")
            .enableAnalyticalStorage(true)
            .enableFreeTier(false)
            .keyVaultKeyUri("https://myKeyVault.vault.azure.net")
            .kind("GlobalDocumentDB")
            .location("westus")
            .locations(Map.ofEntries(
                Map.entry("failoverPriority", 0),
                Map.entry("isZoneRedundant", false),
                Map.entry("locationName", "southcentralus")
            ))
            .minimalTlsVersion("Tls")
            .resourceGroupName("rg1")
            .restoreParameters(Map.ofEntries(
                Map.entry("databasesToRestore",
                    Map.ofEntries(
                        Map.entry("collectionNames",
                            "collection1",
                            "collection2"),
                        Map.entry("databaseName", "db1")
                    ),
                    Map.ofEntries(
                        Map.entry("collectionNames",
                            "collection3",
                            "collection4"),
                        Map.entry("databaseName", "db2")
                    )),
                Map.entry("restoreMode", "PointInTime"),
                Map.entry("restoreSource", "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc"),
                Map.entry("restoreTimestampInUtc", "2021-03-11T22:05:09Z")
            ))
            .tags()
            .build());
    }
}

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:documentdb:DatabaseAccount ddb1 /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}

Properties

analyticalStorageConfiguration

val analyticalStorageConfiguration: Output<AnalyticalStorageConfigurationResponse>?

Analytical storage specific properties.

apiProperties

val apiProperties: Output<ApiPropertiesResponse>?

API specific properties.

backupPolicy

val backupPolicy: Output<Either<ContinuousModeBackupPolicyResponse, PeriodicModeBackupPolicyResponse>>?

The object representing the policy for taking backups on an account.

capabilities

val capabilities: Output<List<CapabilityResponse>>?

List of Cosmos DB capabilities for the account

capacity

val capacity: Output<CapacityResponse>?

The object that represents all properties related to capacity enforcement on an account.

connectorOffer

val connectorOffer: Output<String>?

The cassandra connector offer type for the Cosmos DB database C* account.

consistencyPolicy

val consistencyPolicy: Output<ConsistencyPolicyResponse>?

The consistency policy for the Cosmos DB database account.

cors

val cors: Output<List<CorsPolicyResponse>>?

The CORS policy for the Cosmos DB database account.

createMode

val createMode: Output<String>?

Enum to indicate the mode of account creation.

databaseAccountOfferType

val databaseAccountOfferType: Output<String>

The offer type for the Cosmos DB database account. Default value: Standard.

defaultIdentity

val defaultIdentity: Output<String>?

The default identity for accessing key vault used in features like customer managed keys. The default identity needs to be explicitly set by the users. It can be "FirstPartyIdentity", "SystemAssignedIdentity" and more.

disableKeyBasedMetadataWriteAccess

val disableKeyBasedMetadataWriteAccess: Output<Boolean>?

Disable write operations on metadata resources (databases, containers, throughput) via account keys

disableLocalAuth

val disableLocalAuth: Output<Boolean>?

Opt-out of local authentication and ensure only MSI and AAD can be used exclusively for authentication.

documentEndpoint

val documentEndpoint: Output<String>

The connection endpoint for the Cosmos DB database account.

enableAnalyticalStorage

val enableAnalyticalStorage: Output<Boolean>?

Flag to indicate whether to enable storage analytics.

enableAutomaticFailover

val enableAutomaticFailover: Output<Boolean>?

Enables automatic failover of the write region in the rare event that the region is unavailable due to an outage. Automatic failover will result in a new write region for the account and is chosen based on the failover priorities configured for the account.

enableCassandraConnector

val enableCassandraConnector: Output<Boolean>?

Enables the cassandra connector on the Cosmos DB C* account

enableFreeTier

val enableFreeTier: Output<Boolean>?

Flag to indicate whether Free Tier is enabled.

enableMultipleWriteLocations

val enableMultipleWriteLocations: Output<Boolean>?

Enables the account to write in multiple locations

enablePartitionMerge

val enablePartitionMerge: Output<Boolean>?

Flag to indicate enabling/disabling of Partition Merge feature on the account

failoverPolicies

val failoverPolicies: Output<List<FailoverPolicyResponse>>

An array that contains the regions ordered by their failover priorities.

val id: Output<String>

identity

val identity: Output<ManagedServiceIdentityResponse>?

Identity for the resource.

instanceId

val instanceId: Output<String>

A unique identifier assigned to the database account

ipRules

val ipRules: Output<List<IpAddressOrRangeResponse>>?

List of IpRules.

isVirtualNetworkFilterEnabled

val isVirtualNetworkFilterEnabled: Output<Boolean>?

Flag to indicate whether to enable/disable Virtual Network ACL rules.

keysMetadata

val keysMetadata: Output<DatabaseAccountKeysMetadataResponse>

The object that represents the metadata for the Account Keys of the Cosmos DB account.

keyVaultKeyUri

val keyVaultKeyUri: Output<String>?

The URI of the key vault

kind

val kind: Output<String>?

Indicates the type of database account. This can only be set at database account creation.

location

val location: Output<String>?

The location of the resource group to which the resource belongs.

locations

val locations: Output<List<LocationResponse>>

An array that contains all of the locations enabled for the Cosmos DB account.

minimalTlsVersion

val minimalTlsVersion: Output<String>?

Indicates the minimum allowed Tls version. The default value is Tls 1.2. Cassandra and Mongo APIs only work with Tls 1.2.

name

val name: Output<String>

The name of the ARM resource.

networkAclBypass

val networkAclBypass: Output<String>?

Indicates what services are allowed to bypass firewall checks.

networkAclBypassResourceIds

val networkAclBypassResourceIds: Output<List<String>>?

An array that contains the Resource Ids for Network Acl Bypass for the Cosmos DB account.

privateEndpointConnections

val privateEndpointConnections: Output<List<PrivateEndpointConnectionResponse>>

List of Private Endpoint Connections configured for the Cosmos DB account.

provisioningState

val provisioningState: Output<String>

The status of the Cosmos DB account at the time the operation was called. The status can be one of following. 'Creating' – the Cosmos DB account is being created. When an account is in Creating state, only properties that are specified as input for the Create Cosmos DB account operation are returned. 'Succeeded' – the Cosmos DB account is active for use. 'Updating' – the Cosmos DB account is being updated. 'Deleting' – the Cosmos DB account is being deleted. 'Failed' – the Cosmos DB account failed creation. 'DeletionFailed' – the Cosmos DB account deletion failed.

publicNetworkAccess