Databases - Update

Servizio:

Redis Cache

Versione API:

2025-07-01

Aggiorna un database

PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}?api-version=2025-07-01

Parametri dell'URI

Nome	In	Necessario	Tipo	Descrizione
clusterName	path	True	string pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$	Nome del cluster Redis Enterprise. Il nome deve avere una lunghezza di 1-60 caratteri. Caratteri consentiti (A-Z, a-z, 0-9) e trattino (-). Non ci possono essere trattini iniziali né finali né consecutivi
databaseName	path	True	string pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$	Nome del database Redis Enterprise.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Nome del gruppo di risorse. Il nome è insensibile alle maiuscole e minuscole.
subscriptionId	path	True	string minLength: 1	ID della sottoscrizione di destinazione.
api-version	query	True	string minLength: 1	Versione dell'API da usare per questa operazione.

Corpo della richiesta

Nome	Tipo	Descrizione
properties.accessKeysAuthentication	accessKeysAuthentication	Questa proprietà può essere abilitata/disabilitata per consentire o negare l'accesso con le chiavi di accesso correnti. Può essere aggiornato anche dopo la creazione del database. Il valore predefinito è Disabled.
properties.clientProtocol	Protocol	Specifica se i client Redis possono connettersi usando protocolli redis crittografati o in testo non crittografato. Il valore predefinito è TLS-encrypted.
properties.clusteringPolicy	ClusteringPolicy	Criteri di clustering: l'impostazione predefinita è OSSCluster. Questa proprietà può essere aggiornata solo se il valore corrente è NoCluster. Se il valore è OSSCluster o EnterpriseCluster, non può essere aggiornato senza eliminare il database.
properties.deferUpgrade	DeferUpgradeSetting	Opzione per rinviare l'aggiornamento quando viene rilasciata la versione più recente. Il valore predefinito è NotDeferred. Ulteriori informazioni: https://aka.ms/redisversionupgrade
properties.evictionPolicy	EvictionPolicy	Criterio di rimozione redis: il valore predefinito è VolatileLRU
properties.geoReplication	GeoReplication	Set facoltativo di proprietà per configurare la replica geografica per questo database.
properties.modules	Module[]	Set facoltativo di moduli Redis da abilitare in questo database: i moduli possono essere aggiunti solo in fase di creazione.
properties.persistence	Persistence	Impostazioni di persistenza Impostazioni di persistenza
properties.port	integer (int32)	Porta TCP dell'endpoint del database. Specificato in fase di creazione. Il valore predefinito è una porta disponibile.

Risposte

Nome	Tipo	Descrizione
200 OK	Database	Il database è stato/è in fase di aggiornamento. Controllare provisioningState e resourceState per lo stato dettagliato.
202 Accepted		L'operazione di aggiornamento del database è stata avviata correttamente. GET l'URL nelle intestazioni Azure-AsyncOperation o Location per recuperare lo stato aggiornato. Intestazioni Location: string Azure-AsyncOperation: string
Other Status Codes	ErrorResponse	Risposta di errore che descrive il motivo per cui l'operazione non è riuscita.

Sicurezza

azure_auth

Flusso OAuth2 di Azure Active Directory.

Tipo: oauth2
Flow: implicit
URL di autorizzazione: https://login.microsoftonline.com/common/oauth2/authorize

Ambiti

Nome	Descrizione
user_impersonation	rappresentare l'account utente

Esempio

RedisEnterpriseDatabasesUpdate

RedisEnterpriseDatabasesUpdate Clustering on No Cluster Cache

RedisEnterpriseDatabasesUpdate

Esempio di richiesta

HTTP

PATCH https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default?api-version=2025-07-01

{
  "properties": {
    "clientProtocol": "Encrypted",
    "evictionPolicy": "AllKeysLRU",
    "persistence": {
      "rdbEnabled": true,
      "rdbFrequency": "12h"
    },
    "accessKeysAuthentication": "Enabled"
  }
}

