你当前正在访问 Microsoft Azure Global Edition 技术文档网站。如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

Redis Enterprise - Create

服务:: Redis Cache

API 版本:: 2025-07-01

创建或更新现有（覆盖/重新创建，可能会停机）缓存群集

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

URI 参数

名称	在	必需	类型	说明
clusterName	path	True	string pattern: ^(?=.{1,60}$)[A-Za-z0-9]+(-[A-Za-z0-9]+)*$	Redis Enterprise 群集的名称。名称长度必须为 1-60 个字符。允许的字符（A-Z、a-z、0-9）和连字符（-）。不能有前导和尾随和连续连字符
resourceGroupName	path	True	string minLength: 1 maxLength: 90	资源组的名称。此名称不区分大小写。
subscriptionId	path	True	string minLength: 1	目标订阅的 ID。
api-version	query	True	string minLength: 1	要用于此操作的 API 版本。

请求正文

名称	必需	类型	说明
location	True	string	资源所在的地理位置
properties.publicNetworkAccess	True	PublicNetworkAccess	公网流量是否可以访问Redis集群。只能设置“启用”或“禁用”。 null 仅对于使用旧 API 版本创建的集群返回，这些 API 版本没有此属性且无法设置。
sku	True	Sku	要创建的 SKU 会影响价格、性能和功能。
identity		ManagedServiceIdentity	资源的标识。
properties.encryption		Encryption	群集的静态加密配置。
properties.highAvailability		HighAvailability	默认启用。如果禁用 highAvailability，则不会复制数据集。这会影响可用性 SLA，并增加数据丢失的风险。
properties.minimumTlsVersion		TlsVersion	要支持的群集的最低 TLS 版本，例如“1.2”。将来可以添加较新版本。请注意，TLS 1.0 和 TLS 1.1 现已完全过时 -- 无法使用它们。仅为了与旧 API 版本保持一致，才提及它们。
tags		object	资源标记。
zones		string[]	将部署此群集的可用性区域。

响应

名称	类型	说明
200 OK	Cluster	集群正在更新。检查 provisioningState 和 resourceState 以查看详细状态。
201 Created	Cluster	正在创建集群。检查 provisioningState 和 resourceState 以查看详细状态。
Other Status Codes	ErrorResponse	描述作失败的原因的错误响应。

安全性

azure_auth

Azure Active Directory OAuth2 Flow。

类型: oauth2
流向: implicit
授权 URL: https://login.microsoftonline.com/common/oauth2/authorize

作用域

名称	说明
user_impersonation	模拟用户帐户

示例

RedisEnterpriseCreate

示例请求

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

{
  "location": "West US",
  "sku": {
    "name": "EnterpriseFlash_F300",
    "capacity": 3
  },
  "zones": [
    "1",
    "2",
    "3"
  ],
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": {}
    }
  },
  "properties": {
    "minimumTlsVersion": "1.2",
    "encryption": {
      "customerManagedKeyEncryption": {
        "keyEncryptionKeyIdentity": {
          "identityType": "userAssignedIdentity",
          "userAssignedIdentityResourceId": "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity"
        },
        "keyEncryptionKeyUrl": "https://your-kv.vault.azure.net/keys/your-key/your-key-version"
      }
    },
    "publicNetworkAccess": "Disabled"
  },
  "tags": {
    "tag1": "value1"
  }
}


