Deploy Azure Database for PostgreSQL Server Group Clusters

The azure-native:dbforpostgresql:ServerGroupCluster resource, part of the Pulumi Azure Native provider, provisions Azure Cosmos DB for PostgreSQL clusters: coordinator and worker node configuration, high availability, and replication topology. This guide focuses on three capabilities: single-node and multi-node cluster topologies, point-in-time restore from backups, and read replica creation for query offloading.

Clusters require an Azure resource group and may reference source clusters for restore or replication scenarios. The examples are intentionally small. Combine them with your own network configuration, authentication settings, and maintenance windows.

Deploy a single-node cluster with high availability

Most deployments start with a single coordinator node that handles both query routing and data storage, suitable for development and smaller production workloads.

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const serverGroupCluster = new azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster", {
    administratorLoginPassword: "password",
    citusVersion: "11.3",
    clusterName: "testcluster-singlenode",
    coordinatorEnablePublicIpAccess: true,
    coordinatorServerEdition: "GeneralPurpose",
    coordinatorStorageQuotaInMb: 131072,
    coordinatorVCores: 8,
    enableHa: true,
    enableShardsOnCoordinator: true,
    location: "westus",
    nodeCount: 0,
    postgresqlVersion: "15",
    preferredPrimaryZone: "1",
    resourceGroupName: "TestGroup",
    tags: {
        owner: "JohnDoe",
    },
});

import pulumi
import pulumi_azure_native as azure_native

server_group_cluster = azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster",
    administrator_login_password="password",
    citus_version="11.3",
    cluster_name="testcluster-singlenode",
    coordinator_enable_public_ip_access=True,
    coordinator_server_edition="GeneralPurpose",
    coordinator_storage_quota_in_mb=131072,
    coordinator_v_cores=8,
    enable_ha=True,
    enable_shards_on_coordinator=True,
    location="westus",
    node_count=0,
    postgresql_version="15",
    preferred_primary_zone="1",
    resource_group_name="TestGroup",
    tags={
        "owner": "JohnDoe",
    })

package main

