Create Azure SQL Elastic Pools

The azure-native:sql:ElasticPool resource, part of the Pulumi Azure Native provider, defines an Azure SQL elastic pool: its SKU, capacity, per-database resource limits, and availability configuration. This guide focuses on four capabilities: basic pool creation, SKU and capacity configuration, serverless compute with auto-pause, and zone redundancy with high availability replicas.

Elastic pools belong to an Azure SQL Server and require an existing resource group. The examples are intentionally small. Combine them with your own SQL Server infrastructure and database assignments.

Create a basic elastic pool with required properties

Most deployments start with the minimum configuration: a name, location, resource group, and parent SQL server.

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

const elasticPool = new azure_native.sql.ElasticPool("elasticPool", {
    elasticPoolName: "sqlcrudtest-8102",
    location: "Japan East",
    resourceGroupName: "sqlcrudtest-2369",
    serverName: "sqlcrudtest-8069",
});

import pulumi
import pulumi_azure_native as azure_native

elastic_pool = azure_native.sql.ElasticPool("elasticPool",
    elastic_pool_name="sqlcrudtest-8102",
    location="Japan East",
    resource_group_name="sqlcrudtest-2369",
    server_name="sqlcrudtest-8069")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sql.NewElasticPool(ctx, "elasticPool", &sql.ElasticPoolArgs{
			ElasticPoolName:   pulumi.String("sqlcrudtest-8102"),
			Location:          pulumi.String("Japan East"),
			ResourceGroupName: pulumi.String("sqlcrudtest-2369"),
			ServerName:        pulumi.String("sqlcrudtest-8069"),
		})
		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 elasticPool = new AzureNative.Sql.ElasticPool("elasticPool", new()
    {
        ElasticPoolName = "sqlcrudtest-8102",
        Location = "Japan East",
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.sql.ElasticPool;
import com.pulumi.azurenative.sql.ElasticPoolArgs;
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 elasticPool = new ElasticPool("elasticPool", ElasticPoolArgs.builder()
            .elasticPoolName("sqlcrudtest-8102")
            .location("Japan East")
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .build());

    }
}

resources:
  elasticPool:
    type: azure-native:sql:ElasticPool
    properties:
      elasticPoolName: sqlcrudtest-8102
      location: Japan East
      resourceGroupName: sqlcrudtest-2369
      serverName: sqlcrudtest-8069

Azure applies default SKU and capacity settings when you omit them. The elasticPoolName identifies the pool within the server. The location determines the Azure region. The serverName and resourceGroupName reference existing infrastructure that must already exist.

Configure capacity and per-database resource limits

Production workloads require explicit control over pool capacity and per-database boundaries to balance cost and performance.

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

const elasticPool = new azure_native.sql.ElasticPool("elasticPool", {
    elasticPoolName: "sqlcrudtest-8102",
    location: "Japan East",
    perDatabaseSettings: {
        maxCapacity: 2,
        minCapacity: 0.25,
    },
    resourceGroupName: "sqlcrudtest-2369",
    serverName: "sqlcrudtest-8069",
    sku: {
        capacity: 2,
        name: "GP_Gen4_2",
        tier: "GeneralPurpose",
    },
});

import pulumi
import pulumi_azure_native as azure_native

