Mevcut bir HorizonDB havuzunu, düğüm tahsisi, seçilmiş hesaplama modeli özellikleri, hesaplama model türü, yüksek kullanılabilirlik yapılandırması veya ilgili parametre grubunu günceller. Atlanan nodeCount ve highAvailability.mode değerleri mevcut değerlerini korur; hizmet, PATCH'i özyinelemeli olarak birleştirir ve ardından etkili tuple'ı atomik olarak doğrular. nodeCount sağlandığında 1'den 16'ya kadar olmalıdır. Disabled yalnızca etkili nodeCount 1 olduğunda geçerlidir. AnyZone ve ZoneRedundant yalnızca etkili nodeCount 2'den 16'ya kadar olduğunda geçerlidir. Bu nedenle, bu düğüm sayısı aralıkları arasında geçiş yapmak için nodeCount ve highAvailability.mode'un birlikte değiştirilmesini gerektirir. AnyZone aynı bölge veya bölgeler arası yerleştirmeye izin verir. AnyZone'dan ZoneRedundant'a geçmek, başka bir kullanılabilirlik bölgesinde bir yedek düğüm tahsis edebilir ve yalnızca okunabilir bir düğümü değiştirerek değiştirilen düğüme bağlantıyı koparabilir. Eğer istenen tüm düğümler veya gerekli zonal topoloji sağlanamazsa, uzun süreli işlem başarısız olur ve önceki kaynak durumu korunur. Yapılandırılmış nodeCount değişmeden çalışma zamanı hesaplamasını dağıtmak için Pool stop eylemini kullanın. parameterGroup sağlandığında, hem parameterGroupResourceId hem de applyMethod gereklidir. Havuz, ilişkisini karşılık gelen varsayılan parametre grubu ile müşteri tarafından oluşturulan bir parametre grubu arasında her iki yönde değiştirebilir. applyDinamik parametre değişiklikleri etkin hale geldiğinde metod kontrolleri. Statik parametre değişiklikleri her zaman müşteri tarafından başlatılan bir Yeniden başlatma gerektirir; Stop ve ardından Start ile planlı bakım bekleyen değişiklikleri uygulamaz. Alt tipe özgü hesaplama kısıtlamaları, özyinelemeli birleştirilmiş konfigürasyona karşı doğrulanır.
PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.HorizonDb/clusters/{clusterName}/pools/{poolName}?api-version=2026-10-01-preview
URI Parametreleri
| Veri Akışı Adı |
İçinde |
Gerekli |
Tür |
Description |
|
clusterName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
HorizonDB kümesinin adı.
|
|
poolName
|
path |
True
|
string
minLength: 1 maxLength: 63 pattern: ^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$
|
HorizonDB havuzunun adı.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
Kaynak grubunun adı. Ad büyük/küçük harfe duyarsız.
|
|
subscriptionId
|
path |
True
|
string
(uuid)
|
Hedef aboneliğin kimliği. Değer bir UUID olmalıdır.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
Bu işlem için kullanılacak API sürümü.
|
İstek Gövdesi
| Veri Akışı Adı |
Tür |
Description |
|
properties
|
PoolPropertiesForPatchUpdate
|
HorizonDB havuzu için güncellenebilecek özellikler.
|
|
tags
|
object
|
Kaynak etiketleri.
|
Yanıtlar
| Veri Akışı Adı |
Tür |
Description |
|
200 OK
|
Pool
|
Azure işlemi başarıyla tamamlandı.
|
|
202 Accepted
|
|
Kaynak güncelleştirme isteği kabul edildi.
Üst Bilgiler
- Azure-AsyncOperation: string
- Location: string
- Retry-After: integer
|
|
Other Status Codes
|
ErrorResponse
|
Beklenmeyen bir hata yanıtı.
|
Güvenlik
azure_auth
Azure Active Directory OAuth2 Akışı.
Tür:
oauth2
Akış:
implicit
Yetkilendirme URL’si:
https://login.microsoftonline.com/common/oauth2/authorize
Kapsamlar
| Veri Akışı Adı |
Description |
|
user_impersonation
|
kullanıcı hesabınızı taklit etme
|
Örnekler
Örnek isteği
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
Örnek yanıt
{
"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
Örnek isteği
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
Örnek yanıt
{
"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
Örnek isteği
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
Örnek yanıt
{
"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
Örnek isteği
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
Örnek yanıt
{
"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
Örnek isteği
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
Örnek yanıt
{
"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
Tanımlar
| Veri Akışı Adı |
Description |
|
ComputeProcessorType
|
Hesaplama işlemci türü.
|
|
createdByType
|
Kaynağı oluşturan kimliğin türü.
|
|
ErrorAdditionalInfo
|
Kaynak yönetimi hatasına ilişkin ek bilgiler.
|
|
ErrorDetail
|
Hata ayrıntısı.
|
|
ErrorResponse
|
Hata yanıtı
|
|
ParameterApplyMethod
|
Dinamik parametre değişiklikleri etkin hale geldiğinde kontroller. Statik parametre değişiklikleri her zaman yalnızca müşteri tarafından başlatılan bir havuz Yeniden başlatmadan sonra etkili olur. Stop ve ardından Start ile planlı bakım bekleyen parametre değişikliklerini uygulamaz.
|
|
ParameterGroupSyncStatus
|
HorizonDB kaynağı ile parametre grubu arasındaki senkronizasyon durumunu gösterir.
|
|
Pool
|
HorizonDB havuzunu temsil eder.
|
|
PoolComputeModel
|
HorizonDB havuzu için hesaplama modeli.
|
|
PoolComputeModelForPatchUpdate
|
Güncellenebilen bir HorizonDB havuzunun hesaplama modeli özellikleri. Nesne özyinelemeli olarak birleştirilebilir: atlanan özellikler mevcut değerlerini korur. Mevcut veya hedef hesaplama modeli tipine uygulanmayan özellikler reddedilir. Tür değiştiğinde, istek tam hedef hesaplama modelini içermelidir. Alt tipe özgü kısıtlamalar, etkili birleştirilmiş yapılandırmaya karşı doğrulanır; geçersiz talepler kaynak değiştirilmeden reddedilir.
|
|
PoolComputeModelType
|
Hesaplama model türü.
|
|
PoolForPatchUpdate
|
Güncelleme işlemleri için HorizonDB havuzu.
|
|
PoolHighAvailability
|
HorizonDB havuzu için yüksek kullanılabilirlik yapılandırması.
|
|
PoolHighAvailabilityMode
|
Yüksek kullanılabilirlik modu HorizonDB havuzu için talep edildi.
|
|
PoolHighAvailabilityPatch
|
HorizonDB havuz güncellemesi için yüksek kullanılabilirlik yapılandırması.
|
|
PoolParameterGroupReference
|
HorizonDB havuzuyla ilişkili parametre grubuna bir referans. Şema, oluşturma ve güncelleme uyumluluğu için hem varsayılan hem de müşteri tarafından oluşturulan parametre gruplarını temsil eder. Bu API sürümünde, ilk havuz oluşturma yalnızca ilgili varsayılan parametre grubunu kabul eder; Mevcut bir havuza yapılan PUT güncellemeleri her iki grup tipini de ilişkilendirebilir.
|
|
PoolParameterGroupReferenceForPatchUpdate
|
Mevcut bir HorizonDB havuzunu güncellemek için bir parametre grup referansı. Havuz, karşılık gelen varsayılan parametre grubu ile müşteri tarafından oluşturulan parametre grubu arasında her iki yönde geçiş yapabilir.
|
|
PoolProperties
|
HorizonDB havuzunun özellikleri.
|
|
PoolPropertiesForPatchUpdate
|
Güncelleme işlemleri için HorizonDB havuzunun özellikleri.
|
|
PoolState
|
HorizonDB havuzunun mevcut durumu.
|
|
ProvisioningState
|
Sağlama durumu.
|
|
ScheduledMaintenanceManagementType
|
HorizonDB havuzu için planlı bakımı kimin yöneteceğini belirtir.
|
|
ScheduledMaintenancePropertiesForPatchUpdate
|
Havuz güncelleme operasyonu için planlı bakım yapılandırması.
|
|
systemData
|
Kaynağın oluşturulması ve son değiştirilmesiyle ilgili meta veriler.
|
|
SystemScheduledMaintenanceProperties
|
HorizonDB havuzu için sistem tarafından yönetilen planlı bakım yapılandırması. Kullanıcı tarafından yönetilen zamanlama özellikleri yok olmalıdır.
|
ComputeProcessorType
Numaralandırma
Hesaplama işlemci türü.
| Değer |
Description |
|
Intel
|
Intel işlemci
|
|
AMD
|
AMD işlemci
|
createdByType
Numaralandırma
Kaynağı oluşturan kimliğin türü.
| Değer |
Description |
|
User
|
|
|
Application
|
|
|
ManagedIdentity
|
|
|
Key
|
|
ErrorAdditionalInfo
Nesne
Kaynak yönetimi hatasına ilişkin ek bilgiler.
| Veri Akışı Adı |
Tür |
Description |
|
info
|
object
|
Ek bilgiler.
|
|
type
|
string
|
Ek bilgi türü.
|
ErrorDetail
Nesne
Hata ayrıntısı.
| Veri Akışı Adı |
Tür |
Description |
|
additionalInfo
|
ErrorAdditionalInfo[]
|
Hata ek bilgisi.
|
|
code
|
string
|
Hata kodu.
|
|
details
|
ErrorDetail[]
|
Hata ayrıntıları.
|
|
message
|
string
|
Hata iletisi.
|
|
target
|
string
|
Hata hedefi
|
ErrorResponse
Nesne
Hata yanıtı
| Veri Akışı Adı |
Tür |
Description |
|
error
|
ErrorDetail
|
Hata nesnesi.
|
ParameterApplyMethod
Numaralandırma
Dinamik parametre değişiklikleri etkin hale geldiğinde kontroller. Statik parametre değişiklikleri her zaman yalnızca müşteri tarafından başlatılan bir havuz Yeniden başlatmadan sonra etkili olur. Stop ve ardından Start ile planlı bakım bekleyen parametre değişikliklerini uygulamaz.
| Değer |
Description |
|
Immediate
|
Dinamik parametre değişikliklerini hemen uygulayın. Statik parametre değişiklikleri, müşteri tarafından başlatılan bir havuz Yeniden Başlatılana kadar beklemektedir.
|
|
PendingReboot
|
Dinamik ve statik parametre değişikliklerini, müşteri tarafından başlatılan bir havuz Yeniden Başlatılana kadar beklet. Stop ve ardından Start ile planlı bakım uygulamayın.
|
ParameterGroupSyncStatus
Numaralandırma
HorizonDB kaynağı ile parametre grubu arasındaki senkronizasyon durumunu gösterir.
| Değer |
Description |
|
Applying
|
Parametre güncellemeleri şu anda uygulanmaktadır.
|
|
InSync
|
Parametre değerleri senkronize edilmiş ve günceldir.
|
|
FailedToApply
|
Parametre güncellemeleri uygulamak başarısız oldu.
|
|
PendingReboot
|
Parametre güncellemeleri beklemekte ve etki altına almak için müşteri tarafından başlatılan bir havuz Restart gerektiriyor. Stop ve ardından Start ve planlı bakım bu durumu koruyor.
|
Pool
Nesne
HorizonDB havuzunu temsil eder.
| Veri Akışı Adı |
Tür |
Description |
|
id
|
string
(arm-id)
|
Kaynağın tam nitelikli kaynak kimliği. Örneğin "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
|
|
name
|
string
|
Kaynağın adı
|
|
properties
|
PoolProperties
|
Bu kaynağın kaynağa özgü özellikleri.
|
|
systemData
|
systemData
|
createdBy ve modifiedBy bilgilerini içeren Azure Resource Manager meta verileri.
|
|
tags
|
object
|
Kaynak etiketleri.
|
|
type
|
string
|
Kaynağın türü. Örneğin, "Microsoft.Compute/virtualMachines" veya "Microsoft.Storage/storageAccounts"
|
PoolComputeModel
Nesne
HorizonDB havuzu için hesaplama modeli.
| Veri Akışı Adı |
Tür |
Description |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
Hesaplama modeli için hesaplama üretimi.
|
|
computeProcessor
|
ComputeProcessorType
|
Hesaplama modeli için işlemci tipi.
|
|
type
|
PoolComputeModelType
|
Hesaplama modelinin türü.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
Sanal çekirdek sayısı. İzin verilen değerler 1'den 192'ye kadardır.
|
PoolComputeModelForPatchUpdate
Nesne
Güncellenebilen bir HorizonDB havuzunun hesaplama modeli özellikleri. Nesne özyinelemeli olarak birleştirilebilir: atlanan özellikler mevcut değerlerini korur. Mevcut veya hedef hesaplama modeli tipine uygulanmayan özellikler reddedilir. Tür değiştiğinde, istek tam hedef hesaplama modelini içermelidir. Alt tipe özgü kısıtlamalar, etkili birleştirilmiş yapılandırmaya karşı doğrulanır; geçersiz talepler kaynak değiştirilmeden reddedilir.
| Veri Akışı Adı |
Tür |
Description |
|
computeGeneration
|
integer
(int32)
minimum: 1
|
Hesaplama modeli için hesaplama üretimi. Atlama, mevcut hesaplama üretimini korur.
|
|
computeProcessor
|
ComputeProcessorType
|
Hesaplama modeli için işlemci tipi. Eksiklik, mevcut işlemci tipini korur.
|
|
type
|
PoolComputeModelType
|
Hesaplama model türü. Bu özelliği çıkararak mevcut tipi koruyun. Mevcut tipin yeniden gönderilmesi bir idempotent no-opolarak başarılı olur. Tipi değiştirmek için, hedef tipin gerektirdiği tüm ortak özellikleri ve tüm özellikleri sağlayın.
|
|
vCores
|
integer
(int32)
minimum: 2 maximum: 192
|
Sağlanan vCore sayısı. İzin verilen değerler 1'den 192'ye kadardır. Bu özellik yalnızca Provisioned hesaplama modeli için geçerlidir. Eksiklik mevcut değeri korur.
|
PoolComputeModelType
Numaralandırma
Hesaplama model türü.
| Değer |
Description |
|
Provisioned
|
Provisioned compute model
|
PoolForPatchUpdate
Nesne
Güncelleme işlemleri için HorizonDB havuzu.
| Veri Akışı Adı |
Tür |
Description |
|
properties
|
PoolPropertiesForPatchUpdate
|
HorizonDB havuzu için güncellenebilecek özellikler.
|
|
tags
|
object
|
Kaynak etiketleri.
|
PoolHighAvailability
Nesne
HorizonDB havuzu için yüksek kullanılabilirlik yapılandırması.
| Veri Akışı Adı |
Tür |
Description |
|
mode
|
PoolHighAvailabilityMode
|
Yüksek erişilebilirlik modu. NodeCount 1 olduğunda devre dışı bırakılması zorunludur. NodeCount 2'den 16'ya kadar olduğunda AnyZone veya ZoneRedundant gereklidir.
|
PoolHighAvailabilityMode
Numaralandırma
Yüksek kullanılabilirlik modu HorizonDB havuzu için talep edildi.
| Değer |
Description |
|
Disabled
|
Yüksek erişilebilirlik devre dışı bırakılıyor. Bu mod yalnızca nodeCount 1 olduğunda geçerlidir.
|
|
AnyZone
|
Hizmet, aynı erişilebilirlik bölgesinde veya erişilebilirlik bölgeleri arasında düğümler tahsis edebilir. Bu mod yalnızca nodeCount 2'den 16'ya kadar olduğunda geçerlidir.
|
|
ZoneRedundant
|
Hizmet, erişim bölgeleri arasında düğümleri tahsis etmelidir. Bu mod yalnızca nodeCount 2'den 16'ya kadar olduğunda geçerlidir.
|
PoolHighAvailabilityPatch
Nesne
HorizonDB havuz güncellemesi için yüksek kullanılabilirlik yapılandırması.
| Veri Akışı Adı |
Tür |
Description |
|
mode
|
PoolHighAvailabilityMode
|
Yüksek erişilebilirlik modu. Atlama, hizmet etkili nodeCount ile doğrulamadan önce mevcut modu korur.
|
PoolParameterGroupReference
Nesne
HorizonDB havuzuyla ilişkili parametre grubuna bir referans. Şema, oluşturma ve güncelleme uyumluluğu için hem varsayılan hem de müşteri tarafından oluşturulan parametre gruplarını temsil eder. Bu API sürümünde, ilk havuz oluşturma yalnızca ilgili varsayılan parametre grubunu kabul eder; Mevcut bir havuza yapılan PUT güncellemeleri her iki grup tipini de ilişkilendirebilir.
| Veri Akışı Adı |
Tür |
Description |
|
applyMethod
|
ParameterApplyMethod
|
İlgili parametre grubundan dinamik parametre değişikliklerinin ne zaman etkili hale geldiğini belirler. Statik parametre değişiklikleri, bu değerden bağımsız olarak, her zaman müşteri tarafından başlatılan bir havuz Yeniden başlatma gerektirir. Stop ve ardından Start ile planlı bakım bekleyen parametre değişikliklerini uygulamaz.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
İlgili parametre grubunun Azure kaynak kimliği. Bu API sürümünde ilk havuz oluşturma için ilgili Microsoft. HorizonDb/locations/parameterGroups kaynağı gereklidir. Mevcut bir havuz için, PUT ya ilgili varsayılan grubu ya da müşteri tarafından oluşturulan bir Microsoft'u belirtebilir. HorizonDb/parameterGroups kaynağı.
|
|
syncStatus
|
ParameterGroupSyncStatus
|
Havuz ile parametre grubu arasındaki senkronizasyon durumu. Bekleyen Reboot değişiklikleri, Stop, Start ve planlı bakım süreçlerinde beklemeye devam ediyor ve ancak müşteri tarafından başlatılan bir Yeniden Başlatma işlemi sonrası geçerli hale geliyor.
|
PoolParameterGroupReferenceForPatchUpdate
Nesne
Mevcut bir HorizonDB havuzunu güncellemek için bir parametre grup referansı. Havuz, karşılık gelen varsayılan parametre grubu ile müşteri tarafından oluşturulan parametre grubu arasında her iki yönde geçiş yapabilir.
| Veri Akışı Adı |
Tür |
Description |
|
applyMethod
|
ParameterApplyMethod
|
İlgili parametre grubundan dinamik parametre değişikliklerinin ne zaman etkili hale geldiğini belirler. Statik parametre değişiklikleri, bu değerden bağımsız olarak, her zaman müşteri tarafından başlatılan bir havuz Yeniden başlatma gerektirir. Stop ve ardından Start ile planlı bakım bekleyen parametre değişikliklerini uygulamaz.
|
|
parameterGroupResourceId
|
string
(arm-id)
|
Mevcut havuzla ilişkilendirilmek için karşılık gelen varsayılan veya müşteri tarafından oluşturulan parametre grubunun Azure kaynak kimliği.
|
PoolProperties
Nesne
HorizonDB havuzunun özellikleri.
| Veri Akışı Adı |
Tür |
Description |
|
computeModel
|
PoolComputeModel
|
HorizonDB havuzu için gerekli hesaplama modeli.
|
|
highAvailability
|
PoolHighAvailability
|
Havuz için gerekli yüksek erişilebilirlik konfigürasyonu. mod nodeCount 1 olduğunda devre dışı bırakılmalı ve nodeCount 2'den 16'ya kadar olduğunda AnyZone veya ZoneRedundant olmalıdır.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
Havuza tahsis edilecek ve atanan gereken düğüm sayısı. İzin verilen değerler 1'den 16'ya kadardır. Yapılandırılmış düğüm sayısını değiştirmeden çalışma zamanında hesaplamayı dağıtmak için havuzu durdurun.
|
|
parameterGroup
|
PoolParameterGroupReference
|
Havuzla ilişkilendirilen gerekli parametre grubu. Bu API sürümünde yeni bir havuz oluşturulurken, arayan ilgili varsayılan parametre grubunu sağlamalıdır; müşteri tarafından oluşturulan parametre grupları oluşturulma sırasında kabul edilmez. Mevcut bir havuz için, PUT veya PATCH ya ilgili varsayılan parametre grubunu ya da müşteri tarafından oluşturulan bir parametre grubunu ilişkilendirebilir. Görünür yaratma şekli, her iki kaynak kimliği formunu da kasıtlı olarak destekler; böylece gelecekteki API sürümü, müşteri tarafından oluşturulan parametre gruplarına izin vererek oluşturulma sırasında bozuk bir şema değişikliği olmadan izin verebilir.
|
|
provisioningState
|
ProvisioningState
|
Havuzun tedarik durumu.
|
|
scheduledMaintenance
|
ScheduledMaintenanceProperties:
SystemScheduledMaintenanceProperties
|
Havuz için planlı bakım konfigürasyonu. Mevcut özellikler, seçilen bakım yönetimi türüne bağlıdır.
|
|
state
|
PoolState
|
Havuzun mevcut durumu.
|
PoolPropertiesForPatchUpdate
Nesne
Güncelleme işlemleri için HorizonDB havuzunun özellikleri.
| Veri Akışı Adı |
Tür |
Description |
|
computeModel
|
PoolComputeModelForPatchUpdate
|
Hesaplama modeli özellikleri güncellenecek. Atlanan özellikler mevcut değerlerini korur. Hesaplama modeli tipini değiştirmek için, tip, hesaplama işlemcisi, hesaplama üretimi ve hedef tipin gerektirdiği tüm özellikleri içeren tam hedef hesaplama modelini sağlayın.
|
|
highAvailability
|
PoolHighAvailabilityPatch
|
Yüksek erişilebilirlik yapılandırması güncelleniyor. Atlama, mevcut modu korur. Hizmet, etkin nodeCount ve modu birlikte doğrulamadan önce atlanan PATCH özelliklerini mevcut kaynakla özyinelemeli olarak birleştirir.
|
|
nodeCount
|
integer
(int32)
minimum: 1 maximum: 16
|
Havuza tahsis edilecek ve atanan düğüm sayısı. İzin verilen değerler 1'den 16'ya kadardır. Atlama, mevcut yapılandırılmış değeri korur. Yapılandırılmış düğüm sayısını değiştirmeden çalışma zamanında hesaplamayı dağıtmak için havuzu durdurun.
|
|
parameterGroup
|
PoolParameterGroupReferenceForPatchUpdate
|
Mevcut havuzla ilişkilendirilecek varsayılan veya müşteri tarafından oluşturulan parametre grubu. Müşteriler bu grup türleri arasında her iki yönde geçiş yapabilir. Eksiklik, mevcut ilişkiyi korur.
|
|
scheduledMaintenance
|
ScheduledMaintenancePropertiesForPatchUpdate
|
Havuz için güncellenecek planlı bakım konfigürasyonu. Sunulduğunda, seçilen bakım yönetim tipi için tam yapılandırma gereklidir. Eksiklik mevcut konfigürasyonu korur.
|
PoolState
Numaralandırma
HorizonDB havuzunun mevcut durumu.
| Değer |
Description |
|
Ready
|
Hazır ve çalışır durumda
|
|
Provisioning
|
Sağlama
|
|
Deleting
|
Siliyor
|
|
Inaccessible
|
Erişilemez
|
|
Updating
|
Güncelleniyor
|
|
Starting
|
Başlıyor
|
|
Restarting
|
Yeniden başlatıyor
|
|
Stopping
|
Duruyor
|
|
Stopped
|
Durduruldu
|
ProvisioningState
Numaralandırma
Sağlama durumu.
| Değer |
Description |
|
Succeeded
|
Kaynak oluşturuldu.
|
|
Failed
|
Kaynak oluşturma başarısız oldu.
|
|
Canceled
|
Kaynak oluşturma işlemi iptal edildi.
|
|
InProgress
|
HorizonDB kaynak operasyonu aktif olarak çalışıyor.
|
|
Provisioning
|
HorizonDB kaynağı hâlâ provisioning'de.
|
ScheduledMaintenanceManagementType
Numaralandırma
HorizonDB havuzu için planlı bakımı kimin yöneteceğini belirtir.
| Değer |
Description |
|
System
|
Planlı bakım sistem tarafından yönetilir.
|
ScheduledMaintenancePropertiesForPatchUpdate
Nesne
Havuz güncelleme operasyonu için planlı bakım yapılandırması.
| Veri Akışı Adı |
Tür |
Description |
|
maintenanceManagementType
|
ScheduledMaintenanceManagementType
|
Planlı bakımın sistem tarafından mı yoksa kullanıcı tarafından mı yönetildiğini belirtir. Planlı bakım sağlandığında, bu mülk hizmet tarafından gereklidir.
|
systemData
Nesne
Kaynağın oluşturulması ve son değiştirilmesiyle ilgili meta veriler.
| Veri Akışı Adı |
Tür |
Description |
|
createdAt
|
string
(date-time)
|
Kaynak oluşturmanın zaman damgası (UTC).
|
|
createdBy
|
string
|
Kaynağı oluşturan kimlik.
|
|
createdByType
|
createdByType
|
Kaynağı oluşturan kimliğin türü.
|
|
lastModifiedAt
|
string
(date-time)
|
Kaynağın son değişikliğinin zaman damgası (UTC)
|
|
lastModifiedBy
|
string
|
Kaynağı en son değiştiren kimlik.
|
|
lastModifiedByType
|
createdByType
|
Kaynağı en son değiştiren kimlik türü.
|
SystemScheduledMaintenanceProperties
Nesne
HorizonDB havuzu için sistem tarafından yönetilen planlı bakım yapılandırması. Kullanıcı tarafından yönetilen zamanlama özellikleri yok olmalıdır.
| Veri Akışı Adı |
Tür |
Description |
|
maintenanceManagementType
|
string:
System
|
Planlı bakımın sistem tarafından mı yoksa kullanıcı tarafından mı yönetildiğini belirtir.
|