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 FREEFrequently Asked Questions
Cluster Topology & Configuration
What's a single node cluster?
A single node cluster uses
nodeCount=0 and places distributed tables on the coordinator node. You must set enableShardsOnCoordinator=true for this configuration.Can I create a cluster with exactly one worker node?
No,
nodeCount cannot be 1. Use 0 for single node clusters or 2 or more for multi-node configurations.What happens when I change enableShardsOnCoordinator?
Changing
enableShardsOnCoordinator requires shard rebalancing, which can impact cluster performance during the operation.How do I enable high availability for my cluster?
Set
enableHa=true and optionally specify preferredPrimaryZone to choose the primary availability zone.Server Editions & Sizing
What are the available server editions for coordinators?
Coordinators support GeneralPurpose, BurstableMemoryOptimized, and BurstableGeneralPurpose editions. The default is GeneralPurpose.
What are the Burstable server editions?
Burstable editions (BurstableMemoryOptimized and BurstableGeneralPurpose) are cost-effective options for workloads that don’t need continuous full CPU. Examples show 1 vCore and 2 vCore configurations.
What's the default server edition for worker nodes?
Worker nodes default to MemoryOptimized edition, but you can specify a different edition using
nodeServerEdition.Backup & Replication
How do I create a point-in-time restore of my cluster?
Specify
pointInTimeUTC (in ISO8601 format), sourceLocation, and sourceResourceId pointing to the source cluster.How do I create a read replica cluster?
Set
sourceLocation and sourceResourceId to reference the source cluster. Don’t include pointInTimeUTC for read replicas.Can I enable geo-backup after creating my cluster?
No,
enableGeoBackup can only be configured during cluster creation and cannot be changed afterward.Immutability & Constraints
Which cluster properties can't be changed after creation?
The
location, clusterName, and resourceGroupName properties are immutable. Additionally, enableGeoBackup can only be set during creation.