import com.azure.resourcemanager.redisenterprise.models.ClusterPropertiesEncryption;
import com.azure.resourcemanager.redisenterprise.models.ClusterPropertiesEncryptionCustomerManagedKeyEncryption;
import com.azure.resourcemanager.redisenterprise.models.ClusterPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity;
import com.azure.resourcemanager.redisenterprise.models.CmkIdentityType;
import com.azure.resourcemanager.redisenterprise.models.ManagedServiceIdentity;
import com.azure.resourcemanager.redisenterprise.models.ManagedServiceIdentityType;
import com.azure.resourcemanager.redisenterprise.models.PublicNetworkAccess;
import com.azure.resourcemanager.redisenterprise.models.Sku;
import com.azure.resourcemanager.redisenterprise.models.SkuName;
import com.azure.resourcemanager.redisenterprise.models.TlsVersion;
import com.azure.resourcemanager.redisenterprise.models.UserAssignedIdentity;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for RedisEnterprise Create.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/
     * RedisEnterpriseCreate.json
     */
    /**
     * Sample code: RedisEnterpriseCreate.
     * 
     * @param manager Entry point to RedisEnterpriseManager.
     */
    public static void redisEnterpriseCreate(com.azure.resourcemanager.redisenterprise.RedisEnterpriseManager manager) {
        manager.redisEnterprises().define("cache1").withRegion("West US").withExistingResourceGroup("rg1")
            .withSku(new Sku().withName(SkuName.ENTERPRISE_FLASH_F300).withCapacity(3))
            .withTags(mapOf("tag1", "value1")).withZones(Arrays.asList("1", "2", "3"))
            .withIdentity(new ManagedServiceIdentity().withType(ManagedServiceIdentityType.USER_ASSIGNED)
                .withUserAssignedIdentities(mapOf(
                    "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity",
                    new UserAssignedIdentity())))
            .withPublicNetworkAccess(PublicNetworkAccess.DISABLED).withMinimumTlsVersion(TlsVersion.ONE_TWO)
            .withEncryption(new ClusterPropertiesEncryption().withCustomerManagedKeyEncryption(
                new ClusterPropertiesEncryptionCustomerManagedKeyEncryption().withKeyEncryptionKeyIdentity(
                    new ClusterPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity()
                        .withUserAssignedIdentityResourceId(
                            "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity")
                        .withIdentityType(CmkIdentityType.USER_ASSIGNED_IDENTITY))
                    .withKeyEncryptionKeyUrl("fakeTokenPlaceholder")))
            .create();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

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_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.redis_enterprise.begin_create(
        resource_group_name="rg1",
        cluster_name="cache1",
        parameters={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": {}
                },
            },
            "location": "West US",
            "properties": {
                "encryption": {
                    "customerManagedKeyEncryption": {
                        "keyEncryptionKeyIdentity": {
                            "identityType": "userAssignedIdentity",
                            "userAssignedIdentityResourceId": "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity",
                        },
                        "keyEncryptionKeyUrl": "https://your-kv.vault.azure.net/keys/your-key/your-key-version",
                    }
                },
                "minimumTlsVersion": "1.2",
                "publicNetworkAccess": "Disabled",
            },
            "sku": {"capacity": 3, "name": "EnterpriseFlash_F300"},
            "tags": {"tag1": "value1"},
            "zones": ["1", "2", "3"],
        },
    ).result()
    print(response)