Java

import com.azure.resourcemanager.redisenterprise.models.AccessKeysAuthentication;
import com.azure.resourcemanager.redisenterprise.models.Database;
import com.azure.resourcemanager.redisenterprise.models.EvictionPolicy;
import com.azure.resourcemanager.redisenterprise.models.Persistence;
import com.azure.resourcemanager.redisenterprise.models.Protocol;
import com.azure.resourcemanager.redisenterprise.models.RdbFrequency;

/**
 * Samples for Databases Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
     * RedisEnterpriseDatabasesUpdate.json
     */
    /**
     * Sample code: RedisEnterpriseDatabasesUpdate.
     * 
     * @param manager Entry point to RedisEnterpriseManager.
     */
    public static void
        redisEnterpriseDatabasesUpdate(com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
        Database resource = manager.databases()
            .getWithResponse("rg1", "cache1", "default", com.azure.core.util.Context.NONE).getValue();
        resource.update().withClientProtocol(Protocol.ENCRYPTED).withEvictionPolicy(EvictionPolicy.ALL_KEYS_LRU)
            .withPersistence(new Persistence().withRdbEnabled(true).withRdbFrequency(RdbFrequency.ONE_TWOH))
            .withAccessKeysAuthentication(AccessKeysAuthentication.ENABLED).apply();
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.redisenterprise import RedisEnterpriseManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-redisenterprise
# USAGE
    python redis_enterprise_databases_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 = RedisEnterpriseManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f",
    )

    response = client.databases.begin_update(
        resource_group_name="rg1",
        cluster_name="cache1",
        database_name="default",
        parameters={
            "properties": {
                "accessKeysAuthentication": "Enabled",
                "clientProtocol": "Encrypted",
                "evictionPolicy": "AllKeysLRU",
                "persistence": {"rdbEnabled": True, "rdbFrequency": "12h"},
            }
        },
    ).result()
    print(response)


# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesUpdate.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

Go