elastic_pool = azure_native.sql.ElasticPool("elasticPool",
    elastic_pool_name="sqlcrudtest-8102",
    location="Japan East",
    per_database_settings={
        "max_capacity": 2,
        "min_capacity": 0.25,
    },
    resource_group_name="sqlcrudtest-2369",
    server_name="sqlcrudtest-8069",
    sku={
        "capacity": 2,
        "name": "GP_Gen4_2",
        "tier": "GeneralPurpose",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sql.NewElasticPool(ctx, "elasticPool", &sql.ElasticPoolArgs{
			ElasticPoolName: pulumi.String("sqlcrudtest-8102"),
			Location:        pulumi.String("Japan East"),
			PerDatabaseSettings: &sql.ElasticPoolPerDatabaseSettingsArgs{
				MaxCapacity: pulumi.Float64(2),
				MinCapacity: pulumi.Float64(0.25),
			},
			ResourceGroupName: pulumi.String("sqlcrudtest-2369"),
			ServerName:        pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Capacity: pulumi.Int(2),
				Name:     pulumi.String("GP_Gen4_2"),
				Tier:     pulumi.String("GeneralPurpose"),
			},
		})
		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 elasticPool = new AzureNative.Sql.ElasticPool("elasticPool", new()
    {
        ElasticPoolName = "sqlcrudtest-8102",
        Location = "Japan East",
        PerDatabaseSettings = new AzureNative.Sql.Inputs.ElasticPoolPerDatabaseSettingsArgs
        {
            MaxCapacity = 2,
            MinCapacity = 0.25,
        },
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Capacity = 2,
            Name = "GP_Gen4_2",
            Tier = "GeneralPurpose",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.sql.ElasticPool;
import com.pulumi.azurenative.sql.ElasticPoolArgs;
import com.pulumi.azurenative.sql.inputs.ElasticPoolPerDatabaseSettingsArgs;
import com.pulumi.azurenative.sql.inputs.SkuArgs;
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 elasticPool = new ElasticPool("elasticPool", ElasticPoolArgs.builder()
            .elasticPoolName("sqlcrudtest-8102")
            .location("Japan East")
            .perDatabaseSettings(ElasticPoolPerDatabaseSettingsArgs.builder()
                .maxCapacity(2.0)
                .minCapacity(0.25)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .capacity(2)
                .name("GP_Gen4_2")
                .tier("GeneralPurpose")
                .build())
            .build());

    }
}

resources:
  elasticPool:
    type: azure-native:sql:ElasticPool
    properties:
      elasticPoolName: sqlcrudtest-8102
      location: Japan East
      perDatabaseSettings:
        maxCapacity: 2
        minCapacity: 0.25
      resourceGroupName: sqlcrudtest-2369
      serverName: sqlcrudtest-8069
      sku:
        capacity: 2
        name: GP_Gen4_2
        tier: GeneralPurpose

The sku property sets the pool’s tier, family, and capacity. The perDatabaseSettings block defines maxCapacity and minCapacity for individual databases, ensuring each database gets a guaranteed minimum and cannot exceed a maximum. This configuration uses the GeneralPurpose tier with Gen4 hardware and 2 vCores.

Enable serverless compute with auto-pause

Development and test environments benefit from serverless compute, which pauses during inactivity and scales capacity dynamically.

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

const elasticPool = new azure_native.sql.ElasticPool("elasticPool", {
    autoPauseDelay: 60,
    elasticPoolName: "sqlcrudtest-8102",
    location: "Japan East",
    minCapacity: 0.5,
    perDatabaseSettings: {
        autoPauseDelay: 80,
        maxCapacity: 2,
        minCapacity: 0,
    },
    resourceGroupName: "sqlcrudtest-2369",
    serverName: "sqlcrudtest-8069",
    sku: {
        capacity: 2,
        name: "GP_S_Gen5_2",
        tier: "GeneralPurpose",
    },
});

import pulumi
import pulumi_azure_native as azure_native

elastic_pool = azure_native.sql.ElasticPool("elasticPool",
    auto_pause_delay=60,
    elastic_pool_name="sqlcrudtest-8102",
    location="Japan East",
    min_capacity=0.5,
    per_database_settings={
        "auto_pause_delay": 80,
        "max_capacity": 2,
        "min_capacity": 0,
    },
    resource_group_name="sqlcrudtest-2369",
    server_name="sqlcrudtest-8069",
    sku={
        "capacity": 2,
        "name": "GP_S_Gen5_2",
        "tier": "GeneralPurpose",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sql.NewElasticPool(ctx, "elasticPool", &sql.ElasticPoolArgs{
			AutoPauseDelay:  pulumi.Int(60),
			ElasticPoolName: pulumi.String("sqlcrudtest-8102"),
			Location:        pulumi.String("Japan East"),
			MinCapacity:     pulumi.Float64(0.5),
			PerDatabaseSettings: &sql.ElasticPoolPerDatabaseSettingsArgs{
				AutoPauseDelay: pulumi.Int(80),
				MaxCapacity:    pulumi.Float64(2),
				MinCapacity:    pulumi.Float64(0),
			},
			ResourceGroupName: pulumi.String("sqlcrudtest-2369"),
			ServerName:        pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Capacity: pulumi.Int(2),
				Name:     pulumi.String("GP_S_Gen5_2"),
				Tier:     pulumi.String("GeneralPurpose"),
			},
		})
		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 elasticPool = new AzureNative.Sql.ElasticPool("elasticPool", new()
    {
        AutoPauseDelay = 60,
        ElasticPoolName = "sqlcrudtest-8102",
        Location = "Japan East",
        MinCapacity = 0.5,
        PerDatabaseSettings = new AzureNative.Sql.Inputs.ElasticPoolPerDatabaseSettingsArgs
        {
            AutoPauseDelay = 80,
            MaxCapacity = 2,
            MinCapacity = 0,
        },
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Capacity = 2,
            Name = "GP_S_Gen5_2",
            Tier = "GeneralPurpose",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.sql.ElasticPool;
import com.pulumi.azurenative.sql.ElasticPoolArgs;
import com.pulumi.azurenative.sql.inputs.ElasticPoolPerDatabaseSettingsArgs;
import com.pulumi.azurenative.sql.inputs.SkuArgs;
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 elasticPool = new ElasticPool("elasticPool", ElasticPoolArgs.builder()
            .autoPauseDelay(60)
            .elasticPoolName("sqlcrudtest-8102")
            .location("Japan East")
            .minCapacity(0.5)
            .perDatabaseSettings(ElasticPoolPerDatabaseSettingsArgs.builder()
                .autoPauseDelay(80)
                .maxCapacity(2.0)
                .minCapacity(0.0)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .capacity(2)
                .name("GP_S_Gen5_2")
                .tier("GeneralPurpose")
                .build())
            .build());

    }
}

resources:
  elasticPool:
    type: azure-native:sql:ElasticPool
    properties:
      autoPauseDelay: 60
      elasticPoolName: sqlcrudtest-8102
      location: Japan East
      minCapacity: 0.5
      perDatabaseSettings:
        autoPauseDelay: 80
        maxCapacity: 2
        minCapacity: 0
      resourceGroupName: sqlcrudtest-2369
      serverName: sqlcrudtest-8069
      sku:
        capacity: 2
        name: GP_S_Gen5_2
        tier: GeneralPurpose

The autoPauseDelay property sets how many minutes of inactivity trigger an automatic pause. The minCapacity property defines the floor for serverless scaling. The sku name with GP_S prefix indicates serverless compute. Per-database settings can override pool-level auto-pause behavior.

Pin pool to availability zone with zone redundancy

Mission-critical workloads require high availability across Azure availability zones to protect against datacenter failures.

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

const elasticPool = new azure_native.sql.ElasticPool("elasticPool", {
    availabilityZone: azure_native.sql.AvailabilityZoneType.One,
    elasticPoolName: "sqlcrudtest-8102",
    location: "Japan East",
    perDatabaseSettings: {
        maxCapacity: 2,
        minCapacity: 0.25,
    },
    resourceGroupName: "sqlcrudtest-2369",
    serverName: "sqlcrudtest-8069",
    sku: {
        name: "HS_Gen5_4",
    },
    zoneRedundant: true,
});

import pulumi
import pulumi_azure_native as azure_native

elastic_pool = azure_native.sql.ElasticPool("elasticPool",
    availability_zone=azure_native.sql.AvailabilityZoneType.ONE,
    elastic_pool_name="sqlcrudtest-8102",
    location="Japan East",
    per_database_settings={
        "max_capacity": 2,
        "min_capacity": 0.25,
    },
    resource_group_name="sqlcrudtest-2369",
    server_name="sqlcrudtest-8069",
    sku={
        "name": "HS_Gen5_4",
    },
    zone_redundant=True)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sql.NewElasticPool(ctx, "elasticPool", &sql.ElasticPoolArgs{
			AvailabilityZone: pulumi.String(sql.AvailabilityZoneTypeOne),
			ElasticPoolName:  pulumi.String("sqlcrudtest-8102"),
			Location:         pulumi.String("Japan East"),
			PerDatabaseSettings: &sql.ElasticPoolPerDatabaseSettingsArgs{
				MaxCapacity: pulumi.Float64(2),
				MinCapacity: pulumi.Float64(0.25),
			},
			ResourceGroupName: pulumi.String("sqlcrudtest-2369"),
			ServerName:        pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Name: pulumi.String("HS_Gen5_4"),
			},
			ZoneRedundant: pulumi.Bool(true),
		})
		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 elasticPool = new AzureNative.Sql.ElasticPool("elasticPool", new()
    {
        AvailabilityZone = AzureNative.Sql.AvailabilityZoneType.One,
        ElasticPoolName = "sqlcrudtest-8102",
        Location = "Japan East",
        PerDatabaseSettings = new AzureNative.Sql.Inputs.ElasticPoolPerDatabaseSettingsArgs
        {
            MaxCapacity = 2,
            MinCapacity = 0.25,
        },
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Name = "HS_Gen5_4",
        },
        ZoneRedundant = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.sql.ElasticPool;
import com.pulumi.azurenative.sql.ElasticPoolArgs;
import com.pulumi.azurenative.sql.inputs.ElasticPoolPerDatabaseSettingsArgs;
import com.pulumi.azurenative.sql.inputs.SkuArgs;
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 elasticPool = new ElasticPool("elasticPool", ElasticPoolArgs.builder()
            .availabilityZone("1")
            .elasticPoolName("sqlcrudtest-8102")
            .location("Japan East")
            .perDatabaseSettings(ElasticPoolPerDatabaseSettingsArgs.builder()
                .maxCapacity(2.0)
                .minCapacity(0.25)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .name("HS_Gen5_4")
                .build())
            .zoneRedundant(true)
            .build());

    }
}

