Databases - Create

Dienst:: Redis Cache

API-Version:: 2025-07-01

Erstellt eine Datenbank

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

URI-Parameter

Name	In	Erforderlich	Typ	Beschreibung
clusterName	path	True	string pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$	Der Name des Redis Enterprise-Clusters. Der Name muss 1 bis 60 Zeichen lang sein. Zulässige Zeichen (A-Z, a-z, 0-9) und Bindestrich(-). Es kann weder führende noch nachfolgende Bindestriche oder aufeinander folgende Bindestriche geben.
databaseName	path	True	string pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$	Der Name der Redis Enterprise-Datenbank.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Der Name der Ressourcengruppe. Bei dem Namen wird die Groß-/Kleinschreibung nicht beachtet.
subscriptionId	path	True	string minLength: 1	Die ID des Zielabonnements.
api-version	query	True	string minLength: 1	Hierbei handelt es sich um die für diesen Vorgang zu verwendende API-Version.

Anforderungstext

Name	Typ	Beschreibung
properties.accessKeysAuthentication	accessKeysAuthentication	Diese Eigenschaft kann aktiviert/deaktiviert sein, um den Zugriff mit den aktuellen Zugriffstasten zuzulassen oder zu verweigern. Kann auch nach der Erstellung der Datenbank aktualisiert werden. Der Standardwert ist deaktiviert.
properties.clientProtocol	Protocol	Gibt an, ob Redis-Clients eine Verbindung mit TLS-verschlüsselten oder Nur-Text-Redis-Protokollen herstellen können. Der Standardwert ist TLS-verschlüsselt.
properties.clusteringPolicy	ClusteringPolicy	Clustering-Richtlinie – Der Standardwert ist OSSCluster. Diese Eigenschaft kann nur aktualisiert werden, wenn der aktuelle Wert NoCluster ist. Wenn der Wert OSSCluster oder EnterpriseCluster ist, kann er nicht aktualisiert werden, ohne die Datenbank zu löschen.
properties.deferUpgrade	DeferUpgradeSetting	Option zum Zurückstellen des Upgrades, wenn die neueste Version veröffentlicht wird – Der Standardwert ist "NotDeferred". Weitere Informationen: https://aka.ms/redisversionupgrade
properties.evictionPolicy	EvictionPolicy	Redis-Entfernungsrichtlinie – Standardeinstellung ist VolatileLRU
properties.geoReplication	GeoReplication	Optionaler Satz von Eigenschaften zum Konfigurieren der Georeplikation für diese Datenbank.
properties.modules	Module[]	Optionaler Satz von Redis-Modulen, die in dieser Datenbank aktiviert werden sollen – Module können nur zur Erstellungszeit hinzugefügt werden.
properties.persistence	Persistence	Persistenzeinstellungen Persistenzeinstellungen
properties.port	integer (int32)	TCP-Port des Datenbankendpunkts. Zur Erstellungszeit angegeben. Standardmäßig wird ein verfügbarer Port verwendet.

Antworten

Name	Typ	Beschreibung
200 OK	Database	Die Datenbank wurde/wird aktualisiert. Überprüfen Sie provisioningState und resourceState auf detaillierten Status.
201 Created	Database	Die Datenbank wurde/wird erstellt. Überprüfen Sie provisioningState und resourceState auf detaillierten Status.
Other Status Codes	ErrorResponse	Fehlerantwort, die beschreibt, warum der Vorgang fehlgeschlagen ist.

Sicherheit

azure_auth

Azure Active Directory OAuth2-Fluss.

Typ: oauth2
Ablauf: implicit
Autorisierungs-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiche

Name	Beschreibung
user_impersonation	Identitätswechsel ihres Benutzerkontos

Beispiele

RedisEnterpriseDatabasesCreate

RedisEnterpriseDatabasesCreate No Cluster Cache

RedisEnterpriseDatabasesCreate With Active Geo Replication

RedisEnterpriseDatabasesCreate

Beispielanforderung

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

Beispiel für eine Antwort

Statuscode:: 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": "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"
  }
}

Statuscode:: 201

{
  "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

Beispielanforderung

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

Beispiel für eine Antwort

Statuscode:: 201

{
  "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"
  }
}