# x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseCreate.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/RedisEnterpriseCreate.json
func ExampleClient_BeginCreate() {
	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.NewClient().BeginCreate(ctx, "rg1", "cache1", armredisenterprise.Cluster{
		Location: to.Ptr("West US"),
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
		},
		Identity: &armredisenterprise.ManagedServiceIdentity{
			Type: to.Ptr(armredisenterprise.ManagedServiceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armredisenterprise.UserAssignedIdentity{
				"/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": {},
			},
		},
		Properties: &armredisenterprise.ClusterCreateProperties{
			Encryption: &armredisenterprise.ClusterCommonPropertiesEncryption{
				CustomerManagedKeyEncryption: &armredisenterprise.ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryption{
					KeyEncryptionKeyIdentity: &armredisenterprise.ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity{
						IdentityType:                   to.Ptr(armredisenterprise.CmkIdentityTypeUserAssignedIdentity),
						UserAssignedIdentityResourceID: to.Ptr("/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity"),
					},
					KeyEncryptionKeyURL: to.Ptr("https://your-kv.vault.azure.net/keys/your-key/your-key-version"),
				},
			},
			MinimumTLSVersion:   to.Ptr(armredisenterprise.TLSVersionOne2),
			PublicNetworkAccess: to.Ptr(armredisenterprise.PublicNetworkAccessDisabled),
		},
		SKU: &armredisenterprise.SKU{
			Name:     to.Ptr(armredisenterprise.SKUNameEnterpriseFlashF300),
			Capacity: to.Ptr[int32](3),
		},
		Zones: []*string{
			to.Ptr("1"),
			to.Ptr("2"),
			to.Ptr("3")},
	}, 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.Cluster = armredisenterprise.Cluster{
	// 	Name: to.Ptr("cache1"),
	// 	Type: to.Ptr("Microsoft.Cache/redisEnterprise"),
	// 	ID: to.Ptr("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1"),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 		"tag1": to.Ptr("value1"),
	// 	},
	// 	Identity: &armredisenterprise.ManagedServiceIdentity{
	// 		Type: to.Ptr(armredisenterprise.ManagedServiceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armredisenterprise.UserAssignedIdentity{
	// 			"/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": &armredisenterprise.UserAssignedIdentity{
	// 				ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 		},
	// 	},
	// 	Kind: to.Ptr(armredisenterprise.KindV1),
	// 	Properties: &armredisenterprise.ClusterCreateProperties{
	// 		HostName: to.Ptr("cache1.westus.something.azure.net"),
	// 		MinimumTLSVersion: to.Ptr(armredisenterprise.TLSVersionOne2),
	// 		ProvisioningState: to.Ptr(armredisenterprise.ProvisioningStateSucceeded),
	// 		RedisVersion: to.Ptr("5"),
	// 		ResourceState: to.Ptr(armredisenterprise.ResourceStateRunning),
	// 		PublicNetworkAccess: to.Ptr(armredisenterprise.PublicNetworkAccessDisabled),
	// 	},
	// 	SKU: &armredisenterprise.SKU{
	// 		Name: to.Ptr(armredisenterprise.SKUNameEnterpriseFlashF300),
	// 		Capacity: to.Ptr[int32](3),
	// 	},
	// 	Zones: []*string{
	// 		to.Ptr("1"),
	// 		to.Ptr("2"),
	// 		to.Ptr("3")},
	// 	}
}

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 or updates an existing (overwrite/recreate, with potential downtime) cache cluster
 *
 * @summary Creates or updates an existing (overwrite/recreate, with potential downtime) cache cluster
 * x-ms-original-file: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseCreate.json
 */
async function redisEnterpriseCreate() {
  const subscriptionId =
    process.env["REDISENTERPRISE_SUBSCRIPTION_ID"] || "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
  const resourceGroupName = process.env["REDISENTERPRISE_RESOURCE_GROUP"] || "rg1";
  const clusterName = "cache1";
  const parameters = {
    encryption: {
      customerManagedKeyEncryption: {
        keyEncryptionKeyIdentity: {
          identityType: "userAssignedIdentity",
          userAssignedIdentityResourceId:
            "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity",
        },
        keyEncryptionKeyUrl: "https://your-kv.vault.azure.net/keys/your-key/your-key-version",
      },
    },
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/yourSubscription/resourceGroups/yourRg/providers/MicrosoftManagedIdentity/userAssignedIdentities/yourIdentity":
          {},
      },
    },
    location: "West US",
    minimumTlsVersion: "1.2",
    publicNetworkAccess: "Disabled",
    sku: { name: "EnterpriseFlash_F300", capacity: 3 },
    tags: { tag1: "value1" },
    zones: ["1", "2", "3"],
  };
  const credential = new DefaultAzureCredential();
  const client = new RedisEnterpriseManagementClient(credential, subscriptionId);
  const result = await client.redisEnterprise.beginCreateAndWait(
    resourceGroupName,
    clusterName,
    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.Models;
using Azure.ResourceManager.RedisEnterprise.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.RedisEnterprise;

// Generated from example definition: specification/redisenterprise/resource-manager/Microsoft.Cache/RedisEnterprise/stable/2025-07-01/examples/RedisEnterpriseCreate.json
// this example is just showing the usage of "RedisEnterprise_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://dori-uw-1.kuma-moon.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 ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f";
string resourceGroupName = "rg1";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this RedisEnterpriseClusterResource
RedisEnterpriseClusterCollection collection = resourceGroupResource.GetRedisEnterpriseClusters();

// invoke the operation
string clusterName = "cache1";
RedisEnterpriseClusterData data = new RedisEnterpriseClusterData(new AzureLocation("West US"), new RedisEnterpriseSku(RedisEnterpriseSkuName.EnterpriseFlashF300)
{
    Capacity = 3,
})
{
    Zones = { "1", "2", "3" },
    Identity = new ManagedServiceIdentity("UserAssigned")
    {
        UserAssignedIdentities =
        {
        [new ResourceIdentifier("/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity")] = new UserAssignedIdentity()
        },
    },
    MinimumTlsVersion = RedisEnterpriseTlsVersion.Tls1_2,
    CustomerManagedKeyEncryption = new RedisEnterpriseCustomerManagedKeyEncryption
    {
        KeyEncryptionKeyIdentity = new RedisEnterpriseCustomerManagedKeyEncryptionKeyIdentity
        {
            UserAssignedIdentityResourceId = new ResourceIdentifier("/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity"),
            IdentityType = RedisEnterpriseCustomerManagedKeyIdentityType.UserAssignedIdentity,
        },
        KeyEncryptionKeyUri = new Uri("https://your-kv.vault.azure.net/keys/your-key/your-key-version"),
    },
    PublicNetworkAccess = RedisEnterprisePublicNetworkAccess.Disabled,
    Tags =
    {
    ["tag1"] = "value1"
    },
};
ArmOperation<RedisEnterpriseClusterResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, clusterName, data);
RedisEnterpriseClusterResource 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
RedisEnterpriseClusterData 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

示例响应

状态代码:: 201

{
  "name": "cache1",
  "type": "Microsoft.Cache/redisEnterprise",
  "id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1",
  "location": "West US",
  "kind": "v1",
  "sku": {
    "name": "EnterpriseFlash_F300",
    "capacity": 3
  },
  "zones": [
    "1",
    "2",
    "3"
  ],
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": {
        "principalId": "00000000-0000-0000-0000-000000000000",
        "clientId": "00000000-0000-0000-0000-000000000000"
      }
    }
  },
  "properties": {
    "provisioningState": "Creating",
    "resourceState": "Creating",
    "hostName": "cache1.westus.something.azure.net",
    "redisVersion": "5",
    "minimumTlsVersion": "1.2",
    "publicNetworkAccess": "Disabled",
    "encryption": {
      "customerManagedKeyEncryption": {
        "keyEncryptionKeyIdentity": {
          "userAssignedIdentityResourceId": "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity",
          "identityType": "userAssignedIdentity"
        },
        "keyEncryptionKeyUrl": "https://your-kv.vault.azure.net/keys/your-key/your-key-version"
      }
    }
  },
  "tags": {
    "tag1": "value1"
  }
}

