Crea una base de datos
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}?api-version=2025-07-01
Parámetros de identificador URI
| Nombre |
En |
Requerido |
Tipo |
Description |
|
clusterName
|
path |
True
|
string
pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$
|
Nombre del clúster de Redis Enterprise. El nombre debe tener entre 1 y 60 caracteres. Caracteres permitidos (A-Z, a-z, 0-9) y guion(-). No puede haber guiones iniciales ni finales ni consecutivos
|
|
databaseName
|
path |
True
|
string
pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$
|
Nombre de la base de datos de Redis Enterprise.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
Nombre del grupo de recursos. El nombre distingue mayúsculas de minúsculas.
|
|
subscriptionId
|
path |
True
|
string
minLength: 1
|
Identificador de la suscripción de destino.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
Versión de API que se usará para esta operación.
|
Cuerpo de la solicitud
| Nombre |
Tipo |
Description |
|
properties.accessKeysAuthentication
|
accessKeysAuthentication
|
Esta propiedad puede estar habilitada o deshabilitada para permitir o denegar el acceso con las claves de acceso actuales. Se puede actualizar incluso después de crear la base de datos. El valor predeterminado es Deshabilitado.
|
|
properties.clientProtocol
|
Protocol
|
Especifica si los clientes de Redis pueden conectarse mediante protocolos de redis cifrados mediante TLS o con texto no cifrado. El valor predeterminado es TLS cifrado.
|
|
properties.clusteringPolicy
|
ClusteringPolicy
|
Directiva de agrupación en clústeres: el valor predeterminado es OSSCluster. Esta propiedad solo se puede actualizar si el valor actual es NoCluster. Si el valor es OSSCluster o EnterpriseCluster, no se puede actualizar sin eliminar la base de datos.
|
|
properties.deferUpgrade
|
DeferUpgradeSetting
|
Opción para aplazar la actualización cuando se publica la versión más reciente: el valor predeterminado es NotDeferred. Aprende más: https://aka.ms/redisversionupgrade
|
|
properties.evictionPolicy
|
EvictionPolicy
|
Directiva de expulsión de Redis: el valor predeterminado es VolatileLRU
|
|
properties.geoReplication
|
GeoReplication
|
Conjunto opcional de propiedades para configurar la replicación geográfica para esta base de datos.
|
|
properties.modules
|
Module[]
|
Conjunto opcional de módulos de redis que se habilitarán en esta base de datos: los módulos solo se pueden agregar en tiempo de creación.
|
|
properties.persistence
|
Persistence
|
Configuración de persistencia
Configuración de persistencia
|
|
properties.port
|
integer
(int32)
|
Puerto TCP del punto de conexión de la base de datos. Especificado en tiempo de creación. El valor predeterminado es un puerto disponible.
|
Respuestas
| Nombre |
Tipo |
Description |
|
200 OK
|
Database
|
La base de datos se estaba actualizando o se está actualizando. Compruebe provisioningState y resourceState para conocer el estado detallado.
|
|
201 Created
|
Database
|
La base de datos se estaba creando o se está creando. Compruebe provisioningState y resourceState para conocer el estado detallado.
|
|
Other Status Codes
|
ErrorResponse
|
Respuesta de error que describe por qué se produjo un error en la operación.
|
Seguridad
azure_auth
Flujo de OAuth2 de Azure Active Directory.
Tipo:
oauth2
Flujo:
implicit
Dirección URL de autorización:
https://login.microsoftonline.com/common/oauth2/authorize
Ámbitos
| Nombre |
Description |
|
user_impersonation
|
suplantar la cuenta de usuario
|
Ejemplos
RedisEnterpriseDatabasesCreate
Solicitud de ejemplo
PUT 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": "AllKeysLRU",
"persistence": {
"aofEnabled": true,
"aofFrequency": "1s"
},
"port": 10000,
"modules": [
{
"name": "RedisBloom",
"args": "ERROR_RATE 0.00 INITIAL_SIZE 400"
},
{
"name": "RedisTimeSeries",
"args": "RETENTION_POLICY 20"
},
{
"name": "RediSearch"
}
],
"deferUpgrade": "NotDeferred",
"accessKeysAuthentication": "Enabled"
}
}
import com.azure.resourcemanager.redisenterprise.models.AccessKeysAuthentication;
import com.azure.resourcemanager.redisenterprise.models.AofFrequency;
import com.azure.resourcemanager.redisenterprise.models.ClusteringPolicy;
import com.azure.resourcemanager.redisenterprise.models.DeferUpgradeSetting;
import com.azure.resourcemanager.redisenterprise.models.EvictionPolicy;
import com.azure.resourcemanager.redisenterprise.models.Module;
import com.azure.resourcemanager.redisenterprise.models.Persistence;
import com.azure.resourcemanager.redisenterprise.models.Protocol;
import java.util.Arrays;
/**
* Samples for Databases Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
* RedisEnterpriseDatabasesCreate.json
*/
/**
* Sample code: RedisEnterpriseDatabasesCreate.
*
* @param manager Entry point to RedisEnterpriseManager.
*/
public static void
redisEnterpriseDatabasesCreate(com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
manager.databases().define("default").withExistingRedisEnterprise("rg1", "cache1")
.withClientProtocol(Protocol.ENCRYPTED).withPort(10000)
.withClusteringPolicy(ClusteringPolicy.ENTERPRISE_CLUSTER).withEvictionPolicy(EvictionPolicy.ALL_KEYS_LRU)
.withPersistence(new Persistence().withAofEnabled(true).withAofFrequency(AofFrequency.ONES))
.withModules(Arrays.asList(new Module().withName("RedisBloom").withArgs("ERROR_RATE 0.00 INITIAL_SIZE 400"),
new Module().withName("RedisTimeSeries").withArgs("RETENTION_POLICY 20"),
new Module().withName("RediSearch")))
.withDeferUpgrade(DeferUpgradeSetting.NOT_DEFERRED)
.withAccessKeysAuthentication(AccessKeysAuthentication.ENABLED).create();
}
}
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.redisenterprise import RedisEnterpriseManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-redisenterprise
# USAGE
python redis_enterprise_databases_create.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_create(
resource_group_name="rg1",
cluster_name="cache1",
database_name="default",
parameters={
"properties": {
"accessKeysAuthentication": "Enabled",
"clientProtocol": "Encrypted",
"clusteringPolicy": "EnterpriseCluster",
"deferUpgrade": "NotDeferred",
"evictionPolicy": "AllKeysLRU",
"modules": [
{"args": "ERROR_RATE 0.00 INITIAL_SIZE 400", "name": "RedisBloom"},
{"args": "RETENTION_POLICY 20", "name": "RedisTimeSeries"},
{"name": "RediSearch"},
],
"persistence": {"aofEnabled": True, "aofFrequency": "1s"},
"port": 10000,
}
},
).result()
print(response)
# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesCreate.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 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/RedisEnterpriseDatabasesCreate.json
func ExampleDatabasesClient_BeginCreate_redisEnterpriseDatabasesCreate() {
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().BeginCreate(ctx, "rg1", "cache1", "default", armredisenterprise.Database{
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.EvictionPolicyAllKeysLRU),
Modules: []*armredisenterprise.Module{
{
Name: to.Ptr("RedisBloom"),
Args: to.Ptr("ERROR_RATE 0.00 INITIAL_SIZE 400"),
},
{
Name: to.Ptr("RedisTimeSeries"),
Args: to.Ptr("RETENTION_POLICY 20"),
},
{
Name: to.Ptr("RediSearch"),
}},
Persistence: &armredisenterprise.Persistence{
AofEnabled: to.Ptr(true),
AofFrequency: to.Ptr(armredisenterprise.AofFrequencyOneS),
},
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.EvictionPolicyAllKeysLRU),
// Modules: []*armredisenterprise.Module{
// {
// Name: to.Ptr("RedisBloom"),
// Args: to.Ptr("ERROR_RATE 0.00 INITIAL_SIZE 400"),
// Version: to.Ptr("1.0.0"),
// },
// {
// Name: to.Ptr("RedisTimeSeries"),
// Args: to.Ptr("RETENTION_POLICY 20"),
// Version: to.Ptr("1.0.0"),
// },
// {
// Name: to.Ptr("RediSearch"),
// Args: to.Ptr(""),
// Version: to.Ptr("1.0.0"),
// }},
// Persistence: &armredisenterprise.Persistence{
// AofEnabled: to.Ptr(true),
// AofFrequency: to.Ptr(armredisenterprise.AofFrequencyOneS),
// },
// 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
const { RedisEnterpriseManagementClient } = require("@azure/arm-redisenterprisecache");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");
/**
* This sample demonstrates how to Creates a database
*
* @summary Creates a database
* x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesCreate.json
*/
async function redisEnterpriseDatabasesCreate() {
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",
clusteringPolicy: "EnterpriseCluster",
deferUpgrade: "NotDeferred",
evictionPolicy: "AllKeysLRU",
modules: [
{ name: "RedisBloom", args: "ERROR_RATE 0.00 INITIAL_SIZE 400" },
{ name: "RedisTimeSeries", args: "RETENTION_POLICY 20" },
{ name: "RediSearch" },
],
persistence: { aofEnabled: true, aofFrequency: "1s" },
port: 10000,
};
const credential = new DefaultAzureCredential();
const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
const result = await client.databases.beginCreateAndWait(
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
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/RedisEnterpriseDatabasesCreate.json
// this example is just showing the usage of "Databases_Create" 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 RedisEnterpriseClusterResource created on azure
// for more information of creating RedisEnterpriseClusterResource, please refer to the document of RedisEnterpriseClusterResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
string clusterName = "cache1";
ResourceIdentifier redisEnterpriseClusterResourceId = RedisEnterpriseClusterResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, clusterName);
RedisEnterpriseClusterResource redisEnterpriseCluster = client.GetRedisEnterpriseClusterResource(redisEnterpriseClusterResourceId);
// get the collection of this RedisEnterpriseDatabaseResource
RedisEnterpriseDatabaseCollection collection = redisEnterpriseCluster.GetRedisEnterpriseDatabases();
// invoke the operation
string databaseName = "default";
RedisEnterpriseDatabaseData data = new RedisEnterpriseDatabaseData
{
ClientProtocol = RedisEnterpriseClientProtocol.Encrypted,
Port = 10000,
ClusteringPolicy = RedisEnterpriseClusteringPolicy.EnterpriseCluster,
EvictionPolicy = RedisEnterpriseEvictionPolicy.AllKeysLru,
Persistence = new RedisPersistenceSettings
{
IsAofEnabled = true,
AofFrequency = PersistenceSettingAofFrequency.OneSecond,
},
Modules = {new RedisEnterpriseModule("RedisBloom")
{
Args = "ERROR_RATE 0.00 INITIAL_SIZE 400",
}, new RedisEnterpriseModule("RedisTimeSeries")
{
Args = "RETENTION_POLICY 20",
}, new RedisEnterpriseModule("RediSearch")},
DeferUpgrade = DeferUpgradeSetting.NotDeferred,
AccessKeysAuthentication = AccessKeysAuthentication.Enabled,
};
ArmOperation<RedisEnterpriseDatabaseResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, databaseName, data);
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
Respuesta de muestra
{
"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": "EnterpriseCluster",
"evictionPolicy": "AllKeysLRU",
"persistence": {
"aofEnabled": true,
"aofFrequency": "1s"
},
"port": 10000,
"modules": [
{
"name": "RedisBloom",
"args": "ERROR_RATE 0.00 INITIAL_SIZE 400",
"version": "1.0.0"
},
{
"name": "RedisTimeSeries",
"args": "RETENTION_POLICY 20",
"version": "1.0.0"
},
{
"name": "RediSearch",
"args": "",
"version": "1.0.0"
}
],
"deferUpgrade": "NotDeferred",
"accessKeysAuthentication": "Enabled",
"redisVersion": "6.0"
}
}
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/db1",
"name": "cache1/db1",
"type": "Microsoft.Cache/redisEnterprise/databases",
"properties": {
"provisioningState": "Creating",
"resourceState": "Creating",
"clientProtocol": "Encrypted",
"clusteringPolicy": "EnterpriseCluster",
"evictionPolicy": "AllKeysLRU",
"persistence": {
"aofEnabled": true,
"aofFrequency": "1s"
},
"port": 10000,
"modules": [
{
"name": "RedisBloom",
"args": "ERROR_RATE 0.00 INITIAL_SIZE 400",
"version": "1.0.0"
},
{
"name": "RedisTimeSeries",
"args": "RETENTION_POLICY 20",
"version": "1.0.0"
},
{
"name": "RediSearch",
"args": "",
"version": "1.0.0"
}
],
"accessKeysAuthentication": "Enabled"
}
}
RedisEnterpriseDatabasesCreate No Cluster Cache
Solicitud de ejemplo
PUT 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": "NoCluster",
"evictionPolicy": "NoEviction",
"port": 10000
}
}
import com.azure.resourcemanager.redisenterprise.models.ClusteringPolicy;
import com.azure.resourcemanager.redisenterprise.models.EvictionPolicy;
import com.azure.resourcemanager.redisenterprise.models.Protocol;
/**
* Samples for Databases Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
* RedisEnterpriseDatabasesNoClusterCacheCreate.json
*/
/**
* Sample code: RedisEnterpriseDatabasesCreate No Cluster Cache.
*
* @param manager Entry point to RedisEnterpriseManager.
*/
public static void redisEnterpriseDatabasesCreateNoClusterCache(
com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
manager.databases().define("default").withExistingRedisEnterprise("rg1", "cache1")
.withClientProtocol(Protocol.ENCRYPTED).withPort(10000).withClusteringPolicy(ClusteringPolicy.NO_CLUSTER)
.withEvictionPolicy(EvictionPolicy.NO_EVICTION).create();
}
}
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.redisenterprise import RedisEnterpriseManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-redisenterprise
# USAGE
python redis_enterprise_databases_no_cluster_cache_create.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_create(
resource_group_name="rg1",
cluster_name="cache1",
database_name="default",
parameters={
"properties": {
"clientProtocol": "Encrypted",
"clusteringPolicy": "NoCluster",
"evictionPolicy": "NoEviction",
"port": 10000,
}
},
).result()
print(response)
# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheCreate.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 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/RedisEnterpriseDatabasesNoClusterCacheCreate.json
func ExampleDatabasesClient_BeginCreate_redisEnterpriseDatabasesCreateNoClusterCache() {
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().BeginCreate(ctx, "rg1", "cache1", "default", armredisenterprise.Database{
Properties: &armredisenterprise.DatabaseCreateProperties{
ClientProtocol: to.Ptr(armredisenterprise.ProtocolEncrypted),
ClusteringPolicy: to.Ptr(armredisenterprise.ClusteringPolicyNoCluster),
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.ClusteringPolicyNoCluster),
// 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
const { RedisEnterpriseManagementClient } = require("@azure/arm-redisenterprisecache");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");
/**
* This sample demonstrates how to Creates a database
*
* @summary Creates a database
* x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesNoClusterCacheCreate.json
*/
async function redisEnterpriseDatabasesCreateNoClusterCache() {
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: "NoCluster",
evictionPolicy: "NoEviction",
port: 10000,
};
const credential = new DefaultAzureCredential();
const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
const result = await client.databases.beginCreateAndWait(
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
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/RedisEnterpriseDatabasesNoClusterCacheCreate.json
// this example is just showing the usage of "Databases_Create" 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 RedisEnterpriseClusterResource created on azure
// for more information of creating RedisEnterpriseClusterResource, please refer to the document of RedisEnterpriseClusterResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
string clusterName = "cache1";
ResourceIdentifier redisEnterpriseClusterResourceId = RedisEnterpriseClusterResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, clusterName);
RedisEnterpriseClusterResource redisEnterpriseCluster = client.GetRedisEnterpriseClusterResource(redisEnterpriseClusterResourceId);
// get the collection of this RedisEnterpriseDatabaseResource
RedisEnterpriseDatabaseCollection collection = redisEnterpriseCluster.GetRedisEnterpriseDatabases();
// invoke the operation
string databaseName = "default";
RedisEnterpriseDatabaseData data = new RedisEnterpriseDatabaseData
{
ClientProtocol = RedisEnterpriseClientProtocol.Encrypted,
Port = 10000,
ClusteringPolicy = RedisEnterpriseClusteringPolicy.NoCluster,
EvictionPolicy = RedisEnterpriseEvictionPolicy.NoEviction,
};
ArmOperation<RedisEnterpriseDatabaseResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, databaseName, data);
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
Respuesta de muestra
{
"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": "Creating",
"resourceState": "Creating",
"clusteringPolicy": "NoCluster",
"evictionPolicy": "NoEviction",
"deferUpgrade": "NotDeferred",
"redisVersion": "7.2",
"accessKeysAuthentication": "Enabled"
}
}
{
"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": "NoCluster",
"evictionPolicy": "NoEviction",
"deferUpgrade": "NotDeferred",
"redisVersion": "7.2",
"accessKeysAuthentication": "Enabled"
}
}
RedisEnterpriseDatabasesCreate With Active Geo Replication
Solicitud de ejemplo
PUT 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,
"accessKeysAuthentication": "Enabled",
"geoReplication": {
"groupNickname": "groupName",
"linkedDatabases": [
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"
},
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"
}
]
}
}
}
import com.azure.resourcemanager.redisenterprise.models.AccessKeysAuthentication;
import com.azure.resourcemanager.redisenterprise.models.ClusteringPolicy;
import com.azure.resourcemanager.redisenterprise.models.DatabasePropertiesGeoReplication;
import com.azure.resourcemanager.redisenterprise.models.EvictionPolicy;
import com.azure.resourcemanager.redisenterprise.models.LinkedDatabase;
import com.azure.resourcemanager.redisenterprise.models.Protocol;
import java.util.Arrays;
/**
* Samples for Databases Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
* RedisEnterpriseDatabasesCreateWithGeoReplication.json
*/
/**
* Sample code: RedisEnterpriseDatabasesCreate With Active Geo Replication.
*
* @param manager Entry point to RedisEnterpriseManager.
*/
public static void redisEnterpriseDatabasesCreateWithActiveGeoReplication(
com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
manager.databases().define("default").withExistingRedisEnterprise("rg1", "cache1")
.withClientProtocol(Protocol.ENCRYPTED).withPort(10000)
.withClusteringPolicy(ClusteringPolicy.ENTERPRISE_CLUSTER).withEvictionPolicy(EvictionPolicy.NO_EVICTION)
.withGeoReplication(new DatabasePropertiesGeoReplication().withGroupNickname("groupName")
.withLinkedDatabases(Arrays.asList(new LinkedDatabase().withId(
"/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
new LinkedDatabase().withId(
"/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"))))
.withAccessKeysAuthentication(AccessKeysAuthentication.ENABLED).create();
}
}
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.redisenterprise import RedisEnterpriseManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-redisenterprise
# USAGE
python redis_enterprise_databases_create_with_geo_replication.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_create(
resource_group_name="rg1",
cluster_name="cache1",
database_name="default",
parameters={
"properties": {
"accessKeysAuthentication": "Enabled",
"clientProtocol": "Encrypted",
"clusteringPolicy": "EnterpriseCluster",
"evictionPolicy": "NoEviction",
"geoReplication": {
"groupNickname": "groupName",
"linkedDatabases": [
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"
},
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"
},
],
},
"port": 10000,
}
},
).result()
print(response)
# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesCreateWithGeoReplication.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 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/RedisEnterpriseDatabasesCreateWithGeoReplication.json
func ExampleDatabasesClient_BeginCreate_redisEnterpriseDatabasesCreateWithActiveGeoReplication() {
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().BeginCreate(ctx, "rg1", "cache1", "default", armredisenterprise.Database{
Properties: &armredisenterprise.DatabaseCreateProperties{
AccessKeysAuthentication: to.Ptr(armredisenterprise.AccessKeysAuthenticationEnabled),
ClientProtocol: to.Ptr(armredisenterprise.ProtocolEncrypted),
ClusteringPolicy: to.Ptr(armredisenterprise.ClusteringPolicyEnterpriseCluster),
EvictionPolicy: to.Ptr(armredisenterprise.EvictionPolicyNoEviction),
GeoReplication: &armredisenterprise.DatabaseCommonPropertiesGeoReplication{
GroupNickname: to.Ptr("groupName"),
LinkedDatabases: []*armredisenterprise.LinkedDatabase{
{
ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
},
{
ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"),
}},
},
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),
// GeoReplication: &armredisenterprise.DatabaseCommonPropertiesGeoReplication{
// GroupNickname: to.Ptr("groupName"),
// LinkedDatabases: []*armredisenterprise.LinkedDatabase{
// {
// ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
// State: to.Ptr(armredisenterprise.LinkStateLinking),
// },
// {
// ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f2/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"),
// State: to.Ptr(armredisenterprise.LinkStateLinking),
// }},
// },
// 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
const { RedisEnterpriseManagementClient } = require("@azure/arm-redisenterprisecache");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");
/**
* This sample demonstrates how to Creates a database
*
* @summary Creates a database
* x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseDatabasesCreateWithGeoReplication.json
*/
async function redisEnterpriseDatabasesCreateWithActiveGeoReplication() {
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",
clusteringPolicy: "EnterpriseCluster",
evictionPolicy: "NoEviction",
geoReplication: {
groupNickname: "groupName",
linkedDatabases: [
{
id: "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
},
{
id: "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
},
],
},
port: 10000,
};
const credential = new DefaultAzureCredential();
const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
const result = await client.databases.beginCreateAndWait(
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
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/RedisEnterpriseDatabasesCreateWithGeoReplication.json
// this example is just showing the usage of "Databases_Create" 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 RedisEnterpriseClusterResource created on azure
// for more information of creating RedisEnterpriseClusterResource, please refer to the document of RedisEnterpriseClusterResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
string clusterName = "cache1";
ResourceIdentifier redisEnterpriseClusterResourceId = RedisEnterpriseClusterResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, clusterName);
RedisEnterpriseClusterResource redisEnterpriseCluster = client.GetRedisEnterpriseClusterResource(redisEnterpriseClusterResourceId);
// get the collection of this RedisEnterpriseDatabaseResource
RedisEnterpriseDatabaseCollection collection = redisEnterpriseCluster.GetRedisEnterpriseDatabases();
// invoke the operation
string databaseName = "default";
RedisEnterpriseDatabaseData data = new RedisEnterpriseDatabaseData
{
ClientProtocol = RedisEnterpriseClientProtocol.Encrypted,
Port = 10000,
ClusteringPolicy = RedisEnterpriseClusteringPolicy.EnterpriseCluster,
EvictionPolicy = RedisEnterpriseEvictionPolicy.NoEviction,
GeoReplication = new RedisEnterpriseDatabaseGeoReplication
{
GroupNickname = "groupName",
LinkedDatabases = {new RedisEnterpriseLinkedDatabase
{
Id = new ResourceIdentifier("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
}, new RedisEnterpriseLinkedDatabase
{
Id = new ResourceIdentifier("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"),
}},
},
AccessKeysAuthentication = AccessKeysAuthentication.Enabled,
};
ArmOperation<RedisEnterpriseDatabaseResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, databaseName, data);
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
Respuesta de muestra
{
"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": "EnterpriseCluster",
"evictionPolicy": "NoEviction",
"port": 10000,
"geoReplication": {
"groupNickname": "groupName",
"linkedDatabases": [
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
"state": "Linking"
},
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f2/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
"state": "Linking"
}
]
},
"deferUpgrade": "NotDeferred",
"accessKeysAuthentication": "Enabled",
"redisVersion": "6.0"
}
}
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/db1",
"name": "cache1/db1",
"type": "Microsoft.Cache/redisEnterprise/databases",
"properties": {
"provisioningState": "Creating",
"resourceState": "Creating",
"clientProtocol": "Plaintext",
"clusteringPolicy": "EnterpriseCluster",
"evictionPolicy": "NoEviction",
"port": 10000,
"geoReplication": {
"groupNickname": "groupName",
"linkedDatabases": [
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
"state": "Linking"
},
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f2/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
"state": "Linking"
}
]
},
"deferUpgrade": "NotDeferred",
"accessKeysAuthentication": "Enabled",
"redisVersion": "6.0"
}
}
Definiciones
| Nombre |
Description |
|
accessKeysAuthentication
|
Esta propiedad puede estar habilitada o deshabilitada para permitir o denegar el acceso con las claves de acceso actuales. Se puede actualizar incluso después de crear la base de datos. El valor predeterminado es Deshabilitado.
|
|
AofFrequency
|
Establece la frecuencia con la que se escriben los datos en el disco. El valor predeterminado es "1s", lo que significa "cada segundo". Tenga en cuenta que la configuración "always" está en desuso, debido a su impacto en el rendimiento.
|
|
ClusteringPolicy
|
Directiva de agrupación en clústeres: el valor predeterminado es OSSCluster. Esta propiedad solo se puede actualizar si el valor actual es NoCluster. Si el valor es OSSCluster o EnterpriseCluster, no se puede actualizar sin eliminar la base de datos.
|
|
Database
|
Describe una base de datos en el clúster de Redis Enterprise
|
|
DeferUpgradeSetting
|
Opción para aplazar la actualización cuando se publica la versión más reciente: el valor predeterminado es NotDeferred. Aprende más: https://aka.ms/redisversionupgrade
|
|
ErrorAdditionalInfo
|
Información adicional sobre el error de administración de recursos.
|
|
ErrorDetail
|
Detalle del error.
|
|
ErrorResponse
|
Respuesta de error
|
|
EvictionPolicy
|
Directiva de expulsión de Redis: el valor predeterminado es VolatileLRU
|
|
GeoReplication
|
Conjunto opcional de propiedades para configurar la replicación geográfica para esta base de datos.
|
|
LinkedDatabase
|
Base de datos vinculada
|
|
LinkState
|
Estado del vínculo entre los recursos de la base de datos.
|
|
Module
|
Configuración del módulo
|
|
Persistence
|
Configuración de persistencia
|
|
Protocol
|
Especifica si los clientes de Redis pueden conectarse mediante protocolos de redis cifrados mediante TLS o con texto no cifrado. El valor predeterminado es TLS cifrado.
|
|
ProvisioningState
|
Estado actual del aprovisionamiento
|
|
RdbFrequency
|
Establece la frecuencia con la que se crea una instantánea de la base de datos.
|
|
ResourceState
|
Estado actual de los recursos
|
accessKeysAuthentication
Enumeración
Esta propiedad puede estar habilitada o deshabilitada para permitir o denegar el acceso con las claves de acceso actuales. Se puede actualizar incluso después de crear la base de datos. El valor predeterminado es Deshabilitado.
| Valor |
Description |
|
Disabled
|
|
|
Enabled
|
|
AofFrequency
Enumeración
Establece la frecuencia con la que se escriben los datos en el disco. El valor predeterminado es "1s", lo que significa "cada segundo". Tenga en cuenta que la configuración "always" está en desuso, debido a su impacto en el rendimiento.
| Valor |
Description |
|
1s
|
|
|
always
|
|
ClusteringPolicy
Enumeración
Directiva de agrupación en clústeres: el valor predeterminado es OSSCluster. Esta propiedad solo se puede actualizar si el valor actual es NoCluster. Si el valor es OSSCluster o EnterpriseCluster, no se puede actualizar sin eliminar la base de datos.
| Valor |
Description |
|
EnterpriseCluster
|
La directiva de clústeres empresariales solo utiliza el protocolo redis clásico, que no admite comandos de clúster redis.
|
|
OSSCluster
|
La directiva de clústeres de OSS sigue la especificación de clúster de redis y requiere que todos los clientes admitan la agrupación en clústeres de redis.
|
|
NoCluster
|
La directiva NoCluster se utiliza para instancias de Redis no agrupadas en clústeres que no requieren funciones de agrupación en clústeres.
|
Database
Objeto
Describe una base de datos en el clúster de Redis Enterprise
| Nombre |
Tipo |
Valor predeterminado |
Description |
|
id
|
string
|
|
Identificador de recurso completo para el recurso. Por ejemplo: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
|
|
name
|
string
|
|
Nombre del recurso
|
|
properties.accessKeysAuthentication
|
accessKeysAuthentication
|
Disabled
|
Esta propiedad puede estar habilitada o deshabilitada para permitir o denegar el acceso con las claves de acceso actuales. Se puede actualizar incluso después de crear la base de datos. El valor predeterminado es Deshabilitado.
|
|
properties.clientProtocol
|
Protocol
|
|
Especifica si los clientes de Redis pueden conectarse mediante protocolos de redis cifrados mediante TLS o con texto no cifrado. El valor predeterminado es TLS cifrado.
|
|
properties.clusteringPolicy
|
ClusteringPolicy
|
|
Directiva de agrupación en clústeres: el valor predeterminado es OSSCluster. Esta propiedad solo se puede actualizar si el valor actual es NoCluster. Si el valor es OSSCluster o EnterpriseCluster, no se puede actualizar sin eliminar la base de datos.
|
|
properties.deferUpgrade
|
DeferUpgradeSetting
|
|
Opción para aplazar la actualización cuando se publica la versión más reciente: el valor predeterminado es NotDeferred. Aprende más: https://aka.ms/redisversionupgrade
|
|
properties.evictionPolicy
|
EvictionPolicy
|
|
Directiva de expulsión de Redis: el valor predeterminado es VolatileLRU
|
|
properties.geoReplication
|
GeoReplication
|
|
Conjunto opcional de propiedades para configurar la replicación geográfica para esta base de datos.
|
|
properties.modules
|
Module[]
|
|
Conjunto opcional de módulos de redis que se habilitarán en esta base de datos: los módulos solo se pueden agregar en tiempo de creación.
|
|
properties.persistence
|
Persistence
|
|
Configuración de persistencia
Configuración de persistencia
|
|
properties.port
|
integer
(int32)
|
|
Puerto TCP del punto de conexión de la base de datos. Especificado en tiempo de creación. El valor predeterminado es un puerto disponible.
|
|
properties.provisioningState
|
ProvisioningState
|
|
Estado actual de aprovisionamiento de la base de datos
|
|
properties.redisVersion
|
string
|
|
Versión de Redis en la que se ejecuta la base de datos, por ejemplo, '6.0'
|
|
properties.resourceState
|
ResourceState
|
|
Estado actual de los recursos de la base de datos
|
|
type
|
string
|
|
Tipo de recurso. Por ejemplo, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"
|
DeferUpgradeSetting
Enumeración
Opción para aplazar la actualización cuando se publica la versión más reciente: el valor predeterminado es NotDeferred. Aprende más: https://aka.ms/redisversionupgrade
| Valor |
Description |
|
Deferred
|
|
|
NotDeferred
|
|
ErrorAdditionalInfo
Objeto
Información adicional sobre el error de administración de recursos.
| Nombre |
Tipo |
Description |
|
info
|
object
|
Información adicional.
|
|
type
|
string
|
Tipo de información adicional.
|
ErrorDetail
Objeto
Detalle del error.
| Nombre |
Tipo |
Description |
|
additionalInfo
|
ErrorAdditionalInfo[]
|
Información adicional del error.
|
|
code
|
string
|
Código de error.
|
|
details
|
ErrorDetail[]
|
Detalles del error.
|
|
message
|
string
|
El mensaje de error.
|
|
target
|
string
|
Destino del error.
|
ErrorResponse
Objeto
Respuesta de error
| Nombre |
Tipo |
Description |
|
error
|
ErrorDetail
|
Objeto de error.
|
EvictionPolicy
Enumeración
Directiva de expulsión de Redis: el valor predeterminado es VolatileLRU
| Valor |
Description |
|
AllKeysLFU
|
|
|
AllKeysLRU
|
|
|
AllKeysRandom
|
|
|
VolatileLRU
|
|
|
VolatileLFU
|
|
|
VolatileTTL
|
|
|
VolatileRandom
|
|
|
NoEviction
|
|
GeoReplication
Objeto
Conjunto opcional de propiedades para configurar la replicación geográfica para esta base de datos.
| Nombre |
Tipo |
Description |
|
groupNickname
|
string
|
Nombre del grupo de recursos de base de datos vinculados
|
|
linkedDatabases
|
LinkedDatabase[]
|
Lista de recursos de base de datos para vincular con esta base de datos
|
LinkedDatabase
Objeto
Base de datos vinculada
| Nombre |
Tipo |
Description |
|
id
|
string
(arm-id)
|
Identificador de recurso de un recurso de base de datos que se va a vincular con esta base de datos.
|
|
state
|
LinkState
|
Estado del vínculo entre los recursos de la base de datos.
|
LinkState
Enumeración
Estado del vínculo entre los recursos de la base de datos.
| Valor |
Description |
|
Linked
|
|
|
Linking
|
|
|
Unlinking
|
|
|
LinkFailed
|
|
|
UnlinkFailed
|
|
Module
Objeto
Configuración del módulo
| Nombre |
Tipo |
Description |
|
args
|
string
|
Opciones de configuración para el módulo, por ejemplo, "ERROR_RATE 0,01 INITIAL_SIZE 400".
|
|
name
|
string
|
Nombre del módulo, por ejemplo, "RedisBloom", "RediSearch", "RedisTimeSeries"
|
|
version
|
string
|
La versión del módulo, por ejemplo, '1.0'.
|
Persistence
Objeto
Configuración de persistencia
| Nombre |
Tipo |
Description |
|
aofEnabled
|
boolean
|
Establece si AOF está habilitado. Tenga en cuenta que, como máximo, se puede habilitar la persistencia de AOF o RDB.
|
|
aofFrequency
|
AofFrequency
|
Establece la frecuencia con la que se escriben los datos en el disco. El valor predeterminado es "1s", lo que significa "cada segundo". Tenga en cuenta que la configuración "always" está en desuso, debido a su impacto en el rendimiento.
|
|
rdbEnabled
|
boolean
|
Establece si RDB está habilitado. Tenga en cuenta que, como máximo, se puede habilitar la persistencia de AOF o RDB.
|
|
rdbFrequency
|
RdbFrequency
|
Establece la frecuencia con la que se crea una instantánea de la base de datos.
|
Protocol
Enumeración
Especifica si los clientes de Redis pueden conectarse mediante protocolos de redis cifrados mediante TLS o con texto no cifrado. El valor predeterminado es TLS cifrado.
| Valor |
Description |
|
Encrypted
|
|
|
Plaintext
|
|
ProvisioningState
Enumeración
Estado actual del aprovisionamiento
| Valor |
Description |
|
Succeeded
|
|
|
Failed
|
|
|
Canceled
|
|
|
Creating
|
|
|
Updating
|
|
|
Deleting
|
|
RdbFrequency
Enumeración
Establece la frecuencia con la que se crea una instantánea de la base de datos.
| Valor |
Description |
|
1h
|
|
|
6h
|
|
|
12h
|
|
ResourceState
Enumeración
Estado actual de los recursos
| Valor |
Description |
|
Running
|
|
|
Creating
|
|
|
CreateFailed
|
|
|
Updating
|
|
|
UpdateFailed
|
|
|
Deleting
|
|
|
DeleteFailed
|
|
|
Enabling
|
|
|
EnableFailed
|
|
|
Disabling
|
|
|
DisableFailed
|
|
|
Disabled
|
|
|
Scaling
|
|
|
ScalingFailed
|
|
|
Moving
|
|