Updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.HorizonDb/clusters/{clusterName}/pools/{poolName}?api-version=2026-10-01-preview
URI Parameters
| Name |
In |
Required |
Type |
Description |
|
clusterName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
The name of the HorizonDB cluster.
|
|
poolName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
The name of the HorizonDB pool.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
The name of the resource group. The name is case insensitive.
|
|
subscriptionId
|
path |
True
|
string
(uuid)
|
The ID of the target subscription. The value must be an UUID.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
The API version to use for this operation.
|
Request Body
Responses
| Name |
Type |
Description |
|
200 OK
|
Pool
|
Azure operation completed successfully.
|
|
202 Accepted
|
|
Resource update request accepted.
Headers
- Azure-AsyncOperation: string
- Location: string
- Retry-After: integer
|
|
Other Status Codes
|
ErrorResponse
|
An unexpected error response.
|
Security
azure_auth
Azure Active Directory OAuth2 Flow.
Type:
oauth2
Flow:
implicit
Authorization URL:
https://login.microsoftonline.com/common/oauth2/authorize
Scopes
| Name |
Description |
|
user_impersonation
|
impersonate your user account
|
Examples
Sample request
PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01?api-version=2026-10-01-preview
{
"properties": {
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters",
"applyMethod": "Immediate"
}
}
}
import com.azure.resourcemanager.horizondb.models.ParameterApplyMethod;
import com.azure.resourcemanager.horizondb.models.Pool;
import com.azure.resourcemanager.horizondb.models.PoolParameterGroupReferenceForPatchUpdate;
import com.azure.resourcemanager.horizondb.models.PoolPropertiesForPatchUpdate;
/**
* Samples for Pools Update.
*/
public final class Main {
/*
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupImmediate.json
*/
/**
* Sample code: Associate a HorizonDB pool with a parameter group immediately.
*
* @param manager Entry point to HorizonDbManager.
*/
public static void associateAHorizonDBPoolWithAParameterGroupImmediately(
com.azure.resourcemanager.horizondb.HorizonDbManager manager) {
Pool resource = manager.pools().getWithResponse("example-resource-group", "example-cluster", "example-pool-01",
com.azure.core.util.Context.NONE).getValue();
resource.update().withProperties(new PoolPropertiesForPatchUpdate()
.withParameterGroup(new PoolParameterGroupReferenceForPatchUpdate().withParameterGroupResourceId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters")
.withApplyMethod(ParameterApplyMethod.IMMEDIATE)))
.apply();
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.horizondb import HorizonDBMgmtClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-horizondb
# USAGE
python pools_update_parameter_group_immediate.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = HorizonDBMgmtClient(
credential=DefaultAzureCredential(),
subscription_id="SUBSCRIPTION_ID",
)
response = client.pools.begin_update(
resource_group_name="example-resource-group",
cluster_name="example-cluster",
pool_name="example-pool-01",
properties={
"properties": {
"parameterGroup": {
"applyMethod": "Immediate",
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters",
}
}
},
).result()
print(response)
# x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupImmediate.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armhorizondb_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/horizondb/armhorizondb"
)
// Generated from example definition: 2026-10-01-preview/Pools_UpdateParameterGroupImmediate.json
func ExamplePoolsClient_BeginUpdate_associateAHorizonDbPoolWithAParameterGroupImmediately() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhorizondb.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "example-resource-group", "example-cluster", "example-pool-01", armhorizondb.PoolForPatchUpdate{
Properties: &armhorizondb.PoolPropertiesForPatchUpdate{
ParameterGroup: &armhorizondb.PoolParameterGroupReferenceForPatchUpdate{
ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters"),
ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
},
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to poll the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armhorizondb.PoolsClientUpdateResponse{
// Pool: armhorizondb.Pool{
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01"),
// Name: to.Ptr("example-pool-01"),
// Type: to.Ptr("Microsoft.HorizonDb/clusters/pools"),
// Properties: &armhorizondb.PoolProperties{
// State: to.Ptr(armhorizondb.PoolStateReady),
// ComputeModel: &armhorizondb.PoolComputeModel{
// Type: to.Ptr(armhorizondb.PoolComputeModelTypeProvisioned),
// ComputeProcessor: to.Ptr(armhorizondb.ComputeProcessorTypeAMD),
// ComputeGeneration: to.Ptr[int32](3),
// VCores: to.Ptr[int32](8),
// },
// NodeCount: to.Ptr[int32](3),
// HighAvailability: &armhorizondb.PoolHighAvailability{
// Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeAnyZone),
// },
// ParameterGroup: &armhorizondb.PoolParameterGroupReference{
// ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters"),
// ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
// SyncStatus: to.Ptr(armhorizondb.ParameterGroupSyncStatusApplying),
// },
// ProvisioningState: to.Ptr(armhorizondb.ProvisioningStateSucceeded),
// },
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { HorizonDbClient } = require("@azure/arm-horizondb");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
*
* @summary updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupImmediate.json
*/
async function associateAHorizonDBPoolWithAParameterGroupImmediately() {
const credential = new DefaultAzureCredential();
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const client = new HorizonDbClient(credential, subscriptionId);
const result = await client.pools.update(
"example-resource-group",
"example-cluster",
"example-pool-01",
{
properties: {
parameterGroup: {
parameterGroupResourceId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters",
applyMethod: "Immediate",
},
},
},
);
console.log(result);
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01",
"name": "example-pool-01",
"type": "Microsoft.HorizonDb/clusters/pools",
"properties": {
"state": "Ready",
"computeModel": {
"type": "Provisioned",
"computeProcessor": "AMD",
"computeGeneration": 3,
"vCores": 8
},
"nodeCount": 3,
"highAvailability": {
"mode": "AnyZone"
},
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters",
"applyMethod": "Immediate",
"syncStatus": "Applying"
},
"provisioningState": "Succeeded"
}
}
Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationStatuses/34343434-3434-3434-3434-343434343434?api-version=2026-10-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationResults/34343434-3434-3434-3434-343434343434?api-version=2026-10-01-preview
Retry-After: 30
Associate a HorizonDB pool with a parameter group pending reboot
Sample request
PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01?api-version=2026-10-01-preview
{
"properties": {
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters",
"applyMethod": "PendingReboot"
}
}
}
import com.azure.resourcemanager.horizondb.models.ParameterApplyMethod;
import com.azure.resourcemanager.horizondb.models.Pool;
import com.azure.resourcemanager.horizondb.models.PoolParameterGroupReferenceForPatchUpdate;
import com.azure.resourcemanager.horizondb.models.PoolPropertiesForPatchUpdate;
/**
* Samples for Pools Update.
*/
public final class Main {
/*
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupPendingReboot.json
*/
/**
* Sample code: Associate a HorizonDB pool with a parameter group pending reboot.
*
* @param manager Entry point to HorizonDbManager.
*/
public static void associateAHorizonDBPoolWithAParameterGroupPendingReboot(
com.azure.resourcemanager.horizondb.HorizonDbManager manager) {
Pool resource = manager.pools().getWithResponse("example-resource-group", "example-cluster", "example-pool-01",
com.azure.core.util.Context.NONE).getValue();
resource.update().withProperties(new PoolPropertiesForPatchUpdate()
.withParameterGroup(new PoolParameterGroupReferenceForPatchUpdate().withParameterGroupResourceId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters")
.withApplyMethod(ParameterApplyMethod.PENDING_REBOOT)))
.apply();
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.horizondb import HorizonDBMgmtClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-horizondb
# USAGE
python pools_update_parameter_group_pending_reboot.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = HorizonDBMgmtClient(
credential=DefaultAzureCredential(),
subscription_id="SUBSCRIPTION_ID",
)
response = client.pools.begin_update(
resource_group_name="example-resource-group",
cluster_name="example-cluster",
pool_name="example-pool-01",
properties={
"properties": {
"parameterGroup": {
"applyMethod": "PendingReboot",
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters",
}
}
},
).result()
print(response)
# x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupPendingReboot.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armhorizondb_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/horizondb/armhorizondb"
)
// Generated from example definition: 2026-10-01-preview/Pools_UpdateParameterGroupPendingReboot.json
func ExamplePoolsClient_BeginUpdate_associateAHorizonDbPoolWithAParameterGroupPendingReboot() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhorizondb.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "example-resource-group", "example-cluster", "example-pool-01", armhorizondb.PoolForPatchUpdate{
Properties: &armhorizondb.PoolPropertiesForPatchUpdate{
ParameterGroup: &armhorizondb.PoolParameterGroupReferenceForPatchUpdate{
ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters"),
ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodPendingReboot),
},
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to poll the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armhorizondb.PoolsClientUpdateResponse{
// Pool: armhorizondb.Pool{
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01"),
// Name: to.Ptr("example-pool-01"),
// Type: to.Ptr("Microsoft.HorizonDb/clusters/pools"),
// Properties: &armhorizondb.PoolProperties{
// State: to.Ptr(armhorizondb.PoolStateReady),
// ComputeModel: &armhorizondb.PoolComputeModel{
// Type: to.Ptr(armhorizondb.PoolComputeModelTypeProvisioned),
// ComputeProcessor: to.Ptr(armhorizondb.ComputeProcessorTypeAMD),
// ComputeGeneration: to.Ptr[int32](3),
// VCores: to.Ptr[int32](8),
// },
// NodeCount: to.Ptr[int32](3),
// HighAvailability: &armhorizondb.PoolHighAvailability{
// Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeAnyZone),
// },
// ParameterGroup: &armhorizondb.PoolParameterGroupReference{
// ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters"),
// ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodPendingReboot),
// SyncStatus: to.Ptr(armhorizondb.ParameterGroupSyncStatusPendingReboot),
// },
// ProvisioningState: to.Ptr(armhorizondb.ProvisioningStateSucceeded),
// },
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { HorizonDbClient } = require("@azure/arm-horizondb");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
*
* @summary updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupPendingReboot.json
*/
async function associateAHorizonDBPoolWithAParameterGroupPendingReboot() {
const credential = new DefaultAzureCredential();
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const client = new HorizonDbClient(credential, subscriptionId);
const result = await client.pools.update(
"example-resource-group",
"example-cluster",
"example-pool-01",
{
properties: {
parameterGroup: {
parameterGroupResourceId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters",
applyMethod: "PendingReboot",
},
},
},
);
console.log(result);
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01",
"name": "example-pool-01",
"type": "Microsoft.HorizonDb/clusters/pools",
"properties": {
"state": "Ready",
"computeModel": {
"type": "Provisioned",
"computeProcessor": "AMD",
"computeGeneration": 3,
"vCores": 8
},
"nodeCount": 3,
"highAvailability": {
"mode": "AnyZone"
},
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/maintenance-window-parameters",
"applyMethod": "PendingReboot",
"syncStatus": "PendingReboot"
},
"provisioningState": "Succeeded"
}
}
Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationStatuses/45454545-4545-4545-4545-454545454545?api-version=2026-10-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationResults/45454545-4545-4545-4545-454545454545?api-version=2026-10-01-preview
Retry-After: 30
Require zone-redundant placement for a HorizonDB pool
Sample request
PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01?api-version=2026-10-01-preview
{
"properties": {
"highAvailability": {
"mode": "ZoneRedundant"
}
}
}
import com.azure.resourcemanager.horizondb.models.Pool;
import com.azure.resourcemanager.horizondb.models.PoolHighAvailabilityMode;
import com.azure.resourcemanager.horizondb.models.PoolHighAvailabilityPatch;
import com.azure.resourcemanager.horizondb.models.PoolPropertiesForPatchUpdate;
/**
* Samples for Pools Update.
*/
public final class Main {
/*
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateHighAvailabilityMode.json
*/
/**
* Sample code: Require zone-redundant placement for a HorizonDB pool.
*
* @param manager Entry point to HorizonDbManager.
*/
public static void
requireZoneRedundantPlacementForAHorizonDBPool(com.azure.resourcemanager.horizondb.HorizonDbManager manager) {
Pool resource = manager.pools().getWithResponse("example-resource-group", "example-cluster", "example-pool-01",
com.azure.core.util.Context.NONE).getValue();
resource.update().withProperties(new PoolPropertiesForPatchUpdate()
.withHighAvailability(new PoolHighAvailabilityPatch().withMode(PoolHighAvailabilityMode.ZONE_REDUNDANT)))
.apply();
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.horizondb import HorizonDBMgmtClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-horizondb
# USAGE
python pools_update_high_availability_mode.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = HorizonDBMgmtClient(
credential=DefaultAzureCredential(),
subscription_id="SUBSCRIPTION_ID",
)
response = client.pools.begin_update(
resource_group_name="example-resource-group",
cluster_name="example-cluster",
pool_name="example-pool-01",
properties={"properties": {"highAvailability": {"mode": "ZoneRedundant"}}},
).result()
print(response)
# x-ms-original-file: 2026-10-01-preview/Pools_UpdateHighAvailabilityMode.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armhorizondb_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/horizondb/armhorizondb"
)
// Generated from example definition: 2026-10-01-preview/Pools_UpdateHighAvailabilityMode.json
func ExamplePoolsClient_BeginUpdate_requireZoneRedundantPlacementForAHorizonDbPool() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhorizondb.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "example-resource-group", "example-cluster", "example-pool-01", armhorizondb.PoolForPatchUpdate{
Properties: &armhorizondb.PoolPropertiesForPatchUpdate{
HighAvailability: &armhorizondb.PoolHighAvailabilityPatch{
Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeZoneRedundant),
},
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to poll the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armhorizondb.PoolsClientUpdateResponse{
// Pool: armhorizondb.Pool{
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01"),
// Name: to.Ptr("example-pool-01"),
// Type: to.Ptr("Microsoft.HorizonDb/clusters/pools"),
// Properties: &armhorizondb.PoolProperties{
// State: to.Ptr(armhorizondb.PoolStateReady),
// ComputeModel: &armhorizondb.PoolComputeModel{
// Type: to.Ptr(armhorizondb.PoolComputeModelTypeProvisioned),
// ComputeProcessor: to.Ptr(armhorizondb.ComputeProcessorTypeAMD),
// ComputeGeneration: to.Ptr[int32](3),
// VCores: to.Ptr[int32](8),
// },
// NodeCount: to.Ptr[int32](3),
// HighAvailability: &armhorizondb.PoolHighAvailability{
// Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeZoneRedundant),
// },
// ParameterGroup: &armhorizondb.PoolParameterGroupReference{
// ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters"),
// ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
// SyncStatus: to.Ptr(armhorizondb.ParameterGroupSyncStatusInSync),
// },
// ScheduledMaintenance: &armhorizondb.SystemScheduledMaintenanceProperties{
// MaintenanceManagementType: to.Ptr(armhorizondb.ScheduledMaintenanceManagementTypeSystem),
// },
// ProvisioningState: to.Ptr(armhorizondb.ProvisioningStateSucceeded),
// },
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { HorizonDbClient } = require("@azure/arm-horizondb");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
*
* @summary updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateHighAvailabilityMode.json
*/
async function requireZoneRedundantPlacementForAHorizonDBPool() {
const credential = new DefaultAzureCredential();
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const client = new HorizonDbClient(credential, subscriptionId);
const result = await client.pools.update(
"example-resource-group",
"example-cluster",
"example-pool-01",
{ properties: { highAvailability: { mode: "ZoneRedundant" } } },
);
console.log(result);
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01",
"name": "example-pool-01",
"type": "Microsoft.HorizonDb/clusters/pools",
"properties": {
"state": "Ready",
"computeModel": {
"type": "Provisioned",
"computeProcessor": "AMD",
"computeGeneration": 3,
"vCores": 8
},
"nodeCount": 3,
"highAvailability": {
"mode": "ZoneRedundant"
},
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/parameterGroups/production-parameters",
"applyMethod": "Immediate",
"syncStatus": "InSync"
},
"scheduledMaintenance": {
"maintenanceManagementType": "System"
},
"provisioningState": "Succeeded"
}
}
Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationStatuses/78787878-7878-7878-7878-787878787878?api-version=2026-10-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationResults/78787878-7878-7878-7878-787878787878?api-version=2026-10-01-preview
Retry-After: 30
Switch a HorizonDB pool back to its corresponding default parameter group
Sample request
PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01?api-version=2026-10-01-preview
{
"properties": {
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned",
"applyMethod": "Immediate"
}
}
}
import com.azure.resourcemanager.horizondb.models.ParameterApplyMethod;
import com.azure.resourcemanager.horizondb.models.Pool;
import com.azure.resourcemanager.horizondb.models.PoolParameterGroupReferenceForPatchUpdate;
import com.azure.resourcemanager.horizondb.models.PoolPropertiesForPatchUpdate;
/**
* Samples for Pools Update.
*/
public final class Main {
/*
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupDefault.json
*/
/**
* Sample code: Switch a HorizonDB pool back to its corresponding default parameter group.
*
* @param manager Entry point to HorizonDbManager.
*/
public static void switchAHorizonDBPoolBackToItsCorrespondingDefaultParameterGroup(
com.azure.resourcemanager.horizondb.HorizonDbManager manager) {
Pool resource = manager.pools().getWithResponse("example-resource-group", "example-cluster", "example-pool-01",
com.azure.core.util.Context.NONE).getValue();
resource.update().withProperties(new PoolPropertiesForPatchUpdate()
.withParameterGroup(new PoolParameterGroupReferenceForPatchUpdate().withParameterGroupResourceId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned")
.withApplyMethod(ParameterApplyMethod.IMMEDIATE)))
.apply();
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.horizondb import HorizonDBMgmtClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-horizondb
# USAGE
python pools_update_parameter_group_default.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = HorizonDBMgmtClient(
credential=DefaultAzureCredential(),
subscription_id="SUBSCRIPTION_ID",
)
response = client.pools.begin_update(
resource_group_name="example-resource-group",
cluster_name="example-cluster",
pool_name="example-pool-01",
properties={
"properties": {
"parameterGroup": {
"applyMethod": "Immediate",
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned",
}
}
},
).result()
print(response)
# x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupDefault.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armhorizondb_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/horizondb/armhorizondb"
)
// Generated from example definition: 2026-10-01-preview/Pools_UpdateParameterGroupDefault.json
func ExamplePoolsClient_BeginUpdate_switchAHorizonDbPoolBackToItsCorrespondingDefaultParameterGroup() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhorizondb.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "example-resource-group", "example-cluster", "example-pool-01", armhorizondb.PoolForPatchUpdate{
Properties: &armhorizondb.PoolPropertiesForPatchUpdate{
ParameterGroup: &armhorizondb.PoolParameterGroupReferenceForPatchUpdate{
ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned"),
ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
},
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to poll the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armhorizondb.PoolsClientUpdateResponse{
// Pool: armhorizondb.Pool{
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01"),
// Name: to.Ptr("example-pool-01"),
// Type: to.Ptr("Microsoft.HorizonDb/clusters/pools"),
// Properties: &armhorizondb.PoolProperties{
// State: to.Ptr(armhorizondb.PoolStateReady),
// ComputeModel: &armhorizondb.PoolComputeModel{
// Type: to.Ptr(armhorizondb.PoolComputeModelTypeProvisioned),
// ComputeProcessor: to.Ptr(armhorizondb.ComputeProcessorTypeAMD),
// ComputeGeneration: to.Ptr[int32](3),
// VCores: to.Ptr[int32](8),
// },
// NodeCount: to.Ptr[int32](3),
// HighAvailability: &armhorizondb.PoolHighAvailability{
// Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeAnyZone),
// },
// ParameterGroup: &armhorizondb.PoolParameterGroupReference{
// ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned"),
// ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
// SyncStatus: to.Ptr(armhorizondb.ParameterGroupSyncStatusApplying),
// },
// ProvisioningState: to.Ptr(armhorizondb.ProvisioningStateSucceeded),
// },
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { HorizonDbClient } = require("@azure/arm-horizondb");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
*
* @summary updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
* x-ms-original-file: 2026-10-01-preview/Pools_UpdateParameterGroupDefault.json
*/
async function switchAHorizonDBPoolBackToItsCorrespondingDefaultParameterGroup() {
const credential = new DefaultAzureCredential();
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const client = new HorizonDbClient(credential, subscriptionId);
const result = await client.pools.update(
"example-resource-group",
"example-cluster",
"example-pool-01",
{
properties: {
parameterGroup: {
parameterGroupResourceId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned",
applyMethod: "Immediate",
},
},
},
);
console.log(result);
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01",
"name": "example-pool-01",
"type": "Microsoft.HorizonDb/clusters/pools",
"properties": {
"state": "Ready",
"computeModel": {
"type": "Provisioned",
"computeProcessor": "AMD",
"computeGeneration": 3,
"vCores": 8
},
"nodeCount": 3,
"highAvailability": {
"mode": "AnyZone"
},
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned",
"applyMethod": "Immediate",
"syncStatus": "Applying"
},
"provisioningState": "Succeeded"
}
}
Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationStatuses/56565656-5656-5656-5656-565656565656?api-version=2026-10-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationResults/56565656-5656-5656-5656-565656565656?api-version=2026-10-01-preview
Retry-After: 30
Update a single HorizonDB pool compute property
Sample request
PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01?api-version=2026-10-01-preview
{
"properties": {
"computeModel": {
"vCores": 16
},
"scheduledMaintenance": {
"maintenanceManagementType": "System"
}
}
}
import com.azure.resourcemanager.horizondb.models.Pool;
import com.azure.resourcemanager.horizondb.models.PoolComputeModelForPatchUpdate;
import com.azure.resourcemanager.horizondb.models.PoolPropertiesForPatchUpdate;
import com.azure.resourcemanager.horizondb.models.ScheduledMaintenanceManagementType;
import com.azure.resourcemanager.horizondb.models.ScheduledMaintenancePropertiesForPatchUpdate;
/**
* Samples for Pools Update.
*/
public final class Main {
/*
* x-ms-original-file: 2026-10-01-preview/Pools_Update.json
*/
/**
* Sample code: Update a single HorizonDB pool compute property.
*
* @param manager Entry point to HorizonDbManager.
*/
public static void
updateASingleHorizonDBPoolComputeProperty(com.azure.resourcemanager.horizondb.HorizonDbManager manager) {
Pool resource = manager.pools().getWithResponse("example-resource-group", "example-cluster", "example-pool-01",
com.azure.core.util.Context.NONE).getValue();
resource.update()
.withProperties(
new PoolPropertiesForPatchUpdate().withComputeModel(new PoolComputeModelForPatchUpdate().withVCores(16))
.withScheduledMaintenance(new ScheduledMaintenancePropertiesForPatchUpdate()
.withMaintenanceManagementType(ScheduledMaintenanceManagementType.SYSTEM)))
.apply();
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.horizondb import HorizonDBMgmtClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-horizondb
# USAGE
python pools_update.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = HorizonDBMgmtClient(
credential=DefaultAzureCredential(),
subscription_id="SUBSCRIPTION_ID",
)
response = client.pools.begin_update(
resource_group_name="example-resource-group",
cluster_name="example-cluster",
pool_name="example-pool-01",
properties={
"properties": {
"computeModel": {"vCores": 16},
"scheduledMaintenance": {"maintenanceManagementType": "System"},
}
},
).result()
print(response)
# x-ms-original-file: 2026-10-01-preview/Pools_Update.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armhorizondb_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/horizondb/armhorizondb"
)
// Generated from example definition: 2026-10-01-preview/Pools_Update.json
func ExamplePoolsClient_BeginUpdate_updateASingleHorizonDbPoolComputeProperty() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armhorizondb.NewClientFactory("ffffffff-ffff-ffff-ffff-ffffffffffff", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPoolsClient().BeginUpdate(ctx, "example-resource-group", "example-cluster", "example-pool-01", armhorizondb.PoolForPatchUpdate{
Properties: &armhorizondb.PoolPropertiesForPatchUpdate{
ComputeModel: &armhorizondb.PoolComputeModelForPatchUpdate{
VCores: to.Ptr[int32](16),
},
ScheduledMaintenance: &armhorizondb.ScheduledMaintenancePropertiesForPatchUpdate{
MaintenanceManagementType: to.Ptr(armhorizondb.ScheduledMaintenanceManagementTypeSystem),
},
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to poll the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res = armhorizondb.PoolsClientUpdateResponse{
// Pool: armhorizondb.Pool{
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01"),
// Name: to.Ptr("example-pool-01"),
// Type: to.Ptr("Microsoft.HorizonDb/clusters/pools"),
// Properties: &armhorizondb.PoolProperties{
// State: to.Ptr(armhorizondb.PoolStateReady),
// ComputeModel: &armhorizondb.PoolComputeModel{
// Type: to.Ptr(armhorizondb.PoolComputeModelTypeProvisioned),
// ComputeProcessor: to.Ptr(armhorizondb.ComputeProcessorTypeAMD),
// ComputeGeneration: to.Ptr[int32](3),
// VCores: to.Ptr[int32](16),
// },
// NodeCount: to.Ptr[int32](3),
// HighAvailability: &armhorizondb.PoolHighAvailability{
// Mode: to.Ptr(armhorizondb.PoolHighAvailabilityModeAnyZone),
// },
// ParameterGroup: &armhorizondb.PoolParameterGroupReference{
// ParameterGroupResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned"),
// ApplyMethod: to.Ptr(armhorizondb.ParameterApplyMethodImmediate),
// SyncStatus: to.Ptr(armhorizondb.ParameterGroupSyncStatusInSync),
// },
// ScheduledMaintenance: &armhorizondb.SystemScheduledMaintenanceProperties{
// MaintenanceManagementType: to.Ptr(armhorizondb.ScheduledMaintenanceManagementTypeSystem),
// },
// ProvisioningState: to.Ptr(armhorizondb.ProvisioningStateSucceeded),
// },
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { HorizonDbClient } = require("@azure/arm-horizondb");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
*
* @summary updates an existing HorizonDB pool, including its node allocation, selected compute model properties, compute model type, high-availability configuration, or associated parameter group. Omitted nodeCount and highAvailability.mode values preserve their existing values; the service recursively merges the PATCH before atomically validating the effective tuple. nodeCount, when supplied, must be 1 through 16. Disabled is valid only when the effective nodeCount is 1. AnyZone and ZoneRedundant are valid only when the effective nodeCount is 2 through 16. Therefore, crossing between those node-count ranges requires nodeCount and highAvailability.mode to be changed together. AnyZone permits same-zone or cross-zone placement. Changing from AnyZone to ZoneRedundant may allocate a replacement node in another availability zone and replace a read-only node, disconnecting connections to the replaced node. If all requested nodes or the required zonal topology cannot be provisioned, the long-running operation fails and the previous resource state is preserved. To deallocate runtime compute without changing the configured nodeCount, use the Pool stop action. When parameterGroup is supplied, both parameterGroupResourceId and applyMethod are required. The pool can switch its association in either direction between the corresponding default parameter group and a customer-created parameter group. applyMethod controls when dynamic parameter changes become effective. Static parameter changes always require a customer-initiated Restart; Stop followed by Start and scheduled maintenance do not apply pending changes. Subtype-specific compute constraints are validated against the recursively merged configuration.
* x-ms-original-file: 2026-10-01-preview/Pools_Update.json
*/
async function updateASingleHorizonDBPoolComputeProperty() {
const credential = new DefaultAzureCredential();
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const client = new HorizonDbClient(credential, subscriptionId);
const result = await client.pools.update(
"example-resource-group",
"example-cluster",
"example-pool-01",
{
properties: {
computeModel: { vCores: 16 },
scheduledMaintenance: { maintenanceManagementType: "System" },
},
},
);
console.log(result);
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/example-resource-group/providers/Microsoft.HorizonDb/clusters/example-cluster/pools/example-pool-01",
"name": "example-pool-01",
"type": "Microsoft.HorizonDb/clusters/pools",
"properties": {
"state": "Ready",
"computeModel": {
"type": "Provisioned",
"computeProcessor": "AMD",
"computeGeneration": 3,
"vCores": 16
},
"nodeCount": 3,
"highAvailability": {
"mode": "AnyZone"
},
"parameterGroup": {
"parameterGroupResourceId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/parameterGroups/default-postgresql-17-provisioned",
"applyMethod": "Immediate",
"syncStatus": "InSync"
},
"scheduledMaintenance": {
"maintenanceManagementType": "System"
},
"provisioningState": "Succeeded"
}
}
Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationStatuses/77777777-7777-7777-7777-777777777777?api-version=2026-10-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.HorizonDb/locations/eastus2/operationResults/77777777-7777-7777-7777-777777777777?api-version=2026-10-01-preview
Retry-After: 30
Definitions
| Name |
Description |
|
ComputeProcessorType
|
The compute processor type.
|
|
createdByType
|
The type of identity that created the resource.
|
|
ErrorAdditionalInfo
|
The resource management error additional info.
|
|
ErrorDetail
|
The error detail.
|
|
ErrorResponse
|
Error response
|
|
ParameterApplyMethod
|
Controls when dynamic parameter changes become effective. Static parameter changes always become effective only after a customer-initiated pool Restart. Stop followed by Start and scheduled maintenance do not apply pending parameter changes.
|
|
ParameterGroupSyncStatus
|
Indicates synchronization status between a HorizonDB resource and its parameter group.
|
|
Pool
|
Represents the HorizonDB pool.
|
|
PoolComputeModel
|
The compute model for a HorizonDB pool.
|
|
PoolComputeModelForPatchUpdate
|
The compute model properties of a HorizonDB pool that can be updated. The object is recursively mergeable: omitted properties preserve their current values. Properties that do not apply to the current or target compute model type are rejected. When type changes, the request must include the complete target compute model. Subtype-specific constraints are validated against the effective merged configuration; invalid requests are rejected without changing the resource.
|
|
PoolComputeModelType
|
The compute model type.
|
|
PoolForPatchUpdate
|
HorizonDB pool for update operations.
|
|
PoolHighAvailability
|
The high-availability configuration for a HorizonDB pool.
|
|
PoolHighAvailabilityMode
|
The high-availability mode requested for a HorizonDB pool.
|
|
PoolHighAvailabilityPatch
|
The high-availability configuration for a HorizonDB pool update.
|
|
PoolParameterGroupReference
|
A reference to the parameter group associated with a HorizonDB pool. The schema represents both default and customer-created parameter groups for create and update compatibility. In this API version, initial pool creation accepts only the corresponding default parameter group; PUT updates to an existing pool can associate either group type.
|
|
PoolParameterGroupReferenceForPatchUpdate
|
A parameter group reference for updating an existing HorizonDB pool. The pool can switch in either direction between its corresponding default parameter group and a customer-created parameter group.
|
|
PoolProperties
|
Properties of a HorizonDB pool.
|
|
PoolPropertiesForPatchUpdate
|
Properties of a HorizonDB pool for update operations.
|
|
PoolState
|
Current state of a HorizonDB pool.
|
|
ProvisioningState
|
The provisioning state.
|
|
ScheduledMaintenanceManagementType
|
Specifies who manages scheduled maintenance for a HorizonDB pool.
|
|
ScheduledMaintenancePropertiesForPatchUpdate
|
The scheduled maintenance configuration for a pool update operation.
|
|
systemData
|
Metadata pertaining to creation and last modification of the resource.
|
|
SystemScheduledMaintenanceProperties
|
The system-managed scheduled maintenance configuration for a HorizonDB pool. User-managed schedule properties must be absent.
|
ComputeProcessorType
Enumeration
The compute processor type.
| Value |
Description |
|
Intel
|
Intel processor
|
|
AMD
|
AMD processor
|
createdByType
Enumeration
The type of identity that created the resource.
| Value |
Description |
|
User
|
|
|
Application
|
|
|
ManagedIdentity
|
|
|
Key
|
|
ErrorAdditionalInfo
Object
The resource management error additional info.
| Name |
Type |
Description |
|
info
|
object
|
The additional info.
|
|
type
|
string
|
The additional info type.
|
ErrorDetail
Object
The error detail.
| Name |
Type |
Description |
|
additionalInfo
|
ErrorAdditionalInfo[]
|
The error additional info.
|
|
code
|
string
|
The error code.
|
|
details
|
ErrorDetail[]
|
The error details.
|
|
message
|
string
|
The error message.
|
|
target
|
string
|
The error target.
|
ErrorResponse
Object
Error response
| Name |
Type |
Description |
|
error
|
ErrorDetail
|
The error object.
|
ParameterApplyMethod
Enumeration
Controls when dynamic parameter changes become effective. Static parameter changes always become effective only after a customer-initiated pool Restart. Stop followed by Start and scheduled maintenance do not apply pending parameter changes.
| Value |
Description |
|
Immediate
|
Apply dynamic parameter changes immediately. Static parameter changes remain pending until a customer-initiated pool Restart.
|
|
PendingReboot
|
Keep dynamic and static parameter changes pending until a customer-initiated pool Restart. Stop followed by Start and scheduled maintenance do not apply them.
|
ParameterGroupSyncStatus
Enumeration
Indicates synchronization status between a HorizonDB resource and its parameter group.
| Value |
Description |
|
Applying
|
Parameter updates are currently being applied.
|
|
InSync
|
Parameter values are synchronized and up to date.
|
|
FailedToApply
|
Applying parameter updates failed.
|
|
PendingReboot
|
Parameter updates are pending and require a customer-initiated pool Restart to take effect. Stop followed by Start and scheduled maintenance preserve this status.
|
Pool
Object
Represents the HorizonDB pool.
| Name |
Type |
Description |
|
id
|
string
(arm-id)
|
Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
|
|
name
|
string
|
The name of the resource
|
|
properties
|
PoolProperties
|
The resource-specific properties for this resource.
|
|
systemData
|
systemData
|
Azure Resource Manager metadata containing createdBy and modifiedBy information.
|
|
type
|
string
|
The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
|
PoolComputeModel
Object
The compute model for a HorizonDB pool.
| Name |
Type |
Description |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
The compute generation for the compute model.
|
|
computeProcessor
|
ComputeProcessorType
|
The processor type for the compute model.
|
|
type
|
PoolComputeModelType
|
The type of compute model.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
The number of vCores. Allowed values are 1 through 192.
|
PoolComputeModelForPatchUpdate
Object
The compute model properties of a HorizonDB pool that can be updated. The object is recursively mergeable: omitted properties preserve their current values. Properties that do not apply to the current or target compute model type are rejected. When type changes, the request must include the complete target compute model. Subtype-specific constraints are validated against the effective merged configuration; invalid requests are rejected without changing the resource.
| Name |
Type |
Description |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
The compute generation for the compute model. Omission preserves the current compute generation.
|
|
computeProcessor
|
ComputeProcessorType
|
The processor type for the compute model. Omission preserves the current processor type.
|
|
type
|
PoolComputeModelType
|
The compute model type. Omit this property to retain the current type. Resubmitting the current type succeeds as an idempotent no-op. To change the type, supply all common properties and all properties required by the target type.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
The number of provisioned vCores. Allowed values are 1 through 192. This property applies only to a Provisioned compute model. Omission preserves the current value.
|
PoolComputeModelType
Enumeration
The compute model type.
| Value |
Description |
|
Provisioned
|
Provisioned compute model
|
PoolForPatchUpdate
Object
HorizonDB pool for update operations.
PoolHighAvailability
Object
The high-availability configuration for a HorizonDB pool.
| Name |
Type |
Description |
|
mode
|
PoolHighAvailabilityMode
|
The high-availability mode. Disabled is required when nodeCount is 1. AnyZone or ZoneRedundant is required when nodeCount is 2 through 16.
|
PoolHighAvailabilityMode
Enumeration
The high-availability mode requested for a HorizonDB pool.
| Value |
Description |
|
Disabled
|
High availability is disabled. This mode is valid only when nodeCount is 1.
|
|
AnyZone
|
The service may allocate nodes in the same availability zone or across availability zones. This mode is valid only when nodeCount is 2 through 16.
|
|
ZoneRedundant
|
The service must allocate nodes across availability zones. This mode is valid only when nodeCount is 2 through 16.
|
PoolHighAvailabilityPatch
Object
The high-availability configuration for a HorizonDB pool update.
| Name |
Type |
Description |
|
mode
|
PoolHighAvailabilityMode
|
The high-availability mode. Omission preserves the current mode before the service validates it with the effective nodeCount.
|
PoolParameterGroupReference
Object
A reference to the parameter group associated with a HorizonDB pool. The schema represents both default and customer-created parameter groups for create and update compatibility. In this API version, initial pool creation accepts only the corresponding default parameter group; PUT updates to an existing pool can associate either group type.
| Name |
Type |
Description |
|
applyMethod
|
ParameterApplyMethod
|
Determines when dynamic parameter changes from the associated parameter group become effective. Static parameter changes always require a customer-initiated pool Restart, regardless of this value. Stop followed by Start and scheduled maintenance do not apply pending parameter changes.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
The Azure resource ID of the associated parameter group. When the parameter group is supplied during initial pool creation in this API version, the ID must identify the corresponding Microsoft.HorizonDb/locations/parameterGroups resource. For an existing pool, PUT can specify either the corresponding default group or a customer-created Microsoft.HorizonDb/parameterGroups resource.
|
|
syncStatus
|
ParameterGroupSyncStatus
|
The synchronization status between the pool and its parameter group. PendingReboot changes remain pending across Stop, Start, and scheduled maintenance and become effective only after a customer-initiated Restart.
|
PoolParameterGroupReferenceForPatchUpdate
Object
A parameter group reference for updating an existing HorizonDB pool. The pool can switch in either direction between its corresponding default parameter group and a customer-created parameter group.
| Name |
Type |
Description |
|
applyMethod
|
ParameterApplyMethod
|
Determines when dynamic parameter changes from the associated parameter group become effective. Static parameter changes always require a customer-initiated pool Restart, regardless of this value. Stop followed by Start and scheduled maintenance do not apply pending parameter changes.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
The Azure resource ID of the corresponding default or customer-created parameter group to associate with the existing pool.
|
PoolProperties
Object
Properties of a HorizonDB pool.
| Name |
Type |
Description |
|
computeModel
|
PoolComputeModel
|
The required compute model for the HorizonDB pool.
|
|
highAvailability
|
PoolHighAvailability
|
The required high-availability configuration for the pool. mode must be Disabled when nodeCount is 1, and must be AnyZone or ZoneRedundant when nodeCount is 2 through 16.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
The required number of nodes to allocate and assign to the pool. Allowed values are 1 through 16. To deallocate runtime compute without changing the configured node count, stop the pool.
|
|
parameterGroup
|
PoolParameterGroupReference
|
The parameter group associated with the pool. When omitted during creation, the service applies the default parameter group compatible with the parent cluster's PostgreSQL version. When supplied during creation in this API version, it must reference the corresponding default parameter group; customer-created parameter groups are not accepted during creation. For an existing pool, PUT or PATCH can associate either the corresponding default parameter group or a customer-created parameter group. The create-visible shape intentionally supports both resource ID forms so a future API version can allow customer-created parameter groups during creation without a breaking schema change.
|
|
provisioningState
|
ProvisioningState
|
The provisioning state of the pool.
|
|
scheduledMaintenance
|
ScheduledMaintenanceProperties:
SystemScheduledMaintenanceProperties
|
The scheduled maintenance configuration for the pool. The properties available depend on the selected maintenance management type.
|
|
state
|
PoolState
|
Current state of the pool.
|
PoolPropertiesForPatchUpdate
Object
Properties of a HorizonDB pool for update operations.
| Name |
Type |
Description |
|
computeModel
|
PoolComputeModelForPatchUpdate
|
The compute model properties to update. Omitted properties preserve their current values. To change the compute model type, supply the complete target compute model, including type, computeProcessor, computeGeneration, and all properties required by the target type.
|
|
highAvailability
|
PoolHighAvailabilityPatch
|
The high-availability configuration to update. Omission preserves the current mode. The service recursively merges omitted PATCH properties with the existing resource before validating the effective nodeCount and mode together.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
The number of nodes to allocate and assign to the pool. Allowed values are 1 through 16. Omission preserves the current configured value. To deallocate runtime compute without changing the configured node count, stop the pool.
|
|
parameterGroup
|
PoolParameterGroupReferenceForPatchUpdate
|
The corresponding default or a customer-created parameter group to associate with the existing pool. Customers can switch in either direction between these group types. Omission preserves the current association.
|
|
scheduledMaintenance
|
ScheduledMaintenancePropertiesForPatchUpdate
|
The scheduled maintenance configuration to update for the pool. When supplied, the complete configuration for the selected maintenance management type is required. Omission preserves the current configuration.
|
PoolState
Enumeration
Current state of a HorizonDB pool.
| Value |
Description |
|
Ready
|
Is ready and operational
|
|
Provisioning
|
Is provisioning
|
|
Deleting
|
Is being deleted
|
|
Inaccessible
|
Is inaccessible
|
|
Updating
|
Is being updated
|
|
Starting
|
Is starting up
|
|
Restarting
|
Is restarting
|
|
Stopping
|
Is stopping
|
|
Stopped
|
Is stopped
|
ProvisioningState
Enumeration
The provisioning state.
| Value |
Description |
|
Succeeded
|
Resource has been created.
|
|
Failed
|
Resource creation failed.
|
|
Canceled
|
Resource creation was canceled.
|
|
InProgress
|
The HorizonDB resource operation is actively running.
|
|
Provisioning
|
The HorizonDB resource is still provisioning.
|
|
Updating
|
The resource is being updated.
|
ScheduledMaintenanceManagementType
Enumeration
Specifies who manages scheduled maintenance for a HorizonDB pool.
| Value |
Description |
|
System
|
Scheduled maintenance is managed by the system.
|
ScheduledMaintenancePropertiesForPatchUpdate
Object
The scheduled maintenance configuration for a pool update operation.
| Name |
Type |
Description |
|
maintenanceManagementType
|
ScheduledMaintenanceManagementType
|
Specifies whether scheduled maintenance is managed by the system or by the user. When scheduledMaintenance is supplied, this property is required by the service.
|
systemData
Object
Metadata pertaining to creation and last modification of the resource.
| Name |
Type |
Description |
|
createdAt
|
string
(date-time)
|
The timestamp of resource creation (UTC).
|
|
createdBy
|
string
|
The identity that created the resource.
|
|
createdByType
|
createdByType
|
The type of identity that created the resource.
|
|
lastModifiedAt
|
string
(date-time)
|
The timestamp of resource last modification (UTC)
|
|
lastModifiedBy
|
string
|
The identity that last modified the resource.
|
|
lastModifiedByType
|
createdByType
|
The type of identity that last modified the resource.
|
SystemScheduledMaintenanceProperties
Object
The system-managed scheduled maintenance configuration for a HorizonDB pool. User-managed schedule properties must be absent.
| Name |
Type |
Description |
|
maintenanceManagementType
|
string:
System
|
Specifies whether scheduled maintenance is managed by the system or by the user.
|