状态代码:: 200

{
  "name": "cache1",
  "type": "Microsoft.Cache/redisEnterprise",
  "id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1",
  "location": "West US",
  "kind": "v1",
  "sku": {
    "name": "EnterpriseFlash_F300",
    "capacity": 3
  },
  "zones": [
    "1",
    "2",
    "3"
  ],
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/your-subscription/resourceGroups/your-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/your-identity": {
        "principalId": "00000000-0000-0000-0000-000000000000",
        "clientId": "00000000-0000-0000-0000-000000000000"
      }
    }
  },
  "properties": {
    "provisioningState": "Succeeded",
    "resourceState": "Running",
    "hostName": "cache1.westus.something.azure.net",
    "redisVersion": "5",
    "minimumTlsVersion": "1.2",
    "publicNetworkAccess": "Disabled"
  },
  "tags": {
    "tag1": "value1"
  }
}

定义

名称	说明
Cluster	描述 Redis Enterprise 集群
CmkIdentityType	此 API 版本仅支持 userAssignedIdentity;将来可能支持其他类型的
CustomerManagedKeyEncryption	资源的所有客户管理的密钥加密属性。将此设置为空对象，以使用Microsoft管理的密钥加密。
Encryption	群集的静态加密配置。
ErrorAdditionalInfo	资源管理错误附加信息。
ErrorDetail	错误详细信息。
ErrorResponse	错误响应
HighAvailability	默认启用。如果禁用 highAvailability，则不会复制数据集。这会影响可用性 SLA，并增加数据丢失的风险。
KeyEncryptionKeyIdentity	客户管理的密钥设置的所有标识配置，用于定义应用于向 Key Vault 进行身份验证的标识。
Kind	区分集群的类型。只读。
ManagedServiceIdentity	托管服务标识（系统分配和/或用户分配的标识）
ManagedServiceIdentityType	托管服务标识的类型（其中允许 SystemAssigned 和 UserAssigned 类型）。
PrivateEndpoint	专用终结点资源。
PrivateEndpointConnection	专用终结点连接资源。
PrivateEndpointConnectionProvisioningState	当前预配状态。
PrivateEndpointServiceConnectionStatus	专用终结点连接状态。
PrivateLinkServiceConnectionState	有关服务使用者与提供程序之间的连接状态的信息集合。
ProvisioningState	当前预配状态
PublicNetworkAccess	公网流量是否可以访问Redis集群。只能设置“启用”或“禁用”。 null 仅对于使用旧 API 版本创建的集群返回，这些 API 版本没有此属性且无法设置。
RedundancyMode	说明群集的当前冗余策略，该策略会影响预期的 SLA。
ResourceState	当前资源状态
Sku	SKU 参数提供给创建 Redis Enterprise 集群作。
SkuName	要部署的 Redis Enterprise 群集级别。可能的值：（“Balanced_B5”、“MemoryOptimized_M10”、“ComputeOptimized_X5”等）。有关 SKU 的详细信息，请参阅最新的定价文档。请注意，将来可能会支持其他 SKU。
TlsVersion	要支持的群集的最低 TLS 版本，例如“1.2”。将来可以添加较新版本。请注意，TLS 1.0 和 TLS 1.1 现已完全过时 -- 无法使用它们。仅为了与旧 API 版本保持一致，才提及它们。
UserAssignedIdentity	用户分配的标识属性

