pulumi-azure-native-kotlin/com.pulumi.azurenative.sql.kotlin/ElasticPool

ElasticPool

class ElasticPool : KotlinCustomResource

An elastic pool. Uses Azure REST API version 2023-08-01. In version 2.x of the Azure Native provider, it used API version 2021-11-01. Other available API versions: 2014-04-01, 2017-10-01-preview, 2020-02-02-preview, 2020-08-01-preview, 2020-11-01-preview, 2021-02-01-preview, 2021-05-01-preview, 2021-08-01-preview, 2021-11-01, 2021-11-01-preview, 2022-02-01-preview, 2022-05-01-preview, 2022-08-01-preview, 2022-11-01-preview, 2023-02-01-preview, 2023-05-01-preview, 2023-08-01-preview, 2024-05-01-preview. These can be accessed by generating a local SDK package using the CLI command pulumi package add azure-native sql [ApiVersion]. See the ../../../version-guide/#accessing-any-api-version-via-local-packages for details.

Example Usage

Create or Update an elastic pool with Availability Zone

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,
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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
	})
}
Content copied to clipboard
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)
                .minCapacity(0.25)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .name("HS_Gen5_4")
                .build())
            .zoneRedundant(true)
            .build());
    }
}
Content copied to clipboard

Create or Update an elastic pool with serverless properties

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",
        },
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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
	})
}
Content copied to clipboard
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)
                .minCapacity(0)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .capacity(2)
                .name("GP_S_Gen5_2")
                .tier("GeneralPurpose")
                .build())
            .build());
    }
}
Content copied to clipboard

Create or update Hyperscale elastic pool with high availability replica count parameter

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",
        },
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard

Create or update elastic pool with all parameter

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",
        },
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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
	})
}
Content copied to clipboard
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)
                .minCapacity(0.25)
                .build())
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .capacity(2)
                .name("GP_Gen4_2")
                .tier("GeneralPurpose")
                .build())
            .build());
    }
}
Content copied to clipboard

Create or update elastic pool with maintenance configuration parameter

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",
        MaintenanceConfigurationId = "/subscriptions/00000000-1111-2222-3333-444444444444/providers/Microsoft.Maintenance/publicMaintenanceConfigurations/SQL_JapanEast_1",
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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"),
			MaintenanceConfigurationId: pulumi.String("/subscriptions/00000000-1111-2222-3333-444444444444/providers/Microsoft.Maintenance/publicMaintenanceConfigurations/SQL_JapanEast_1"),
			ResourceGroupName:          pulumi.String("sqlcrudtest-2369"),
			ServerName:                 pulumi.String("sqlcrudtest-8069"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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")
            .maintenanceConfigurationId("/subscriptions/00000000-1111-2222-3333-444444444444/providers/Microsoft.Maintenance/publicMaintenanceConfigurations/SQL_JapanEast_1")
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .build());
    }
}
Content copied to clipboard

Create or update elastic pool with minimum parameters

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",
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard

Create or update elastic pool with preferred enclave type parameter as Default

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",
        PreferredEnclaveType = AzureNative.Sql.AlwaysEncryptedEnclaveType.Default,
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Name = "GP_Gen5_4",
        },
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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"),
			PreferredEnclaveType: pulumi.String(sql.AlwaysEncryptedEnclaveTypeDefault),
			ResourceGroupName:    pulumi.String("sqlcrudtest-2369"),
			ServerName:           pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Name: pulumi.String("GP_Gen5_4"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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")
            .location("Japan East")
            .preferredEnclaveType("Default")
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .name("GP_Gen5_4")
                .build())
            .build());
    }
}
Content copied to clipboard

Create or update elastic pool with preferred enclave type parameter as VBS

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",
        PreferredEnclaveType = AzureNative.Sql.AlwaysEncryptedEnclaveType.VBS,
        ResourceGroupName = "sqlcrudtest-2369",
        ServerName = "sqlcrudtest-8069",
        Sku = new AzureNative.Sql.Inputs.SkuArgs
        {
            Name = "GP_Gen5_4",
        },
    });
});
Content copied to clipboard
package main
import (
	sql "github.com/pulumi/pulumi-azure-native-sdk/sql/v2"
	"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"),
			PreferredEnclaveType: pulumi.String(sql.AlwaysEncryptedEnclaveTypeVBS),
			ResourceGroupName:    pulumi.String("sqlcrudtest-2369"),
			ServerName:           pulumi.String("sqlcrudtest-8069"),
			Sku: &sql.SkuArgs{
				Name: pulumi.String("GP_Gen5_4"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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")
            .location("Japan East")
            .preferredEnclaveType("VBS")
            .resourceGroupName("sqlcrudtest-2369")
            .serverName("sqlcrudtest-8069")
            .sku(SkuArgs.builder()
                .name("GP_Gen5_4")
                .build())
            .build());
    }
}
Content copied to clipboard

Import

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

$ pulumi import azure-native:sql:ElasticPool sqlcrudtest-8102 /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/elasticPools/{elasticPoolName}
Content copied to clipboard

Properties

Link copied to clipboard
val autoPauseDelay: Output<Int>?

Time in minutes after which elastic pool is automatically paused. A value of -1 means that automatic pause is disabled

Link copied to clipboard
val availabilityZone: Output<String>?

Specifies the availability zone the pool's primary replica is pinned to.

Link copied to clipboard
val azureApiVersion: Output<String>

The Azure API version of the resource.

Link copied to clipboard
val creationDate: Output<String>

The creation date of the elastic pool (ISO8601 format).

Link copied to clipboard
val highAvailabilityReplicaCount: Output<Int>?

The number of secondary replicas associated with the Business Critical, Premium, or Hyperscale edition elastic pool that are used to provide high availability. Applicable only to Hyperscale elastic pools.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val kind: Output<String>

Kind of elastic pool. This is metadata used for the Azure portal experience.

Link copied to clipboard
val licenseType: Output<String>?

The license type to apply for this elastic pool.

Link copied to clipboard
val location: Output<String>

Resource location.

Link copied to clipboard
val maintenanceConfigurationId: Output<String>?

Maintenance configuration id assigned to the elastic pool. This configuration defines the period when the maintenance updates will will occur.

Link copied to clipboard
val maxSizeBytes: Output<Double>?

The storage limit for the database elastic pool in bytes.

Link copied to clipboard
val minCapacity: Output<Double>?

Minimal capacity that serverless pool will not shrink below, if not paused

Link copied to clipboard
val name: Output<String>

Resource name.

Link copied to clipboard
val perDatabaseSettings: Output<ElasticPoolPerDatabaseSettingsResponse>?

The per database settings for the elastic pool.

Link copied to clipboard
val preferredEnclaveType: Output<String>?

Type of enclave requested on the elastic pool.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val sku: Output<SkuResponse>?

The elastic pool SKU. The list of SKUs may vary by region and support offer. To determine the SKUs (including the SKU name, tier/edition, family, and capacity) that are available to your subscription in an Azure region, use the Capabilities_ListByLocation REST API or the following command:

Link copied to clipboard
val state: Output<String>

The state of the elastic pool.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

Link copied to clipboard
val type: Output<String>

Resource type.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val zoneRedundant: Output<Boolean>?

Whether or not this elastic pool is zone redundant, which means the replicas of this elastic pool will be spread across multiple availability zones.