package armredisenterprise_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/redisenterprise/armredisenterprise/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/3855ffb4be0cd4d227b130b67d874fa816736c04/specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesUpdate.json
func ExampleDatabasesClient_BeginUpdate_redisEnterpriseDatabasesUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredisenterprise.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatabasesClient().BeginUpdate(ctx, "rg1", "cache1", "default", armredisenterprise.DatabaseUpdate{
		Properties: &armredisenterprise.DatabaseUpdateProperties{
			AccessKeysAuthentication: to.Ptr(armredisenterprise.AccessKeysAuthenticationEnabled),
			ClientProtocol:           to.Ptr(armredisenterprise.ProtocolEncrypted),
			EvictionPolicy:           to.Ptr(armredisenterprise.EvictionPolicyAllKeysLRU),
			Persistence: &armredisenterprise.Persistence{
				RdbEnabled:   to.Ptr(true),
				RdbFrequency: to.Ptr(armredisenterprise.RdbFrequencyTwelveH),
			},
		},
	}, 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 pull 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.Database = armredisenterprise.Database{
	// 	Name: to.Ptr("cache1/default"),
	// 	Type: to.Ptr("Microsoft.Cache/redisEnterprise/databases"),
	// 	ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
	// 	Properties: &armredisenterprise.DatabaseCreateProperties{
	// 		AccessKeysAuthentication: to.Ptr(armredisenterprise.AccessKeysAuthenticationEnabled),
	// 		ClientProtocol: to.Ptr(armredisenterprise.ProtocolEncrypted),
	// 		ClusteringPolicy: to.Ptr(armredisenterprise.ClusteringPolicyOSSCluster),
	// 		DeferUpgrade: to.Ptr(armredisenterprise.DeferUpgradeSettingNotDeferred),
	// 		EvictionPolicy: to.Ptr(armredisenterprise.EvictionPolicyAllKeysLRU),
	// 		Modules: []*armredisenterprise.Module{
	// 			{
	// 				Name: to.Ptr("RediSearch"),
	// 				Args: to.Ptr(""),
	// 				Version: to.Ptr("1.0.0"),
	// 		}},
	// 		Persistence: &armredisenterprise.Persistence{
	// 			RdbEnabled: to.Ptr(true),
	// 			RdbFrequency: to.Ptr(armredisenterprise.RdbFrequencyTwelveH),
	// 		},
	// 		Port: to.Ptr[int32](10000),
	// 		ProvisioningState: to.Ptr(armredisenterprise.ProvisioningStateSucceeded),
	// 		RedisVersion: to.Ptr("6.0"),
	// 		ResourceState: to.Ptr(armredisenterprise.ResourceStateUpdating),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RedisEnterpriseManagementClient } = require("@azure/arm-redisenterprisecache");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates a database
 *
 * @summary Updates a database
 * x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesUpdate.json
 */
async function redisEnterpriseDatabasesUpdate() {
  const subscriptionId =
    process.env["REDISENTERPRISE_SUBSCRIPTION_ID"] || "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
  const resourceGroupName = process.env["REDISENTERPRISE_RESOURCE_GROUP"] || "rg1";
  const clusterName = "cache1";
  const databaseName = "default";
  const parameters = {
    accessKeysAuthentication: "Enabled",
    clientProtocol: "Encrypted",
    evictionPolicy: "AllKeysLRU",
    persistence: { rdbEnabled: true, rdbFrequency: "12h" },
  };
  const credential = new DefaultAzureCredential();
  const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
  const result = await client.databases.beginUpdateAndWait(
    resourceGroupName,
    clusterName,
    databaseName,
    parameters,
  );
  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

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.RedisEnterprise.Models;
using Azure.ResourceManager.RedisEnterprise;

// Generated from example definition: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesUpdate.json
// this example is just showing the usage of "Databases_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this RedisEnterpriseDatabaseResource created on azure
// for more information of creating RedisEnterpriseDatabaseResource, please refer to the document of RedisEnterpriseDatabaseResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
string clusterName = "cache1";
string databaseName = "default";
ResourceIdentifier redisEnterpriseDatabaseResourceId = RedisEnterpriseDatabaseResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, clusterName, databaseName);
RedisEnterpriseDatabaseResource redisEnterpriseDatabase = client.GetRedisEnterpriseDatabaseResource(redisEnterpriseDatabaseResourceId);

// invoke the operation
RedisEnterpriseDatabasePatch patch = new RedisEnterpriseDatabasePatch
{
    ClientProtocol = RedisEnterpriseClientProtocol.Encrypted,
    EvictionPolicy = RedisEnterpriseEvictionPolicy.AllKeysLru,
    Persistence = new RedisPersistenceSettings
    {
        IsRdbEnabled = true,
        RdbFrequency = PersistenceSettingRdbFrequency.TwelveHours,
    },
    AccessKeysAuthentication = AccessKeysAuthentication.Enabled,
};
ArmOperation<RedisEnterpriseDatabaseResource> lro = await redisEnterpriseDatabase.UpdateAsync(WaitUntil.Completed, patch);
RedisEnterpriseDatabaseResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RedisEnterpriseDatabaseData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Risposta di esempio

Codice di stato:

200

{
  "id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
  "name": "cache1/default",
  "type": "Microsoft.Cache/redisEnterprise/databases",
  "properties": {
    "provisioningState": "Updating",
    "resourceState": "Updating",
    "clientProtocol": "Encrypted",
    "clusteringPolicy": "OSSCluster",
    "evictionPolicy": "AllKeysLRU",
    "persistence": {
      "rdbEnabled": true,
      "rdbFrequency": "12h"
    },
    "port": 10000,
    "modules": [
      {
        "name": "RediSearch",
        "args": "",
        "version": "1.0.0"
      }
    ],
    "deferUpgrade": "NotDeferred",
    "accessKeysAuthentication": "Enabled",
    "redisVersion": "6.0"
  }
}

Codice di stato:

202

Azure-AsyncOperation: https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/providers/Microsoft.Cache/...pathToOperationStatus...
Location: https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/providers/Microsoft.Cache/...pathToOperationResult...

RedisEnterpriseDatabasesUpdate Clustering on No Cluster Cache

Esempio di richiesta

HTTP

PATCH https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default?api-version=2025-07-01

{
  "properties": {
    "clientProtocol": "Encrypted",
    "clusteringPolicy": "EnterpriseCluster",
    "evictionPolicy": "NoEviction",
    "port": 10000
  }
}

Java

import com.azure.resourcemanager.redisenterprise.models.ClusteringPolicy;
import com.azure.resourcemanager.redisenterprise.models.Database;
import com.azure.resourcemanager.redisenterprise.models.EvictionPolicy;
import com.azure.resourcemanager.redisenterprise.models.Protocol;

/**
 * Samples for Databases Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
     * RedisEnterpriseDatabasesNoClusterCacheUpdateClustering.json
     */
    /**
     * Sample code: RedisEnterpriseDatabasesUpdate Clustering on No Cluster Cache.
     * 
     * @param manager Entry point to RedisEnterpriseManager.
     */
    public static void redisEnterpriseDatabasesUpdateClusteringOnNoClusterCache(
        com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
        Database resource = manager.databases()
            .getWithResponse("rg1", "cache1", "default", com.azure.core.util.Context.NONE).getValue();
        resource.update().withClientProtocol(Protocol.ENCRYPTED)
            .withClusteringPolicy(ClusteringPolicy.ENTERPRISE_CLUSTER).withEvictionPolicy(EvictionPolicy.NO_EVICTION)
            .apply();
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.redisenterprise import RedisEnterpriseManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-redisenterprise
# USAGE
    python redis_enterprise_databases_no_cluster_cache_update_clustering.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 = RedisEnterpriseManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f",
    )

    response = client.databases.begin_update(
        resource_group_name="rg1",
        cluster_name="cache1",
        database_name="default",
        parameters={
            "properties": {
                "clientProtocol": "Encrypted",
                "clusteringPolicy": "EnterpriseCluster",
                "evictionPolicy": "NoEviction",
                "port": 10000,
            }
        },
    ).result()
    print(response)


# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheUpdateClustering.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

Go

package armredisenterprise_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/redisenterprise/armredisenterprise/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/3855ffb4be0cd4d227b130b67d874fa816736c04/specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheUpdateClustering.json
func ExampleDatabasesClient_BeginUpdate_redisEnterpriseDatabasesUpdateClusteringOnNoClusterCache() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredisenterprise.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatabasesClient().BeginUpdate(ctx, "rg1", "cache1", "default", armredisenterprise.DatabaseUpdate{
		Properties: &armredisenterprise.DatabaseUpdateProperties{
			ClientProtocol:   to.Ptr(armredisenterprise.ProtocolEncrypted),
			ClusteringPolicy: to.Ptr(armredisenterprise.ClusteringPolicyEnterpriseCluster),
			EvictionPolicy:   to.Ptr(armredisenterprise.EvictionPolicyNoEviction),
			Port:             to.Ptr[int32](10000),
		},
	}, 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 pull 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.Database = armredisenterprise.Database{
	// 	Name: to.Ptr("cache1/default"),
	// 	Type: to.Ptr("Microsoft.Cache/redisEnterprise/databases"),
	// 	ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
	// 	Properties: &armredisenterprise.DatabaseCreateProperties{
	// 		AccessKeysAuthentication: to.Ptr(armredisenterprise.AccessKeysAuthenticationEnabled),
	// 		ClientProtocol: to.Ptr(armredisenterprise.ProtocolEncrypted),
	// 		ClusteringPolicy: to.Ptr(armredisenterprise.ClusteringPolicyEnterpriseCluster),
	// 		DeferUpgrade: to.Ptr(armredisenterprise.DeferUpgradeSettingNotDeferred),
	// 		EvictionPolicy: to.Ptr(armredisenterprise.EvictionPolicyNoEviction),
	// 		Port: to.Ptr[int32](10000),
	// 		ProvisioningState: to.Ptr(armredisenterprise.ProvisioningStateSucceeded),
	// 		RedisVersion: to.Ptr("7.2"),
	// 		ResourceState: to.Ptr(armredisenterprise.ResourceStateUpdating),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RedisEnterpriseManagementClient } = require("@azure/arm-redisenterprisecache");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates a database
 *
 * @summary Updates a database
 * x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheUpdateClustering.json
 */
async function redisEnterpriseDatabasesUpdateClusteringOnNoClusterCache() {
  const subscriptionId =
    process.env["REDISENTERPRISE_SUBSCRIPTION_ID"] || "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
  const resourceGroupName = process.env["REDISENTERPRISE_RESOURCE_GROUP"] || "rg1";
  const clusterName = "cache1";
  const databaseName = "default";
  const parameters = {
    clientProtocol: "Encrypted",
    clusteringPolicy: "EnterpriseCluster",
    evictionPolicy: "NoEviction",
    port: 10000,
  };
  const credential = new DefaultAzureCredential();
  const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
  const result = await client.databases.beginUpdateAndWait(
    resourceGroupName,
    clusterName,
    databaseName,
    parameters,
  );
  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

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.RedisEnterprise.Models;
using Azure.ResourceManager.RedisEnterprise;

// Generated from example definition: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheUpdateClustering.json
// this example is just showing the usage of "Databases_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this RedisEnterpriseDatabaseResource created on azure
// for more information of creating RedisEnterpriseDatabaseResource, please refer to the document of RedisEnterpriseDatabaseResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
string clusterName = "cache1";
string databaseName = "default";
ResourceIdentifier redisEnterpriseDatabaseResourceId = RedisEnterpriseDatabaseResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, clusterName, databaseName);
RedisEnterpriseDatabaseResource redisEnterpriseDatabase = client.GetRedisEnterpriseDatabaseResource(redisEnterpriseDatabaseResourceId);

// invoke the operation
RedisEnterpriseDatabasePatch patch = new RedisEnterpriseDatabasePatch
{
    ClientProtocol = RedisEnterpriseClientProtocol.Encrypted,
    Port = 10000,
    ClusteringPolicy = RedisEnterpriseClusteringPolicy.EnterpriseCluster,
    EvictionPolicy = RedisEnterpriseEvictionPolicy.NoEviction,
};
ArmOperation<RedisEnterpriseDatabaseResource> lro = await redisEnterpriseDatabase.UpdateAsync(WaitUntil.Completed, patch);
RedisEnterpriseDatabaseResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RedisEnterpriseDatabaseData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Risposta di esempio

Codice di stato:

200

{
  "id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
  "name": "cache1/default",
  "type": "Microsoft.Cache/redisEnterprise/databases",
  "properties": {
    "clientProtocol": "Encrypted",
    "port": 10000,
    "provisioningState": "Updating",
    "resourceState": "Updating",
    "clusteringPolicy": "EnterpriseCluster",
    "evictionPolicy": "NoEviction",
    "deferUpgrade": "NotDeferred",
    "redisVersion": "7.2",
    "accessKeysAuthentication": "Enabled"
  }
}

Codice di stato:

202

Azure-AsyncOperation: https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/providers/Microsoft.Cache/...pathToOperationStatus...
Location: https://management.azure.com/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/providers/Microsoft.Cache/...pathToOperationResult...

Definizioni

Nome	Descrizione
accessKeysAuthentication	Questa proprietà può essere abilitata/disabilitata per consentire o negare l'accesso con le chiavi di accesso correnti. Può essere aggiornato anche dopo la creazione del database. Il valore predefinito è Disabled.
AofFrequency	Imposta la frequenza con cui i dati vengono scritti su disco. Il valore predefinito è "1s", ovvero "ogni secondo". Si noti che l'impostazione 'always' è deprecata a causa dell'impatto sulle prestazioni.
ClusteringPolicy	Criteri di clustering: l'impostazione predefinita è OSSCluster. Questa proprietà può essere aggiornata solo se il valore corrente è NoCluster. Se il valore è OSSCluster o EnterpriseCluster, non può essere aggiornato senza eliminare il database.
Database	Viene descritto un database nel cluster Redis Enterprise
DatabaseUpdate	Un aggiornamento parziale del database Redis Enterprise
DeferUpgradeSetting	Opzione per rinviare l'aggiornamento quando viene rilasciata la versione più recente. Il valore predefinito è NotDeferred. Ulteriori informazioni: https://aka.ms/redisversionupgrade
ErrorAdditionalInfo	Informazioni aggiuntive sull'errore di gestione delle risorse.
ErrorDetail	Dettagli dell'errore.
ErrorResponse	Risposta di errore
EvictionPolicy	Criterio di rimozione redis: il valore predefinito è VolatileLRU
GeoReplication	Set facoltativo di proprietà per configurare la replica geografica per questo database.
LinkedDatabase	Database collegato
LinkState	Stato del collegamento tra le risorse del database.
Module	Impostazioni modulo
Persistence	Impostazioni di persistenza
Protocol	Specifica se i client Redis possono connettersi usando protocolli redis crittografati o in testo non crittografato. Il valore predefinito è TLS-encrypted.
ProvisioningState	Stato attuale del provisioning
RdbFrequency	Imposta la frequenza con cui viene creato uno snapshot del database.
ResourceState	Stato attuale delle risorse

accessKeysAuthentication

Enumerazione

Questa proprietà può essere abilitata/disabilitata per consentire o negare l'accesso con le chiavi di accesso correnti. Può essere aggiornato anche dopo la creazione del database. Il valore predefinito è Disabled.

Valore	Descrizione
Disabled
Enabled

AofFrequency

Enumerazione

Imposta la frequenza con cui i dati vengono scritti su disco. Il valore predefinito è "1s", ovvero "ogni secondo". Si noti che l'impostazione 'always' è deprecata a causa dell'impatto sulle prestazioni.

Valore	Descrizione
1s
always

ClusteringPolicy

Enumerazione

Criteri di clustering: l'impostazione predefinita è OSSCluster. Questa proprietà può essere aggiornata solo se il valore corrente è NoCluster. Se il valore è OSSCluster o EnterpriseCluster, non può essere aggiornato senza eliminare il database.

Valore	Descrizione
EnterpriseCluster	I criteri di clustering aziendale utilizzano solo il protocollo redis classico, che non supporta i comandi del cluster redis.
OSSCluster	I criteri di clustering OSS seguono la specifica del cluster redis e richiedono che tutti i client supportino il clustering redis.
NoCluster	Il criterio NoCluster viene utilizzato per le istanze Redis non cluster che non richiedono funzionalità di clustering.

Database

Oggetto

Viene descritto un database nel cluster Redis Enterprise

Nome	Tipo	Valore predefinito	Descrizione
id	string		ID risorsa completo per la risorsa. Ad esempio - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string		Nome della risorsa
properties.accessKeysAuthentication	accessKeysAuthentication	Disabled	Questa proprietà può essere abilitata/disabilitata per consentire o negare l'accesso con le chiavi di accesso correnti. Può essere aggiornato anche dopo la creazione del database. Il valore predefinito è Disabled.
properties.clientProtocol	Protocol		Specifica se i client Redis possono connettersi usando protocolli redis crittografati o in testo non crittografato. Il valore predefinito è TLS-encrypted.
properties.clusteringPolicy	ClusteringPolicy		Criteri di clustering: l'impostazione predefinita è OSSCluster. Questa proprietà può essere aggiornata solo se il valore corrente è NoCluster. Se il valore è OSSCluster o EnterpriseCluster, non può essere aggiornato senza eliminare il database.
properties.deferUpgrade	DeferUpgradeSetting		Opzione per rinviare l'aggiornamento quando viene rilasciata la versione più recente. Il valore predefinito è NotDeferred. Ulteriori informazioni: https://aka.ms/redisversionupgrade
properties.evictionPolicy	EvictionPolicy		Criterio di rimozione redis: il valore predefinito è VolatileLRU
properties.geoReplication	GeoReplication		Set facoltativo di proprietà per configurare la replica geografica per questo database.
properties.modules	Module[]		Set facoltativo di moduli Redis da abilitare in questo database: i moduli possono essere aggiunti solo in fase di creazione.
properties.persistence	Persistence		Impostazioni di persistenza Impostazioni di persistenza
properties.port	integer (int32)		Porta TCP dell'endpoint del database. Specificato in fase di creazione. Il valore predefinito è una porta disponibile.
properties.provisioningState	ProvisioningState		Stato corrente del provisioning del database
properties.redisVersion	string		Versione di Redis su cui è in esecuzione il database, ad esempio "6.0"
properties.resourceState	ResourceState		Stato corrente delle risorse del database
type	string		Tipo di risorsa. Ad esempio, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"

DatabaseUpdate

Oggetto

Un aggiornamento parziale del database Redis Enterprise

Nome	Tipo	Descrizione
properties.accessKeysAuthentication	accessKeysAuthentication	Questa proprietà può essere abilitata/disabilitata per consentire o negare l'accesso con le chiavi di accesso correnti. Può essere aggiornato anche dopo la creazione del database. Il valore predefinito è Disabled.
properties.clientProtocol	Protocol	Specifica se i client Redis possono connettersi usando protocolli redis crittografati o in testo non crittografato. Il valore predefinito è TLS-encrypted.
properties.clusteringPolicy	ClusteringPolicy	Criteri di clustering: l'impostazione predefinita è OSSCluster. Questa proprietà può essere aggiornata solo se il valore corrente è NoCluster. Se il valore è OSSCluster o EnterpriseCluster, non può essere aggiornato senza eliminare il database.
properties.deferUpgrade	DeferUpgradeSetting	Opzione per rinviare l'aggiornamento quando viene rilasciata la versione più recente. Il valore predefinito è NotDeferred. Ulteriori informazioni: https://aka.ms/redisversionupgrade
properties.evictionPolicy	EvictionPolicy	Criterio di rimozione redis: il valore predefinito è VolatileLRU
properties.geoReplication	GeoReplication	Set facoltativo di proprietà per configurare la replica geografica per questo database.
properties.modules	Module[]	Set facoltativo di moduli Redis da abilitare in questo database: i moduli possono essere aggiunti solo in fase di creazione.
properties.persistence	Persistence	Impostazioni di persistenza Impostazioni di persistenza
properties.port	integer (int32)	Porta TCP dell'endpoint del database. Specificato in fase di creazione. Il valore predefinito è una porta disponibile.
properties.provisioningState	ProvisioningState	Stato corrente del provisioning del database
properties.redisVersion	string	Versione di Redis su cui è in esecuzione il database, ad esempio "6.0"
properties.resourceState	ResourceState	Stato corrente delle risorse del database

DeferUpgradeSetting

Enumerazione

Opzione per rinviare l'aggiornamento quando viene rilasciata la versione più recente. Il valore predefinito è NotDeferred. Ulteriori informazioni: https://aka.ms/redisversionupgrade

Valore	Descrizione
Deferred
NotDeferred

ErrorAdditionalInfo

Oggetto

Informazioni aggiuntive sull'errore di gestione delle risorse.

Nome	Tipo	Descrizione
info	object	Informazioni aggiuntive.
type	string	Tipo di informazioni aggiuntive.

ErrorDetail

Oggetto

Dettagli dell'errore.

Nome	Tipo	Descrizione
additionalInfo	ErrorAdditionalInfo[]	Informazioni aggiuntive sull'errore.
code	string	Codice di errore.
details	ErrorDetail[]	Dettagli dell'errore.
message	string	Messaggio di errore.
target	string	Destinazione dell'errore.

ErrorResponse

Oggetto

Risposta di errore

Nome	Tipo	Descrizione
error	ErrorDetail	Oggetto error.

EvictionPolicy

Enumerazione

Criterio di rimozione redis: il valore predefinito è VolatileLRU

Valore	Descrizione
AllKeysLFU
AllKeysLRU
AllKeysRandom
VolatileLRU
VolatileLFU
VolatileTTL
VolatileRandom
NoEviction

GeoReplication

Oggetto

Set facoltativo di proprietà per configurare la replica geografica per questo database.

Nome	Tipo	Descrizione
groupNickname	string	Nome del gruppo di risorse del database collegato
linkedDatabases	LinkedDatabase[]	Elenco di risorse del database da collegare a questo database

LinkedDatabase

Oggetto

Database collegato

Nome	Tipo	Descrizione
id	string (arm-id)	ID risorsa di una risorsa di database da collegare al database.
state	LinkState	Stato del collegamento tra le risorse del database.

LinkState

Enumerazione

Stato del collegamento tra le risorse del database.

Valore	Descrizione
Linked
Linking
Unlinking
LinkFailed
UnlinkFailed

Module

Oggetto

Impostazioni modulo

Nome	Tipo	Descrizione
args	string	Opzioni di configurazione per il modulo, ad esempio 'ERROR_RATE 0.01 INITIAL_SIZE 400'.
name	string	Nome del modulo, ad esempio 'RedisBloom', 'RediSearch', 'RedisTimeSeries'
version	string	La versione del modulo, ad esempio '1.0'.

Persistence

Oggetto

Impostazioni di persistenza

Nome	Tipo	Descrizione
aofEnabled	boolean	Imposta un valore che indica se AOF è abilitato. Si noti che al massimo una di persistenza AOF o RDB può essere abilitata.
aofFrequency	AofFrequency	Imposta la frequenza con cui i dati vengono scritti su disco. Il valore predefinito è "1s", ovvero "ogni secondo". Si noti che l'impostazione 'always' è deprecata a causa dell'impatto sulle prestazioni.
rdbEnabled	boolean	Imposta un valore che indica se RDB è abilitato. Si noti che al massimo una di persistenza AOF o RDB può essere abilitata.
rdbFrequency	RdbFrequency	Imposta la frequenza con cui viene creato uno snapshot del database.

Protocol

Enumerazione

Specifica se i client Redis possono connettersi usando protocolli redis crittografati o in testo non crittografato. Il valore predefinito è TLS-encrypted.

Valore	Descrizione
Encrypted
Plaintext

ProvisioningState

Enumerazione

Stato attuale del provisioning

Valore	Descrizione
Succeeded
Failed
Canceled
Creating
Updating
Deleting

RdbFrequency

Enumerazione

Imposta la frequenza con cui viene creato uno snapshot del database.

Valore	Descrizione
1h
6h
12h

ResourceState

Enumerazione

Stato attuale delle risorse

Valore	Descrizione
Running
Creating
CreateFailed
Updating
UpdateFailed
Deleting
DeleteFailed
Enabling
EnableFailed
Disabling
DisableFailed
Disabled
Scaling
ScalingFailed
Moving