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 properties can't I change after creating an elastic pool?

The location, elasticPoolName, resourceGroupName, and serverName properties are immutable and cannot be modified after creation. Changing these requires recreating the resource.

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

You only need to specify location, resourceGroupName, serverName, and elasticPoolName. All other properties have defaults or are optional.

How does the SKU affect my elastic pool?

The sku property determines the tier/edition (e.g., GeneralPurpose, Hyperscale), hardware generation (e.g., Gen5), and capacity. It controls which features are available, such as serverless capabilities or high availability replicas.

High Availability & Zones

What's the difference between zoneRedundant and availabilityZone?

zoneRedundant spreads replicas across multiple availability zones for redundancy, while availabilityZone pins the primary replica to a specific zone. You can use both together as shown in the availability zone example.

Can I configure high availability replicas for any elastic pool?

No, highAvailabilityReplicaCount is only applicable to Hyperscale elastic pools. It specifies the number of secondary replicas used for high availability.

Serverless Configuration

How do I configure auto-pause for serverless elastic pools?

Set autoPauseDelay (in minutes) at the pool level to control when the pool pauses. You can also set autoPauseDelay within perDatabaseSettings for per-database control. Use -1 to disable automatic pause.

What's the difference between minCapacity at the pool level and in perDatabaseSettings?

Pool-level minCapacity sets the minimum capacity the serverless pool won’t shrink below when not paused. The minCapacity in perDatabaseSettings sets the minimum capacity for individual databases within the pool.

Advanced Features

What are the available enclave types for elastic pools?

You can set preferredEnclaveType to either Default or VBS (Virtualization-Based Security). This controls the type of secure enclave used for Always Encrypted operations.

How do I configure maintenance windows for my elastic pool?

Set maintenanceConfigurationId to a public maintenance configuration resource ID (e.g., /subscriptions/.../publicMaintenanceConfigurations/SQL_JapanEast_1). This defines when maintenance updates occur.

How do perDatabaseSettings relate to pool-level settings?

perDatabaseSettings defines limits for individual databases within the pool, including maxCapacity, minCapacity, and autoPauseDelay. These work alongside pool-level settings to control resource allocation per database.

Using a different cloud?

Explore database guides for other cloud providers:

AWS Guides GCP Guides