resources:
  elasticPool:
    type: azure-native:sql:ElasticPool
    properties:
      availabilityZone: '1'
      elasticPoolName: sqlcrudtest-8102
      location: Japan East
      perDatabaseSettings:
        maxCapacity: 2
        minCapacity: 0.25
      resourceGroupName: sqlcrudtest-2369
      serverName: sqlcrudtest-8069
      sku:
        name: HS_Gen5_4
      zoneRedundant: true

The availabilityZone property pins the pool’s primary replica to a specific zone. The zoneRedundant property spreads replicas across multiple zones. This configuration uses the Hyperscale tier (HS_Gen5_4), which supports zone features for enhanced availability.

Configure high availability replicas for Hyperscale

Hyperscale elastic pools support multiple secondary replicas for read scale-out and faster failover.

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

const elasticPool = new azure_native.sql.ElasticPool("elasticPool", {
    elasticPoolName: "sqlcrudtest-8102",
    highAvailabilityReplicaCount: 2,
    location: "Japan East",
    resourceGroupName: "sqlcrudtest-2369",
    serverName: "sqlcrudtest-8069",
    sku: {
        name: "HS_Gen5_4",
    },
});

import pulumi
import pulumi_azure_native as azure_native

elastic_pool = azure_native.sql.ElasticPool("elasticPool",
    elastic_pool_name="sqlcrudtest-8102",
    high_availability_replica_count=2,
    location="Japan East",
    resource_group_name="sqlcrudtest-2369",
    server_name="sqlcrudtest-8069",
    sku={
        "name": "HS_Gen5_4",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sql.NewElasticPool(ctx, "elasticPool", &sql.ElasticPoolArgs{
			ElasticPoolName:              pulumi.String("sqlcrudtest-8102"),
			HighAvailabilityReplicaCount: pulumi.Int(2),
			Location:                     pulumi.String("Japan East"),
			ResourceGroupName:            pulumi.String("sqlcrudtest-2369"),
			ServerName:                   pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Name: pulumi.String("HS_Gen5_4"),
			},
		})
		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 elasticPool = new AzureNative.Sql.ElasticPool("elasticPool", new()
    {
        ElasticPoolName = "sqlcrudtest-8102",
        HighAvailabilityReplicaCount = 2,
        Location = "Japan East",
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Name = "HS_Gen5_4",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.sql.ElasticPool;
import com.pulumi.azurenative.sql.ElasticPoolArgs;
import com.pulumi.azurenative.sql.inputs.SkuArgs;
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 elasticPool = new ElasticPool("elasticPool", ElasticPoolArgs.builder()
            .elasticPoolName("sqlcrudtest-8102")
            .highAvailabilityReplicaCount(2)
            .location("Japan East")
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .name("HS_Gen5_4")
                .build())
            .build());

    }
}