Statuscode:: 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": "NoCluster",
    "evictionPolicy": "NoEviction",
    "deferUpgrade": "NotDeferred",
    "redisVersion": "7.2",
    "accessKeysAuthentication": "Enabled"
  }
}

RedisEnterpriseDatabasesCreate With Active Geo Replication

Beispielanforderung

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

Beispiel für eine Antwort

Statuscode:: 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": "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"
  }
}

Statuscode:: 201

{
  "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"
  }
}

Definitionen

Name	Beschreibung
accessKeysAuthentication	Diese Eigenschaft kann aktiviert/deaktiviert sein, um den Zugriff mit den aktuellen Zugriffstasten zuzulassen oder zu verweigern. Kann auch nach der Erstellung der Datenbank aktualisiert werden. Der Standardwert ist deaktiviert.
AofFrequency	Legt die Häufigkeit fest, mit der Daten auf den Datenträger geschrieben werden. Der Standardwert ist "1s", d. h. "jede Sekunde". Beachten Sie, dass die Einstellung "immer" aufgrund ihrer Leistungseinbußen veraltet ist.
ClusteringPolicy	Clustering-Richtlinie – Der Standardwert ist OSSCluster. Diese Eigenschaft kann nur aktualisiert werden, wenn der aktuelle Wert NoCluster ist. Wenn der Wert OSSCluster oder EnterpriseCluster ist, kann er nicht aktualisiert werden, ohne die Datenbank zu löschen.
Database	Beschreibt eine Datenbank im Redis Enterprise-Cluster
DeferUpgradeSetting	Option zum Zurückstellen des Upgrades, wenn die neueste Version veröffentlicht wird – Der Standardwert ist "NotDeferred". Weitere Informationen: https://aka.ms/redisversionupgrade
ErrorAdditionalInfo	Der Ressourcenverwaltungsfehler zusätzliche Informationen.
ErrorDetail	Das Fehlerdetails.
ErrorResponse	Fehlerantwort
EvictionPolicy	Redis-Entfernungsrichtlinie – Standardeinstellung ist VolatileLRU
GeoReplication	Optionaler Satz von Eigenschaften zum Konfigurieren der Georeplikation für diese Datenbank.
LinkedDatabase	Verknüpfte Datenbank
LinkState	Status der Verknüpfung zwischen den Datenbankressourcen.
Module	Moduleinstellungen
Persistence	Persistenzeinstellungen
Protocol	Gibt an, ob Redis-Clients eine Verbindung mit TLS-verschlüsselten oder Nur-Text-Redis-Protokollen herstellen können. Der Standardwert ist TLS-verschlüsselt.
ProvisioningState	Aktueller Bereitstellungsstatus
RdbFrequency	Legt die Häufigkeit fest, mit der eine Momentaufnahme der Datenbank erstellt wird.
ResourceState	Aktueller Ressourcenstatus

accessKeysAuthentication

Enumeration

Diese Eigenschaft kann aktiviert/deaktiviert sein, um den Zugriff mit den aktuellen Zugriffstasten zuzulassen oder zu verweigern. Kann auch nach der Erstellung der Datenbank aktualisiert werden. Der Standardwert ist deaktiviert.

Wert	Beschreibung
Disabled
Enabled

AofFrequency

Enumeration

Legt die Häufigkeit fest, mit der Daten auf den Datenträger geschrieben werden. Der Standardwert ist "1s", d. h. "jede Sekunde". Beachten Sie, dass die Einstellung "immer" aufgrund ihrer Leistungseinbußen veraltet ist.

Wert	Beschreibung
1s
always

ClusteringPolicy

Enumeration

Clustering-Richtlinie – Der Standardwert ist OSSCluster. Diese Eigenschaft kann nur aktualisiert werden, wenn der aktuelle Wert NoCluster ist. Wenn der Wert OSSCluster oder EnterpriseCluster ist, kann er nicht aktualisiert werden, ohne die Datenbank zu löschen.