Cluster

对象

描述 Redis Enterprise 集群

名称	类型	说明
id	string	资源的完全限定资源 ID。示例 - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
identity	ManagedServiceIdentity	资源的标识。
kind	Kind	区分集群的类型。只读。
location	string	资源所在的地理位置
name	string	资源的名称
properties.encryption	Encryption	群集的静态加密配置。
properties.highAvailability	HighAvailability	默认启用。如果禁用 highAvailability，则不会复制数据集。这会影响可用性 SLA，并增加数据丢失的风险。
properties.hostName	string	集群终结点的 DNS 名称
properties.minimumTlsVersion	TlsVersion	要支持的群集的最低 TLS 版本，例如“1.2”。将来可以添加较新版本。请注意，TLS 1.0 和 TLS 1.1 现已完全过时 -- 无法使用它们。仅为了与旧 API 版本保持一致，才提及它们。
properties.privateEndpointConnections	PrivateEndpointConnection[]	与指定的 Redis Enterprise 群集关联的专用终结点连接列表
properties.provisioningState	ProvisioningState	群集的当前预配状态
properties.publicNetworkAccess	PublicNetworkAccess	公网流量是否可以访问Redis集群。只能设置“启用”或“禁用”。 null 仅对于使用旧 API 版本创建的集群返回，这些 API 版本没有此属性且无法设置。
properties.redisVersion	string	集群支持的 redis 版本，例如 '6'
properties.redundancyMode	RedundancyMode	说明群集的当前冗余策略，该策略会影响预期的 SLA。
properties.resourceState	ResourceState	集群的当前资源状态
sku	Sku	要创建的 SKU 会影响价格、性能和功能。
tags	object	资源标记。
type	string	资源类型。例如“Microsoft.Compute/virtualMachines”或“Microsoft.Storage/storageAccounts”
zones	string[]	将部署此群集的可用性区域。

CmkIdentityType

枚举

此 API 版本仅支持 userAssignedIdentity;将来可能支持其他类型的

值	说明
systemAssignedIdentity
userAssignedIdentity

CustomerManagedKeyEncryption

对象