resources:
  elasticPool:
    type: azure-native:sql:ElasticPool
    properties:
      elasticPoolName: sqlcrudtest-8102
      highAvailabilityReplicaCount: 2
      location: Japan East
      resourceGroupName: sqlcrudtest-2369
      serverName: sqlcrudtest-8069
      sku:
        name: HS_Gen5_4

The highAvailabilityReplicaCount property adds secondary replicas for read workloads and improved availability. This feature is specific to Hyperscale, Business Critical, and Premium tiers. Each replica provides an additional read endpoint and reduces failover time.

Beyond these examples

These snippets focus on specific elastic pool features: SKU selection and capacity configuration, serverless compute with auto-pause, and zone redundancy and high availability replicas. They’re intentionally minimal rather than full database hosting solutions.

The examples reference pre-existing infrastructure such as Azure SQL Server (serverName) and resource group (resourceGroupName). They focus on configuring the pool rather than provisioning the surrounding infrastructure.

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

Maintenance window configuration (maintenanceConfigurationId)
Enclave type for Always Encrypted (preferredEnclaveType)
Storage limits (maxSizeBytes)
License type selection (licenseType)

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

Let's create Azure SQL Elastic Pools

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

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration Basics

What's the minimum configuration needed to create an elastic pool?

You need elasticPoolName, location, resourceGroupName, and serverName. All other properties are optional.