Wert	Beschreibung
EnterpriseCluster	Die Clustering-Richtlinie für Unternehmen verwendet nur das klassische Redis-Protokoll, das Redis-Clusterbefehle nicht unterstützt.
OSSCluster	Die OSS-Clusterrichtlinie folgt der Redis-Clusterspezifikation und erfordert, dass alle Clients Redis-Clustering unterstützen.
NoCluster	Die NoCluster-Richtlinie wird für nicht gruppierte Redis-Instanzen verwendet, die keine Clustering-Funktionen benötigen.

Database

Objekt

Beschreibt eine Datenbank im Redis Enterprise-Cluster

Name	Typ	Standardwert	Beschreibung
id	string		Vollqualifizierte Ressourcen-ID für die Ressource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string		Der Name der Ressource
properties.accessKeysAuthentication	accessKeysAuthentication	Disabled	Diese Eigenschaft kann aktiviert/deaktiviert sein, um den Zugriff mit den aktuellen Zugriffstasten zuzulassen oder zu verweigern. Kann auch nach der Erstellung der Datenbank aktualisiert werden. Der Standardwert ist deaktiviert.
properties.clientProtocol	Protocol		Gibt an, ob Redis-Clients eine Verbindung mit TLS-verschlüsselten oder Nur-Text-Redis-Protokollen herstellen können. Der Standardwert ist TLS-verschlüsselt.
properties.clusteringPolicy	ClusteringPolicy		Clustering-Richtlinie – Der Standardwert ist OSSCluster. Diese Eigenschaft kann nur aktualisiert werden, wenn der aktuelle Wert NoCluster ist. Wenn der Wert OSSCluster oder EnterpriseCluster ist, kann er nicht aktualisiert werden, ohne die Datenbank zu löschen.
properties.deferUpgrade	DeferUpgradeSetting		Option zum Zurückstellen des Upgrades, wenn die neueste Version veröffentlicht wird – Der Standardwert ist "NotDeferred". Weitere Informationen: https://aka.ms/redisversionupgrade
properties.evictionPolicy	EvictionPolicy		Redis-Entfernungsrichtlinie – Standardeinstellung ist VolatileLRU
properties.geoReplication	GeoReplication		Optionaler Satz von Eigenschaften zum Konfigurieren der Georeplikation für diese Datenbank.
properties.modules	Module[]		Optionaler Satz von Redis-Modulen, die in dieser Datenbank aktiviert werden sollen – Module können nur zur Erstellungszeit hinzugefügt werden.
properties.persistence	Persistence		Persistenzeinstellungen Persistenzeinstellungen
properties.port	integer (int32)		TCP-Port des Datenbankendpunkts. Zur Erstellungszeit angegeben. Standardmäßig wird ein verfügbarer Port verwendet.
properties.provisioningState	ProvisioningState		Aktueller Bereitstellungsstatus der Datenbank
properties.redisVersion	string		Version von Redis, auf der die Datenbank läuft, z.B. '6.0'
properties.resourceState	ResourceState		Aktueller Ressourcenstatus der Datenbank
type	string		Der Typ der Ressource. Z. B. "Microsoft.Compute/virtualMachines" oder "Microsoft.Storage/storageAccounts"

DeferUpgradeSetting

Enumeration

Option zum Zurückstellen des Upgrades, wenn die neueste Version veröffentlicht wird – Der Standardwert ist "NotDeferred". Weitere Informationen: https://aka.ms/redisversionupgrade

Wert	Beschreibung
Deferred
NotDeferred

ErrorAdditionalInfo

Objekt

Der Ressourcenverwaltungsfehler zusätzliche Informationen.

Name	Typ	Beschreibung
info	object	Die zusätzlichen Informationen.
type	string	Der zusätzliche Informationstyp.

ErrorDetail

Objekt

Das Fehlerdetails.

Name	Typ	Beschreibung
additionalInfo	ErrorAdditionalInfo[]	Die zusätzlichen Informationen des Fehlers.
code	string	Der Fehlercode.
details	ErrorDetail[]	Die Fehlerdetails.
message	string	Die Fehlermeldung.
target	string	Das Fehlerziel.

ErrorResponse

Objekt

Fehlerantwort

Name	Typ	Beschreibung
error	ErrorDetail	Das Fehlerobjekt.

EvictionPolicy

Enumeration

Redis-Entfernungsrichtlinie – Standardeinstellung ist VolatileLRU