资源的所有客户管理的密钥加密属性。将此设置为空对象，以使用Microsoft管理的密钥加密。

名称	类型	说明
keyEncryptionKeyIdentity	KeyEncryptionKeyIdentity	客户管理的密钥设置的所有标识配置，用于定义应用于向 Key Vault 进行身份验证的标识。
keyEncryptionKeyUrl	string	密钥加密密钥 URL，仅版本控制。例如： `https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78`

Encryption

对象

群集的静态加密配置。

名称	类型	说明
customerManagedKeyEncryption	CustomerManagedKeyEncryption	资源的所有客户管理的密钥加密属性。将此设置为空对象，以使用Microsoft管理的密钥加密。

ErrorAdditionalInfo

对象

资源管理错误附加信息。

名称	类型	说明
info	object	其他信息。
type	string	其他信息类型。

ErrorDetail

对象

错误详细信息。

名称	类型	说明
additionalInfo	ErrorAdditionalInfo[]	错误附加信息。
code	string	错误代码。
details	ErrorDetail[]	错误详细信息。
message	string	错误消息。
target	string	错误目标。

ErrorResponse

对象

错误响应

名称	类型	说明
error	ErrorDetail	错误对象。

HighAvailability

枚举

默认启用。如果禁用 highAvailability，则不会复制数据集。这会影响可用性 SLA，并增加数据丢失的风险。

值	说明
Enabled
Disabled

KeyEncryptionKeyIdentity

对象

客户管理的密钥设置的所有标识配置，用于定义应用于向 Key Vault 进行身份验证的标识。

名称	类型	说明
identityType	CmkIdentityType	此 API 版本仅支持 userAssignedIdentity;将来可能支持其他类型的
userAssignedIdentityResourceId	string	用户分配的标识用于访问密钥加密密钥 URL。例如：/subscriptions/_{/resourceGroups/<resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId。}

Kind

枚举

区分集群的类型。只读。

值	说明
v1
v2

ManagedServiceIdentity

对象

托管服务标识（系统分配和/或用户分配的标识）

名称	类型	说明
principalId	string (uuid)	系统分配标识的服务主体 ID。此属性仅针对系统分配的标识提供。
tenantId	string (uuid)	系统分配标识的租户 ID。此属性仅针对系统分配的标识提供。
type	ManagedServiceIdentityType	托管服务标识的类型（其中允许 SystemAssigned 和 UserAssigned 类型）。
userAssignedIdentities	<string, UserAssignedIdentity>	User-Assigned 标识与资源关联的用户分配标识集。 userAssignedIdentities 字典密钥将为 ARM 资源 ID，格式为“/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}”。字典值可以是请求中的空对象（{}）。

ManagedServiceIdentityType

枚举

托管服务标识的类型（其中允许 SystemAssigned 和 UserAssigned 类型）。

值	说明
None
SystemAssigned
UserAssigned
SystemAssigned, UserAssigned

PrivateEndpoint

对象

专用终结点资源。

名称	类型	说明
id	string	专用终结点的 ARM 标识符

PrivateEndpointConnection

对象

专用终结点连接资源。

名称	类型	说明
id	string	资源的完全限定资源 ID。示例 - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string	资源的名称
properties.privateEndpoint	PrivateEndpoint	专用终结点的资源。
properties.privateLinkServiceConnectionState	PrivateLinkServiceConnectionState	有关服务使用者与提供程序之间的连接状态的信息集合。
properties.provisioningState	PrivateEndpointConnectionProvisioningState	专用终结点连接资源的预配状态。
type	string	资源类型。例如“Microsoft.Compute/virtualMachines”或“Microsoft.Storage/storageAccounts”

PrivateEndpointConnectionProvisioningState

枚举

当前预配状态。

值	说明
Succeeded
Creating
Deleting
Failed

PrivateEndpointServiceConnectionStatus

枚举

专用终结点连接状态。

值	说明
Pending
Approved
Rejected

PrivateLinkServiceConnectionState

对象

有关服务使用者与提供程序之间的连接状态的信息集合。