How do I determine which SKUs are available in my region?

Use the Azure CLI command az sql elastic-pool list-editions -l <location> -o table or the Capabilities_ListByLocation REST API.

What do the different SKU families mean?

SKU families indicate different capabilities: HS_Gen5 for Hyperscale, GP_S_Gen5 for serverless General Purpose, and GP_Gen4 for standard General Purpose pools.

Immutability & Lifecycle

What properties can't I change after creating an elastic pool?

The elasticPoolName, location, resourceGroupName, and serverName properties are immutable. To change these, you must recreate the resource.

Serverless Features

How do I enable serverless features for my elastic pool?

Use a serverless SKU like GP_S_Gen5_2, then configure autoPauseDelay and minCapacity properties.

What's the difference between pool-level and per-database autoPauseDelay?

Pool-level autoPauseDelay controls when the entire pool pauses. The autoPauseDelay inside perDatabaseSettings controls individual database pause behavior.

How do I disable automatic pause for a serverless pool?

Set autoPauseDelay to -1 to disable automatic pause.

High Availability & Zones

How do I configure zone redundancy for my elastic pool?

Set zoneRedundant to true to spread replicas across multiple availability zones, or set availabilityZone to a specific zone like “1” to pin the primary replica.

How do I configure high availability for a Hyperscale elastic pool?

Set highAvailabilityReplicaCount to the desired number of secondary replicas (e.g., 2) when using a Hyperscale SKU like HS_Gen5_4.

Can I use highAvailabilityReplicaCount with any SKU?

No, highAvailabilityReplicaCount is only applicable to Hyperscale elastic pools (HS_* SKUs).

Advanced Features

How do I configure a maintenance window for my elastic pool?

Set maintenanceConfigurationId to the full ARM resource ID of a public maintenance configuration, such as /subscriptions/.../Microsoft.Maintenance/publicMaintenanceConfigurations/SQL_JapanEast_1.

What enclave types are supported for Always Encrypted?

You can set preferredEnclaveType to either Default or VBS (Virtualization-Based Security).

Using a different cloud?

Explore database guides for other cloud providers:

AWS Guides GCP Guides