Wert	Beschreibung
AllKeysLFU
AllKeysLRU
AllKeysRandom
VolatileLRU
VolatileLFU
VolatileTTL
VolatileRandom
NoEviction

GeoReplication

Objekt

Optionaler Satz von Eigenschaften zum Konfigurieren der Georeplikation für diese Datenbank.

Name	Typ	Beschreibung
groupNickname	string	Name für die Gruppe der verknüpften Datenbankressourcen
linkedDatabases	LinkedDatabase[]	Liste der Datenbankressourcen, die mit dieser Datenbank verknüpft werden sollen

LinkedDatabase

Objekt

Verknüpfte Datenbank

Name	Typ	Beschreibung
id	string (arm-id)	Ressourcen-ID einer Datenbankressource, die mit dieser Datenbank verknüpft werden soll.
state	LinkState	Status der Verknüpfung zwischen den Datenbankressourcen.

LinkState

Enumeration

Status der Verknüpfung zwischen den Datenbankressourcen.

Wert	Beschreibung
Linked
Linking
Unlinking
LinkFailed
UnlinkFailed

Module

Objekt

Moduleinstellungen

Name	Typ	Beschreibung
args	string	Konfigurationsoptionen für das Modul, z. B. "ERROR_RATE 0,01 INITIAL_SIZE 400".
name	string	Der Name des Moduls, z. B. "RedisBloom", "RediSearch", "RedisTimeSeries"
version	string	Die Version des Moduls, z.B. '1.0'.

Persistence

Objekt

Persistenzeinstellungen

Name	Typ	Beschreibung
aofEnabled	boolean	Legt fest, ob AOF aktiviert ist. Beachten Sie, dass mindestens eine AOF- oder RDB-Persistenz aktiviert sein kann.
aofFrequency	AofFrequency	Legt die Häufigkeit fest, mit der Daten auf den Datenträger geschrieben werden. Der Standardwert ist "1s", d. h. "jede Sekunde". Beachten Sie, dass die Einstellung "immer" aufgrund ihrer Leistungseinbußen veraltet ist.
rdbEnabled	boolean	Legt fest, ob RDB aktiviert ist. Beachten Sie, dass mindestens eine AOF- oder RDB-Persistenz aktiviert sein kann.
rdbFrequency	RdbFrequency	Legt die Häufigkeit fest, mit der eine Momentaufnahme der Datenbank erstellt wird.

Protocol

Enumeration

Gibt an, ob Redis-Clients eine Verbindung mit TLS-verschlüsselten oder Nur-Text-Redis-Protokollen herstellen können. Der Standardwert ist TLS-verschlüsselt.

Wert	Beschreibung
Encrypted
Plaintext

ProvisioningState

Enumeration

Aktueller Bereitstellungsstatus

Wert	Beschreibung
Succeeded
Failed
Canceled
Creating
Updating
Deleting

RdbFrequency

Enumeration

Legt die Häufigkeit fest, mit der eine Momentaufnahme der Datenbank erstellt wird.

Wert	Beschreibung
1h
6h
12h

ResourceState

Enumeration

Aktueller Ressourcenstatus

Wert	Beschreibung
Running
Creating
CreateFailed
Updating
UpdateFailed
Deleting
DeleteFailed
Enabling
EnableFailed
Disabling
DisableFailed
Disabled
Scaling
ScalingFailed
Moving

Freigeben über

Databases - Create

URI-Parameter

Anforderungstext

Antworten

Sicherheit

azure_auth

Bereiche

Beispiele

RedisEnterpriseDatabasesCreate

Beispielanforderung

Beispiel für eine Antwort

RedisEnterpriseDatabasesCreate No Cluster Cache

Beispielanforderung

Beispiel für eine Antwort

RedisEnterpriseDatabasesCreate With Active Geo Replication

Beispielanforderung

Beispiel für eine Antwort

Definitionen

accessKeysAuthentication

AofFrequency

ClusteringPolicy

Database

DeferUpgradeSetting

ErrorAdditionalInfo

ErrorDetail

ErrorResponse

EvictionPolicy

GeoReplication

LinkedDatabase

LinkState

Module

Persistence

Protocol

ProvisioningState

RdbFrequency

ResourceState