import (
	dbforpostgresql "github.com/pulumi/pulumi-azure-native-sdk/dbforpostgresql/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dbforpostgresql.NewServerGroupCluster(ctx, "serverGroupCluster", &dbforpostgresql.ServerGroupClusterArgs{
			AdministratorLoginPassword:      pulumi.String("password"),
			CitusVersion:                    pulumi.String("11.3"),
			ClusterName:                     pulumi.String("testcluster-singlenode"),
			CoordinatorEnablePublicIpAccess: pulumi.Bool(true),
			CoordinatorServerEdition:        pulumi.String("GeneralPurpose"),
			CoordinatorStorageQuotaInMb:     pulumi.Int(131072),
			CoordinatorVCores:               pulumi.Int(8),
			EnableHa:                        pulumi.Bool(true),
			EnableShardsOnCoordinator:       pulumi.Bool(true),
			Location:                        pulumi.String("westus"),
			NodeCount:                       pulumi.Int(0),
			PostgresqlVersion:               pulumi.String("15"),
			PreferredPrimaryZone:            pulumi.String("1"),
			ResourceGroupName:               pulumi.String("TestGroup"),
			Tags: pulumi.StringMap{
				"owner": pulumi.String("JohnDoe"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var serverGroupCluster = new AzureNative.DBforPostgreSQL.ServerGroupCluster("serverGroupCluster", new()
    {
        AdministratorLoginPassword = "password",
        CitusVersion = "11.3",
        ClusterName = "testcluster-singlenode",
        CoordinatorEnablePublicIpAccess = true,
        CoordinatorServerEdition = "GeneralPurpose",
        CoordinatorStorageQuotaInMb = 131072,
        CoordinatorVCores = 8,
        EnableHa = true,
        EnableShardsOnCoordinator = true,
        Location = "westus",
        NodeCount = 0,
        PostgresqlVersion = "15",
        PreferredPrimaryZone = "1",
        ResourceGroupName = "TestGroup",
        Tags = 
        {
            { "owner", "JohnDoe" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupCluster;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupClusterArgs;
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 serverGroupCluster = new ServerGroupCluster("serverGroupCluster", ServerGroupClusterArgs.builder()
            .administratorLoginPassword("password")
            .citusVersion("11.3")
            .clusterName("testcluster-singlenode")
            .coordinatorEnablePublicIpAccess(true)
            .coordinatorServerEdition("GeneralPurpose")
            .coordinatorStorageQuotaInMb(131072)
            .coordinatorVCores(8)
            .enableHa(true)
            .enableShardsOnCoordinator(true)
            .location("westus")
            .nodeCount(0)
            .postgresqlVersion("15")
            .preferredPrimaryZone("1")
            .resourceGroupName("TestGroup")
            .tags(Map.of("owner", "JohnDoe"))
            .build());

    }
}

resources:
  serverGroupCluster:
    type: azure-native:dbforpostgresql:ServerGroupCluster
    properties:
      administratorLoginPassword: password
      citusVersion: '11.3'
      clusterName: testcluster-singlenode
      coordinatorEnablePublicIpAccess: true
      coordinatorServerEdition: GeneralPurpose
      coordinatorStorageQuotaInMb: 131072
      coordinatorVCores: 8
      enableHa: true
      enableShardsOnCoordinator: true
      location: westus
      nodeCount: 0
      postgresqlVersion: '15'
      preferredPrimaryZone: '1'
      resourceGroupName: TestGroup
      tags:
        owner: JohnDoe

When nodeCount is 0, the cluster runs in single-node mode with the coordinator handling all data. The enableShardsOnCoordinator property must be true in this configuration, allowing distributed tables to be created on the coordinator itself. The coordinatorServerEdition, coordinatorVCores, and coordinatorStorageQuotaInMb properties define the compute and storage capacity. Setting enableHa to true provisions a standby replica in a different availability zone for automatic failover.

Scale horizontally with dedicated worker nodes

Applications that need to distribute data across multiple servers add worker nodes to parallelize queries and increase storage capacity.

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const serverGroupCluster = new azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster", {
    administratorLoginPassword: "password",
    citusVersion: "11.1",
    clusterName: "testcluster-multinode",
    coordinatorEnablePublicIpAccess: true,
    coordinatorServerEdition: "GeneralPurpose",
    coordinatorStorageQuotaInMb: 524288,
    coordinatorVCores: 4,
    enableHa: true,
    enableShardsOnCoordinator: false,
    location: "westus",
    nodeCount: 3,
    nodeEnablePublicIpAccess: false,
    nodeServerEdition: "MemoryOptimized",
    nodeStorageQuotaInMb: 524288,
    nodeVCores: 8,
    postgresqlVersion: "15",
    preferredPrimaryZone: "1",
    resourceGroupName: "TestGroup",
    tags: {},
});

import pulumi
import pulumi_azure_native as azure_native

server_group_cluster = azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster",
    administrator_login_password="password",
    citus_version="11.1",
    cluster_name="testcluster-multinode",
    coordinator_enable_public_ip_access=True,
    coordinator_server_edition="GeneralPurpose",
    coordinator_storage_quota_in_mb=524288,
    coordinator_v_cores=4,
    enable_ha=True,
    enable_shards_on_coordinator=False,
    location="westus",
    node_count=3,
    node_enable_public_ip_access=False,
    node_server_edition="MemoryOptimized",
    node_storage_quota_in_mb=524288,
    node_v_cores=8,
    postgresql_version="15",
    preferred_primary_zone="1",
    resource_group_name="TestGroup",
    tags={})

package main

import (
	dbforpostgresql "github.com/pulumi/pulumi-azure-native-sdk/dbforpostgresql/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dbforpostgresql.NewServerGroupCluster(ctx, "serverGroupCluster", &dbforpostgresql.ServerGroupClusterArgs{
			AdministratorLoginPassword:      pulumi.String("password"),
			CitusVersion:                    pulumi.String("11.1"),
			ClusterName:                     pulumi.String("testcluster-multinode"),
			CoordinatorEnablePublicIpAccess: pulumi.Bool(true),
			CoordinatorServerEdition:        pulumi.String("GeneralPurpose"),
			CoordinatorStorageQuotaInMb:     pulumi.Int(524288),
			CoordinatorVCores:               pulumi.Int(4),
			EnableHa:                        pulumi.Bool(true),
			EnableShardsOnCoordinator:       pulumi.Bool(false),
			Location:                        pulumi.String("westus"),
			NodeCount:                       pulumi.Int(3),
			NodeEnablePublicIpAccess:        pulumi.Bool(false),
			NodeServerEdition:               pulumi.String("MemoryOptimized"),
			NodeStorageQuotaInMb:            pulumi.Int(524288),
			NodeVCores:                      pulumi.Int(8),
			PostgresqlVersion:               pulumi.String("15"),
			PreferredPrimaryZone:            pulumi.String("1"),
			ResourceGroupName:               pulumi.String("TestGroup"),
			Tags:                            pulumi.StringMap{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var serverGroupCluster = new AzureNative.DBforPostgreSQL.ServerGroupCluster("serverGroupCluster", new()
    {
        AdministratorLoginPassword = "password",
        CitusVersion = "11.1",
        ClusterName = "testcluster-multinode",
        CoordinatorEnablePublicIpAccess = true,
        CoordinatorServerEdition = "GeneralPurpose",
        CoordinatorStorageQuotaInMb = 524288,
        CoordinatorVCores = 4,
        EnableHa = true,
        EnableShardsOnCoordinator = false,
        Location = "westus",
        NodeCount = 3,
        NodeEnablePublicIpAccess = false,
        NodeServerEdition = "MemoryOptimized",
        NodeStorageQuotaInMb = 524288,
        NodeVCores = 8,
        PostgresqlVersion = "15",
        PreferredPrimaryZone = "1",
        ResourceGroupName = "TestGroup",
        Tags = null,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupCluster;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupClusterArgs;
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 serverGroupCluster = new ServerGroupCluster("serverGroupCluster", ServerGroupClusterArgs.builder()
            .administratorLoginPassword("password")
            .citusVersion("11.1")
            .clusterName("testcluster-multinode")
            .coordinatorEnablePublicIpAccess(true)
            .coordinatorServerEdition("GeneralPurpose")
            .coordinatorStorageQuotaInMb(524288)
            .coordinatorVCores(4)
            .enableHa(true)
            .enableShardsOnCoordinator(false)
            .location("westus")
            .nodeCount(3)
            .nodeEnablePublicIpAccess(false)
            .nodeServerEdition("MemoryOptimized")
            .nodeStorageQuotaInMb(524288)
            .nodeVCores(8)
            .postgresqlVersion("15")
            .preferredPrimaryZone("1")
            .resourceGroupName("TestGroup")
            .tags(Map.ofEntries(
            ))
            .build());

    }
}

resources:
  serverGroupCluster:
    type: azure-native:dbforpostgresql:ServerGroupCluster
    properties:
      administratorLoginPassword: password
      citusVersion: '11.1'
      clusterName: testcluster-multinode
      coordinatorEnablePublicIpAccess: true
      coordinatorServerEdition: GeneralPurpose
      coordinatorStorageQuotaInMb: 524288
      coordinatorVCores: 4
      enableHa: true
      enableShardsOnCoordinator: false
      location: westus
      nodeCount: 3
      nodeEnablePublicIpAccess: false
      nodeServerEdition: MemoryOptimized
      nodeStorageQuotaInMb: 524288
      nodeVCores: 8
      postgresqlVersion: '15'
      preferredPrimaryZone: '1'
      resourceGroupName: TestGroup
      tags: {}

Setting nodeCount to 3 provisions three worker nodes alongside the coordinator. The nodeServerEdition, nodeVCores, and nodeStorageQuotaInMb properties configure each worker’s capacity independently from the coordinator. When enableShardsOnCoordinator is false, distributed tables are placed only on worker nodes, not the coordinator. The nodeEnablePublicIpAccess property controls whether worker nodes are accessible from the internet.

Restore a cluster from a point in time

Disaster recovery and testing scenarios often require restoring a cluster to a specific moment from an existing cluster’s backup history.

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const serverGroupCluster = new azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster", {
    clusterName: "testcluster",
    location: "westus",
    pointInTimeUTC: "2017-12-14T00:00:37.467Z",
    resourceGroupName: "TestGroup",
    sourceLocation: "westus",
    sourceResourceId: "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster",
});

import pulumi
import pulumi_azure_native as azure_native

server_group_cluster = azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster",
    cluster_name="testcluster",
    location="westus",
    point_in_time_utc="2017-12-14T00:00:37.467Z",
    resource_group_name="TestGroup",
    source_location="westus",
    source_resource_id="/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster")

package main

import (
	dbforpostgresql "github.com/pulumi/pulumi-azure-native-sdk/dbforpostgresql/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dbforpostgresql.NewServerGroupCluster(ctx, "serverGroupCluster", &dbforpostgresql.ServerGroupClusterArgs{
			ClusterName:       pulumi.String("testcluster"),
			Location:          pulumi.String("westus"),
			PointInTimeUTC:    pulumi.String("2017-12-14T00:00:37.467Z"),
			ResourceGroupName: pulumi.String("TestGroup"),
			SourceLocation:    pulumi.String("westus"),
			SourceResourceId:  pulumi.String("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var serverGroupCluster = new AzureNative.DBforPostgreSQL.ServerGroupCluster("serverGroupCluster", new()
    {
        ClusterName = "testcluster",
        Location = "westus",
        PointInTimeUTC = "2017-12-14T00:00:37.467Z",
        ResourceGroupName = "TestGroup",
        SourceLocation = "westus",
        SourceResourceId = "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupCluster;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupClusterArgs;
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 serverGroupCluster = new ServerGroupCluster("serverGroupCluster", ServerGroupClusterArgs.builder()
            .clusterName("testcluster")
            .location("westus")
            .pointInTimeUTC("2017-12-14T00:00:37.467Z")
            .resourceGroupName("TestGroup")
            .sourceLocation("westus")
            .sourceResourceId("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster")
            .build());

    }
}

resources:
  serverGroupCluster:
    type: azure-native:dbforpostgresql:ServerGroupCluster
    properties:
      clusterName: testcluster
      location: westus
      pointInTimeUTC: 2017-12-14T00:00:37.467Z
      resourceGroupName: TestGroup
      sourceLocation: westus
      sourceResourceId: /subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/source-cluster

The sourceResourceId references the original cluster’s Azure resource ID. The pointInTimeUTC property specifies the exact timestamp to restore from, using ISO8601 format. The sourceLocation indicates the Azure region where the source cluster resides. The restored cluster becomes an independent cluster with its own configuration and lifecycle.

Create a read replica for query offloading

Read-heavy workloads benefit from read replicas that continuously replicate data from a primary cluster, distributing read queries across multiple clusters.

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const serverGroupCluster = new azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster", {
    clusterName: "testcluster",
    location: "westus",
    resourceGroupName: "TestGroup",
    sourceLocation: "westus",
    sourceResourceId: "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster",
});

