Aktualizuje istniejącą pulę HorizonDB, w tym alokację węzłów, wybrane właściwości modelu obliczeniowego, typ modelu obliczeniowego, konfigurację wysokiej dostępności lub powiązaną grupę parametrów. Pominięte wartości nodeCount i highAvailability.mode zachowują swoje istniejące wartości; usługa rekurencyjnie łączy PATCH przed atomową weryfikacją efektywnej krotki. nodeCount po podaniu musi wynosić od 1 do 16. Wyłączone jest ważne tylko wtedy, gdy efektywna liczba węzłów wynosi 1. AnyZone i ZoneRedundant są ważne tylko wtedy, gdy efektywna liczba węzłów wynosi od 2 do 16. Dlatego przejście między tymi zakresami liczby węzłów wymaga jednoczesnej zmiany nodeCount i highAvailability.mode. AnyZone pozwala na umieszczanie w tej samej strefie lub między strefami. Zmiana z AnyZone na ZoneRedundant może przydzielić nowy węzeł w innej strefie dostępności i zastąpić węzeł tylko do odczytu, odłączając połączenia z nowym węzłem. Jeśli nie można przydzielić wszystkich żądanych węzłów lub wymaganej topologii strefowej, długotrwała operacja zostaje nieudana i zachowuje się poprzedni stan zasobu. Aby deallocate obliczenia w czasie wykonywania bez zmiany skonfigurowanego nodeCount, użyj akcji zatrzymania puli. Gdy podana jest parameterGroup, wymagane są zarówno parametryczneŹródłoWyid, jak i applyMethod. Pula może przełączać swoje powiązania w dowolnym kierunku między odpowiadającą grupą domyślnych parametrów a grupą parametrów stworzoną przez klienta. applyMethod kontroluje, gdy dynamiczne zmiany parametrów stają się skuteczne. Statyczne zmiany parametrów zawsze wymagają restartu inicjowanego przez klienta; Stop, a następnie Start oraz zaplanowana konserwacja nie stosują oczekujących zmian. Ograniczenia obliczeniowe specyficzne dla podtypu są weryfikowane względem konfiguracji rekurencyjnie połączonej.
PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.HorizonDb/clusters/{clusterName}/pools/{poolName}?api-version=2026-10-01-preview
Parametry identyfikatora URI
| Nazwisko |
W |
Wymagane |
Typ |
Opis |
|
clusterName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
Nazwa klastra HorizonDB.
|
|
poolName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
Nazwa puli HorizonDB.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
Nazwa grupy zasobów. Nazwa jest niewrażliwa na wielkość liter.
|
|
subscriptionId
|
path |
True
|
string
(uuid)
|
Identyfikator subskrypcji docelowej. Wartość musi być identyfikatorem UUID.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
Wersja interfejsu API do użycia dla tej operacji.
|
Treść żądania
| Nazwisko |
Typ |
Opis |
|
properties
|
PoolPropertiesForPatchUpdate
|
Właściwości, które można zaktualizować dla puli HorizonDB.
|
|
tags
|
object
|
Tagi zasobów.
|
Odpowiedzi
| Nazwisko |
Typ |
Opis |
|
200 OK
|
Pool
|
Operacja Azure zakończyła się pomyślnie.
|
|
202 Accepted
|
|
Żądanie aktualizacji zasobu zostało zaakceptowane.
Nagłówki
- Azure-AsyncOperation: string
- Location: string
- Retry-After: integer
|
|
Other Status Codes
|
ErrorResponse
|
Nieoczekiwana odpowiedź na błąd.
|
Zabezpieczenia
azure_auth
Przepływ OAuth2 w usłudze Azure Active Directory.
Typ:
oauth2
Flow:
implicit
Adres URL autoryzacji:
https://login.microsoftonline.com/common/oauth2/authorize
Zakresy
| Nazwisko |
Opis |
|
user_impersonation
|
podszywaj się pod konto użytkownika
|
Przykłady
Przykładowe żądanie
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
Przykładowa odpowiedź
{
"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
Przykładowe żądanie
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
Przykładowa odpowiedź
{
"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
Przykładowe żądanie
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
Przykładowa odpowiedź
{
"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
Przykładowe żądanie
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
Przykładowa odpowiedź
{
"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
Przykładowe żądanie
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
Przykładowa odpowiedź
{
"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
Definicje
| Nazwisko |
Opis |
|
ComputeProcessorType
|
Typ procesora obliczeniowego.
|
|
createdByType
|
Typ tożsamości, która utworzyła zasób.
|
|
ErrorAdditionalInfo
|
Dodatkowe informacje o błędzie zarządzania zasobami.
|
|
ErrorDetail
|
Szczegóły błędu.
|
|
ErrorResponse
|
Odpowiedź na błąd
|
|
ParameterApplyMethod
|
Kontroluje, gdy dynamiczne zmiany parametrów stają się skuteczne. Statyczne zmiany parametrów zawsze stają się skuteczne dopiero po restarcie puli inicjowanej przez klienta. Stop, a następnie Start oraz zaplanowana konserwacja nie stosują oczekujących zmian parametrów.
|
|
ParameterGroupSyncStatus
|
Wskazuje status synchronizacji między zasobem HorizonDB a jego grupą parametrów.
|
|
Pool
|
Reprezentuje pulę HorizonDB.
|
|
PoolComputeModel
|
Model obliczeniowy dla puli HorizonDB.
|
|
PoolComputeModelForPatchUpdate
|
Właściwości modelu obliczeniowego puli HorizonDB, które można aktualizować. Obiekt jest rekurencyjnie możliwy do scalania: pominięte właściwości zachowują swoje aktualne wartości. Właściwości, które nie mają zastosowania do obecnego lub docelowego typu modelu obliczeniowego, są odrzucane. Gdy typ się zmienia, żądanie musi zawierać cały docelowy model obliczeniowy. Ograniczenia specyficzne dla podtypu są weryfikowane względem efektywnej konfiguracji scalonej; nieprawidłowe żądania są odrzucane bez zmiany zasobu.
|
|
PoolComputeModelType
|
Typ modelu obliczeniowego.
|
|
PoolForPatchUpdate
|
Pula HorizonDB do operacji aktualizacji.
|
|
PoolHighAvailability
|
Konfiguracja wysokiej dostępności dla puli HorizonDB.
|
|
PoolHighAvailabilityMode
|
Tryb wysokiej dostępności wymagany dla puli HorizonDB.
|
|
PoolHighAvailabilityPatch
|
Konfiguracja wysokiej dostępności dla aktualizacji puli HorizonDB.
|
|
PoolParameterGroupReference
|
Odniesienie do grupy parametrów powiązanej z pulą HorizonDB. Schemat reprezentuje zarówno domyślne, jak i generowane przez klienta grupy parametrów dla kompatybilności tworzenia i aktualizacji. W tej wersji API początkowe tworzenie puli akceptuje tylko odpowiadającą im domyślną grupę parametrów; Aktualizacje PUT do istniejącej puli mogą przypisać dowolny typ grupy.
|
|
PoolParameterGroupReferenceForPatchUpdate
|
Referencja grupy parametrów do aktualizacji istniejącej puli HorizonDB. Pula może przełączać się w dowolnym kierunku między odpowiadającą grupą domyślnych parametrów a grupą parametrów stworzoną przez klienta.
|
|
PoolProperties
|
Właściwości puli HorizonDB.
|
|
PoolPropertiesForPatchUpdate
|
Właściwości puli HorizonDB do operacji aktualizacji.
|
|
PoolState
|
Aktualny stan puli HorizonDB.
|
|
ProvisioningState
|
Stan aprowizacji.
|
|
ScheduledMaintenanceManagementType
|
Określa, kto zarządza planowaną konserwacją puli HorizonDB.
|
|
ScheduledMaintenancePropertiesForPatchUpdate
|
Konfiguracja zaplanowanej konserwacji dla operacji aktualizacji puli.
|
|
systemData
|
Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.
|
|
SystemScheduledMaintenanceProperties
|
Systemowo zarządzana konfiguracja zaplanowanej konserwacji dla puli HorizonDB. Właściwości harmonogramu zarządzanego przez użytkownika muszą być nieobecne.
|
ComputeProcessorType
Wyliczenie
Typ procesora obliczeniowego.
| Wartość |
Opis |
|
Intel
|
Procesor firmy Intel
|
|
AMD
|
Procesor AMD
|
createdByType
Wyliczenie
Typ tożsamości, która utworzyła zasób.
| Wartość |
Opis |
|
User
|
|
|
Application
|
|
|
ManagedIdentity
|
|
|
Key
|
|
ErrorAdditionalInfo
Objekt
Dodatkowe informacje o błędzie zarządzania zasobami.
| Nazwisko |
Typ |
Opis |
|
info
|
object
|
Dodatkowe informacje.
|
|
type
|
string
|
Dodatkowy typ informacji.
|
ErrorDetail
Objekt
Szczegóły błędu.
| Nazwisko |
Typ |
Opis |
|
additionalInfo
|
ErrorAdditionalInfo[]
|
Dodatkowe informacje o błędzie
|
|
code
|
string
|
Kod błędu.
|
|
details
|
ErrorDetail[]
|
Szczegóły błędu.
|
|
message
|
string
|
Komunikat o błędzie.
|
|
target
|
string
|
Cel błędu.
|
ErrorResponse
Objekt
Odpowiedź na błąd
ParameterApplyMethod
Wyliczenie
Kontroluje, gdy dynamiczne zmiany parametrów stają się skuteczne. Statyczne zmiany parametrów zawsze stają się skuteczne dopiero po restarcie puli inicjowanej przez klienta. Stop, a następnie Start oraz zaplanowana konserwacja nie stosują oczekujących zmian parametrów.
| Wartość |
Opis |
|
Immediate
|
Natychmiast zastosuj zmiany parametrów dynamicznych. Zmiany parametrów statycznych pozostają w oczekiwaniu do czasu ponownego uruchomienia puli inicjowanej przez klienta.
|
|
PendingReboot
|
Zachowaj dynamiczne i statyczne zmiany parametrów do czasu ponownego uruchomienia puli inicjowanej przez klienta. Stop, potem Start i planowana konserwacja nie stosuj ich.
|
ParameterGroupSyncStatus
Wyliczenie
Wskazuje status synchronizacji między zasobem HorizonDB a jego grupą parametrów.
| Wartość |
Opis |
|
Applying
|
Obecnie wprowadzane są aktualizacje parametrów.
|
|
InSync
|
Wartości parametrów są zsynchronizowane i aktualne.
|
|
FailedToApply
|
Zastosowanie aktualizacji parametrów zakończyło się niepowodzeniem.
|
|
PendingReboot
|
Aktualizacje parametrów są w toku i wymagają restartu puli inicjowanego przez klienta, aby wejść w skutk. Stop, a następnie Start oraz planowana konserwacja utrzymują ten status.
|
Pool
Objekt
Reprezentuje pulę HorizonDB.
| Nazwisko |
Typ |
Opis |
|
id
|
string
(arm-id)
|
W pełni określony identyfikator zasobu dla tego zasobu. Np. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
|
|
name
|
string
|
Nazwa zasobu
|
|
properties
|
PoolProperties
|
Właściwości specyficzne dla zasobu dla tego zasobu.
|
|
systemData
|
systemData
|
Metadane usługi Azure Resource Manager zawierające informacje „createdBy” i „modifiedBy”.
|
|
tags
|
object
|
Tagi zasobów.
|
|
type
|
string
|
Typ zasobu. Np. "Microsoft.Compute/virtualMachines" lub "Microsoft.Storage/storageAccounts"
|
PoolComputeModel
Objekt
Model obliczeniowy dla puli HorizonDB.
| Nazwisko |
Typ |
Opis |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
Generowanie obliczeń dla modelu obliczeniowego.
|
|
computeProcessor
|
ComputeProcessorType
|
Typ procesora dla modelu obliczeniowego.
|
|
type
|
PoolComputeModelType
|
Typ modelu obliczeniowego.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
Liczba rdzeni wirtualnych. Dozwolone wartości to od 1 do 192.
|
PoolComputeModelForPatchUpdate
Objekt
Właściwości modelu obliczeniowego puli HorizonDB, które można aktualizować. Obiekt jest rekurencyjnie możliwy do scalania: pominięte właściwości zachowują swoje aktualne wartości. Właściwości, które nie mają zastosowania do obecnego lub docelowego typu modelu obliczeniowego, są odrzucane. Gdy typ się zmienia, żądanie musi zawierać cały docelowy model obliczeniowy. Ograniczenia specyficzne dla podtypu są weryfikowane względem efektywnej konfiguracji scalonej; nieprawidłowe żądania są odrzucane bez zmiany zasobu.
| Nazwisko |
Typ |
Opis |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
Generowanie obliczeń dla modelu obliczeniowego. Pominięcie zachowuje obecne generowanie obliczeń.
|
|
computeProcessor
|
ComputeProcessorType
|
Typ procesora dla modelu obliczeniowego. Pominięcie zachowuje aktualny typ procesora.
|
|
type
|
PoolComputeModelType
|
Typ modelu obliczeniowego. Pomijam tę właściwość, aby zachować aktualny typ. Ponowne przesłanie obecnego typu odnosi sukces jako idempotentny no-op. Aby zmienić typ, należy podać wszystkie wspólne właściwości oraz wszystkie właściwości wymagane przez typ docelowy.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
Liczba udostępnionych vCores. Dozwolone wartości to od 1 do 192. Ta właściwość dotyczy tylko modelu obliczeniowego Provisioned. Pominięcie zachowuje aktualną wartość.
|
PoolComputeModelType
Wyliczenie
Typ modelu obliczeniowego.
| Wartość |
Opis |
|
Provisioned
|
Model Provisioned compute
|
PoolForPatchUpdate
Objekt
Pula HorizonDB do operacji aktualizacji.
| Nazwisko |
Typ |
Opis |
|
properties
|
PoolPropertiesForPatchUpdate
|
Właściwości, które można zaktualizować dla puli HorizonDB.
|
|
tags
|
object
|
Tagi zasobów.
|
PoolHighAvailability
Objekt
Konfiguracja wysokiej dostępności dla puli HorizonDB.
| Nazwisko |
Typ |
Opis |
|
mode
|
PoolHighAvailabilityMode
|
Tryb wysokiej dostępności. Wyłączenie jest wymagane, gdy nodeCount wynosi 1. AnyZone lub ZoneRedundant jest wymagany, gdy nodeCount wynosi od 2 do 16.
|
PoolHighAvailabilityMode
Wyliczenie
Tryb wysokiej dostępności wymagany dla puli HorizonDB.
| Wartość |
Opis |
|
Disabled
|
Wysoka dostępność jest wyłączona. Ten tryb jest ważny tylko wtedy, gdy nodeCount wynosi 1.
|
|
AnyZone
|
Usługa może alokować węzły w tej samej strefie dostępności lub między strefami dostępności. Ten tryb jest ważny tylko wtedy, gdy nodeCount wynosi od 2 do 16.
|
|
ZoneRedundant
|
Usługa musi alokować węzły ponad strefami dostępności. Ten tryb jest ważny tylko wtedy, gdy nodeCount wynosi od 2 do 16.
|
PoolHighAvailabilityPatch
Objekt
Konfiguracja wysokiej dostępności dla aktualizacji puli HorizonDB.
| Nazwisko |
Typ |
Opis |
|
mode
|
PoolHighAvailabilityMode
|
Tryb wysokiej dostępności. Omissing zachowuje aktualny tryb przed jego weryfikacją przez usługę za pomocą efektywnego nodeCount.
|
PoolParameterGroupReference
Objekt
Odniesienie do grupy parametrów powiązanej z pulą HorizonDB. Schemat reprezentuje zarówno domyślne, jak i generowane przez klienta grupy parametrów dla kompatybilności tworzenia i aktualizacji. W tej wersji API początkowe tworzenie puli akceptuje tylko odpowiadającą im domyślną grupę parametrów; Aktualizacje PUT do istniejącej puli mogą przypisać dowolny typ grupy.
| Nazwisko |
Typ |
Opis |
|
applyMethod
|
ParameterApplyMethod
|
Określa, kiedy zmiany parametrów dynamicznych z powiązanej grupy parametrów stają się skuteczne. Statyczne zmiany parametrów zawsze wymagają restartu puli inicjowanego przez klienta, niezależnie od tej wartości. Stop, a następnie Start oraz zaplanowana konserwacja nie stosują oczekujących zmian parametrów.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
Identyfikator zasobów Azure powiązanej grupy parametrów. Początkowe tworzenie puli w tej wersji API wymaga odpowiedniego Microsoft. HorizonDb/locations/parameterGroups zasobów. Dla istniejącej puli PUT może określić albo odpowiadającą grupę domyślną, albo stworzoną przez klienta grupę Microsoft. HorizonDb/parameterGroups zasob.
|
|
syncStatus
|
ParameterGroupSyncStatus
|
Status synchronizacji między pulą a jej grupą parametrów. Zmiany w trakcie oczekiwania na Reboot pozostają w oczekiwaniu w trybie Stop, Start oraz planowanej konserwacji i stają się skuteczne dopiero po wznowieniu przez klienta Restartu.
|
PoolParameterGroupReferenceForPatchUpdate
Objekt
Referencja grupy parametrów do aktualizacji istniejącej puli HorizonDB. Pula może przełączać się w dowolnym kierunku między odpowiadającą grupą domyślnych parametrów a grupą parametrów stworzoną przez klienta.
| Nazwisko |
Typ |
Opis |
|
applyMethod
|
ParameterApplyMethod
|
Określa, kiedy zmiany parametrów dynamicznych z powiązanej grupy parametrów stają się skuteczne. Statyczne zmiany parametrów zawsze wymagają restartu puli inicjowanego przez klienta, niezależnie od tej wartości. Stop, a następnie Start oraz zaplanowana konserwacja nie stosują oczekujących zmian parametrów.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
Identyfikator zasobu Azure odpowiadającej grupy parametrów domyślnej lub utworzonej przez klienta do powiązania z istniejącą pulą.
|
PoolProperties
Objekt
Właściwości puli HorizonDB.
| Nazwisko |
Typ |
Opis |
|
computeModel
|
PoolComputeModel
|
Wymagany model obliczeniowy dla puli HorizonDB.
|
|
highAvailability
|
PoolHighAvailability
|
Wymagana konfiguracja wysokiej dostępności dla puli. tryb musi być wyłączony, gdy nodeCount wynosi 1, a AnyZone lub ZoneRedundant, gdy nodeCount wynosi od 2 do 16.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
Wymagana liczba węzłów do alokacji i przypisania do puli. Dozwolone wartości to od 1 do 16. Aby dokonać deallokacji obliczeń w czasie wykonywania bez zmiany skonfigurowanej liczby węzłów, zatrzymaj pulę.
|
|
parameterGroup
|
PoolParameterGroupReference
|
Wymagana grupa parametrów powiązana z pulą. Podczas tworzenia nowej puli w tej wersji API wywołujący musi podać odpowiadającą grupę parametrów; grupy parametrów tworzone przez klienta nie są akceptowane podczas tworzenia. Dla istniejącej puli PUT lub PATCH mogą przypisać odpowiadającą grupę domyślnych parametrów lub grupę parametrów stworzoną przez klienta. Kształt tworzenia widocznego celowo obsługuje oba formularze ID zasobów, aby przyszła wersja API mogła umożliwić tworzenie grup parametrów tworzonych przez klienta bez konieczności urywania schematu.
|
|
provisioningState
|
ProvisioningState
|
Stan udostępniania puli.
|
|
scheduledMaintenance
|
ScheduledMaintenanceProperties:
SystemScheduledMaintenanceProperties
|
Planowana konfiguracja konserwacji basenu. Dostępne nieruchomości zależą od wybranego typu zarządzania utrzymaniem.
|
|
state
|
PoolState
|
Obecny stan basenu.
|
PoolPropertiesForPatchUpdate
Objekt
Właściwości puli HorizonDB do operacji aktualizacji.
| Nazwisko |
Typ |
Opis |
|
computeModel
|
PoolComputeModelForPatchUpdate
|
Właściwości modelu obliczeniowego do aktualizacji. Pominięte właściwości zachowują swoje aktualne wartości. Aby zmienić typ modelu obliczeniowego, należy dostarczyć pełny docelowy model obliczeniowy, w tym typ, procesor obliczeniowy, generowanie obliczeń oraz wszystkie właściwości wymagane przez ten typ docelowy.
|
|
highAvailability
|
PoolHighAvailabilityPatch
|
Konfiguracja wysokiej dostępności do aktualizacji. Pominięcie zachowuje obecny tryb. Usługa rekurencyjnie łączy pominięte właściwości PATCH z istniejącym zasobem przed zweryfikowaniem efektywnego nodeCount i trybu razem.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
Liczba węzłów do alokacji i przypisania do puli. Dozwolone wartości to od 1 do 16. Pominięcie zachowuje aktualną skonfigurowaną wartość. Aby dokonać deallokacji obliczeń w czasie wykonywania bez zmiany skonfigurowanej liczby węzłów, zatrzymaj pulę.
|
|
parameterGroup
|
PoolParameterGroupReferenceForPatchUpdate
|
Odpowiadająca domyślna lub grupa parametrów stworzona przez klienta do powiązania z istniejącą pulą. Klienci mogą przełączać się w dowolnym kierunku między tymi typami grup. Pominięcie zachowuje obecne powiązanie.
|
|
scheduledMaintenance
|
ScheduledMaintenancePropertiesForPatchUpdate
|
Konfiguracja zaplanowanej konserwacji do aktualizacji dla puli. Po dostarczeniu wymagana jest pełna konfiguracja dla wybranego typu zarządzania utrzymaniem. Pominięcie zachowuje obecną konfigurację.
|
PoolState
Wyliczenie
Aktualny stan puli HorizonDB.
| Wartość |
Opis |
|
Ready
|
Jest gotowy i sprawny
|
|
Provisioning
|
To provisioning
|
|
Deleting
|
Jest usuwane
|
|
Inaccessible
|
Jest niedostępny
|
|
Updating
|
Jest aktualizowana
|
|
Starting
|
Zaczyna się
|
|
Restarting
|
Restartuje się.
|
|
Stopping
|
Przestaje
|
|
Stopped
|
Zostaje zatrzymane
|
ProvisioningState
Wyliczenie
Stan aprowizacji.
| Wartość |
Opis |
|
Succeeded
|
Zasób został utworzony.
|
|
Failed
|
Tworzenie zasobu nie powiodło się.
|
|
Canceled
|
Tworzenie zasobu zostało anulowane.
|
|
InProgress
|
Operacja zasobów HorizonDB jest aktywnie uruchomiona.
|
|
Provisioning
|
Zasób HorizonDB nadal jest w trakcie udostępniania.
|
ScheduledMaintenanceManagementType
Wyliczenie
Określa, kto zarządza planowaną konserwacją puli HorizonDB.
| Wartość |
Opis |
|
System
|
Planowaną konserwacją zarządza system.
|
ScheduledMaintenancePropertiesForPatchUpdate
Objekt
Konfiguracja zaplanowanej konserwacji dla operacji aktualizacji puli.
| Nazwisko |
Typ |
Opis |
|
maintenanceManagementType
|
ScheduledMaintenanceManagementType
|
Określa, czy zaplanowana konserwacja jest zarządzana przez system, czy przez użytkownika. Gdy planowana konserwacja jest dostarczana, ta właściwość jest wymagana przez usługę.
|
systemData
Objekt
Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.
| Nazwisko |
Typ |
Opis |
|
createdAt
|
string
(date-time)
|
Sygnatura czasowa tworzenia zasobu (UTC).
|
|
createdBy
|
string
|
Tożsamość, która utworzyła zasób.
|
|
createdByType
|
createdByType
|
Typ tożsamości, która utworzyła zasób.
|
|
lastModifiedAt
|
string
(date-time)
|
Znacznik czasu ostatniej modyfikacji zasobu (UTC)
|
|
lastModifiedBy
|
string
|
Tożsamość, która ostatnio zmodyfikowała zasób.
|
|
lastModifiedByType
|
createdByType
|
Typ tożsamości, która ostatnio zmodyfikowała zasób.
|
SystemScheduledMaintenanceProperties
Objekt
Systemowo zarządzana konfiguracja zaplanowanej konserwacji dla puli HorizonDB. Właściwości harmonogramu zarządzanego przez użytkownika muszą być nieobecne.
| Nazwisko |
Typ |
Opis |
|
maintenanceManagementType
|
string:
System
|
Określa, czy zaplanowana konserwacja jest zarządzana przez system, czy przez użytkownika.
|