名称	类型	说明
actionsRequired	string	一条消息，指示服务提供商上的更改是否需要对使用者进行任何更新。
description	string	批准/拒绝连接的原因。
status	PrivateEndpointServiceConnectionStatus	指示连接是否已被服务的所有者批准/拒绝/删除。

ProvisioningState

枚举

当前预配状态

值	说明
Succeeded
Failed
Canceled
Creating
Updating
Deleting

PublicNetworkAccess

枚举

公网流量是否可以访问Redis集群。只能设置“启用”或“禁用”。 null 仅对于使用旧 API 版本创建的集群返回，这些 API 版本没有此属性且无法设置。

值	说明
Enabled
Disabled

RedundancyMode

枚举

说明群集的当前冗余策略，该策略会影响预期的 SLA。

值	说明
None	没有冗余。将发生可用性损失。
LR	具有高可用性的本地冗余。
ZR	区域冗余。更高的可用性。

ResourceState

枚举

当前资源状态

值	说明
Running
Creating
CreateFailed
Updating
UpdateFailed
Deleting
DeleteFailed
Enabling
EnableFailed
Disabling
DisableFailed
Disabled
Scaling
ScalingFailed
Moving

Sku

对象

SKU 参数提供给创建 Redis Enterprise 集群作。

名称	类型	说明
capacity	integer (int32)	此属性仅用于 Enterprise 和 EnterpriseFlash SKU。确定群集的大小。企业 SKU 的有效值为（2、4、6、...），对于 EnterpriseFlash SKU，有效值为（3、9、15、...）。
name	SkuName	要部署的 Redis Enterprise 群集级别。可能的值：（“Balanced_B5”、“MemoryOptimized_M10”、“ComputeOptimized_X5”等）。有关 SKU 的详细信息，请参阅最新的定价文档。请注意，将来可能会支持其他 SKU。

SkuName

枚举

要部署的 Redis Enterprise 群集级别。可能的值：（“Balanced_B5”、“MemoryOptimized_M10”、“ComputeOptimized_X5”等）。有关 SKU 的详细信息，请参阅最新的定价文档。请注意，将来可能会支持其他 SKU。

值	说明
Enterprise_E1
Enterprise_E5
Enterprise_E10
Enterprise_E20
Enterprise_E50
Enterprise_E100
Enterprise_E200
Enterprise_E400
EnterpriseFlash_F300
EnterpriseFlash_F700
EnterpriseFlash_F1500
Balanced_B0
Balanced_B1
Balanced_B3
Balanced_B5
Balanced_B10
Balanced_B20
Balanced_B50
Balanced_B100
Balanced_B150
Balanced_B250
Balanced_B350
Balanced_B500
Balanced_B700
Balanced_B1000
MemoryOptimized_M10
MemoryOptimized_M20
MemoryOptimized_M50
MemoryOptimized_M100
MemoryOptimized_M150
MemoryOptimized_M250
MemoryOptimized_M350
MemoryOptimized_M500
MemoryOptimized_M700
MemoryOptimized_M1000
MemoryOptimized_M1500
MemoryOptimized_M2000
ComputeOptimized_X3
ComputeOptimized_X5
ComputeOptimized_X10
ComputeOptimized_X20
ComputeOptimized_X50
ComputeOptimized_X100
ComputeOptimized_X150
ComputeOptimized_X250
ComputeOptimized_X350
ComputeOptimized_X500
ComputeOptimized_X700
FlashOptimized_A250
FlashOptimized_A500
FlashOptimized_A700
FlashOptimized_A1000
FlashOptimized_A1500
FlashOptimized_A2000
FlashOptimized_A4500

TlsVersion

枚举

要支持的群集的最低 TLS 版本，例如“1.2”。将来可以添加较新版本。请注意，TLS 1.0 和 TLS 1.1 现已完全过时 -- 无法使用它们。仅为了与旧 API 版本保持一致，才提及它们。

值	说明
1.0
1.1
1.2

UserAssignedIdentity

对象

用户分配的标识属性

名称	类型	说明
clientId	string (uuid)	分配的标识的客户端 ID。
principalId	string (uuid)	已分配标识的主体 ID。