import pulumi
import pulumi_azure_native as azure_native

server_group_cluster = azure_native.dbforpostgresql.ServerGroupCluster("serverGroupCluster",
    cluster_name="testcluster",
    location="westus",
    resource_group_name="TestGroup",
    source_location="westus",
    source_resource_id="/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster")

package main

import (
	dbforpostgresql "github.com/pulumi/pulumi-azure-native-sdk/dbforpostgresql/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dbforpostgresql.NewServerGroupCluster(ctx, "serverGroupCluster", &dbforpostgresql.ServerGroupClusterArgs{
			ClusterName:       pulumi.String("testcluster"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("TestGroup"),
			SourceLocation:    pulumi.String("westus"),
			SourceResourceId:  pulumi.String("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var serverGroupCluster = new AzureNative.DBforPostgreSQL.ServerGroupCluster("serverGroupCluster", new()
    {
        ClusterName = "testcluster",
        Location = "westus",
        ResourceGroupName = "TestGroup",
        SourceLocation = "westus",
        SourceResourceId = "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupCluster;
import com.pulumi.azurenative.dbforpostgresql.ServerGroupClusterArgs;
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 serverGroupCluster = new ServerGroupCluster("serverGroupCluster", ServerGroupClusterArgs.builder()
            .clusterName("testcluster")
            .location("westus")
            .resourceGroupName("TestGroup")
            .sourceLocation("westus")
            .sourceResourceId("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster")
            .build());

    }
}

resources:
  serverGroupCluster:
    type: azure-native:dbforpostgresql:ServerGroupCluster
    properties:
      clusterName: testcluster
      location: westus
      resourceGroupName: TestGroup
      sourceLocation: westus
      sourceResourceId: /subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestResourceGroup/providers/Microsoft.DBforPostgreSQL/serverGroupsv2/sourcecluster

The sourceResourceId points to the primary cluster, and sourceLocation specifies its region. Unlike point-in-time restore, read replicas maintain continuous replication from the source cluster. The replica can be in the same region or a different one for geographic distribution. Read replicas are read-only; write operations must go to the primary cluster.

Beyond these examples

These snippets focus on specific cluster-level features: single-node and multi-node topologies, point-in-time restore and read replicas, and coordinator and worker node sizing. They’re intentionally minimal rather than full database deployments.

The examples may reference pre-existing infrastructure such as Azure resource groups and source clusters for restore and replica scenarios. They focus on configuring the cluster rather than provisioning surrounding infrastructure.

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

Maintenance windows (maintenanceWindow)
Data encryption configuration (dataEncryption)
Authentication configuration (authConfig)
Network access controls and private endpoints
Custom database naming (databaseName)
Burstable tier configurations

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

Let's deploy Azure Database for PostgreSQL Server Group Clusters

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

Try Pulumi Cloud for FREE

Frequently Asked Questions

Cluster Architecture & Configuration

How do I configure single-node vs multi-node clusters?

Set nodeCount to 0 for single-node configuration (coordinator only with distributed table support) or 2 or more for multi-node configuration (coordinator plus worker nodes). A nodeCount of 1 is invalid and will cause creation to fail.

When should I enable shards on the coordinator?

Set enableShardsOnCoordinator to true on single-node clusters. Changing this value after creation requires shard rebalancing.

What's the difference between coordinator and worker node properties?

Coordinator properties (coordinatorVCores, coordinatorStorageQuotaInMb, coordinatorServerEdition) configure the coordinator server, while node properties (nodeVCores, nodeStorageQuotaInMb, nodeServerEdition) configure each worker node in multi-node clusters.

Backup & Recovery

How do I create a point-in-time restore cluster?

Configure pointInTimeUTC with an ISO8601 timestamp, sourceLocation with the source region, and sourceResourceId pointing to the source cluster.

How do I create a read replica cluster?

Set sourceLocation and sourceResourceId without specifying pointInTimeUTC.

Can I enable geo-backup after cluster creation?

No, enableGeoBackup can only be configured at cluster creation time.

Compute & Storage Resources

What are the vCore limits for coordinator and worker nodes?

Coordinator servers support up to 96 vCores (coordinatorVCores), while worker nodes support up to 104 vCores (nodeVCores).

What server editions are available?

Four editions are available: BurstableMemoryOptimized (1 vCore), BurstableGeneralPurpose (2 vCores), GeneralPurpose (default for coordinator), and MemoryOptimized (default for worker nodes).

Creation Requirements

What properties are required to create a cluster?

Required properties include administratorLoginPassword, coordinatorServerEdition, coordinatorStorageQuotaInMb, coordinatorVCores, and nodeCount.

Using a different cloud?

Explore database guides for other cloud providers:

AWS Guides GCP Guides