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 參數

名稱	位於	必要	類型	Description
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	目標訂用帳戶的標識碼。
api-version	query	True	string minLength: 1	用於此作業的 API 版本。

要求本文

名稱	必要	類型	Description
location	True	string	資源所在的地理位置
properties.publicNetworkAccess	True	PublicNetworkAccess	公用網路流量是否可以存取Redis叢集。只能設定「啟用」或「停用」。 null 只會針對使用舊 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[]	將部署此叢集的可用性區域。

回應

名稱	類型	Description
200 OK	Cluster	叢集正在更新。檢查 provisioningState 和 resourceState 以查看詳細狀態。
201 Created	Cluster	叢集正在建立中。檢查 provisioningState 和 resourceState 以查看詳細狀態。
Other Status Codes	ErrorResponse	說明作業為何失敗的錯誤回應。

安全性

azure_auth

Azure Active Directory OAuth2 Flow。

類型: oauth2
Flow: implicit
授權 URL: https://login.microsoftonline.com/common/oauth2/authorize

範圍

名稱	Description
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://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 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"
  }
}

定義

名稱	Description
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 版本建立的叢集傳回，這些叢集沒有此內容且無法設定。
RedundancyMode	說明叢集目前的備援策略，這會影響預期的 SLA。
ResourceState	目前的資源狀態
Sku	SKU 參數提供給建立 Redis Enterprise 叢集作業。
SkuName	要部署的 Redis 企業叢集層級。可能的值：（『Balanced_B5』、『MemoryOptimized_M10』、『ComputeOptimized_X5』等等）。如需 SKU 的詳細資訊，請參閱最新的定價檔。請注意，未來可能會支援其他 SKU。
TlsVersion	叢集支援的最低 TLS 版本，例如『1.2』。未來可以新增較新版本。請注意，TLS 1.0 和 TLS 1.1 現在已完全過時，您無法使用它們。只有為了與舊版 API 的一致性，才會提及它們。
UserAssignedIdentity	使用者指派的身分識別屬性

Cluster

Object

描述 Redis Enterprise 叢集

名稱	類型	Description
id	string	資源的完整資源標識碼。例如 - /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 版本建立的叢集傳回，這些叢集沒有此內容且無法設定。
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;未來可能支援其他類型

值	Description
systemAssignedIdentity
userAssignedIdentity

CustomerManagedKeyEncryption

Object

資源的所有客戶自控金鑰加密屬性。將此設定為空白物件，以使用Microsoft管理的金鑰加密。

名稱	類型	Description
keyEncryptionKeyIdentity	KeyEncryptionKeyIdentity	客戶管理的金鑰設定的所有身分識別組態，定義應用來驗證 Key Vault 的身分識別。
keyEncryptionKeyUrl	string	金鑰加密金鑰 URL，僅限版本。前任： `https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78`

Encryption

Object

叢集的待用加密組態。

名稱	類型	Description
customerManagedKeyEncryption	CustomerManagedKeyEncryption	資源的所有客戶自控金鑰加密屬性。將此設定為空白物件，以使用Microsoft管理的金鑰加密。

ErrorAdditionalInfo

Object

資源管理錯誤其他資訊。

名稱	類型	Description
info	object	其他資訊。
type	string	其他信息類型。

ErrorDetail

Object

錯誤詳細數據。

名稱	類型	Description
additionalInfo	ErrorAdditionalInfo[]	錯誤其他資訊。
code	string	錯誤碼。
details	ErrorDetail[]	錯誤詳細數據。
message	string	錯誤訊息。
target	string	錯誤目標。

ErrorResponse

Object

錯誤回應

名稱	類型	Description
error	ErrorDetail	error 物件。

HighAvailability

列舉型別

默認為啟用。如果 highAvailability 已停用，則不會復寫數據集。這會影響可用性 SLA，並增加資料遺失的風險。

值	Description
Enabled
Disabled

KeyEncryptionKeyIdentity

Object

客戶管理的金鑰設定的所有身分識別組態，定義應用來驗證 Key Vault 的身分識別。

名稱	類型	Description
identityType	CmkIdentityType	此 API 版本僅支援 userAssignedIdentity;未來可能支援其他類型
userAssignedIdentityResourceId	string	使用者指派的身分識別可用來存取金鑰加密金鑰 URL。例如：/subscriptions/_{/resourceGroups/<resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId。}

Kind

列舉型別

區分叢集的類型。唯讀。

值	Description
v1
v2

ManagedServiceIdentity

Object

受控服務識別（系統指派和/或使用者指派的身分識別）

名稱	類型	Description
principalId	string (uuid)	系統指派身分識別的服務主體標識碼。此屬性只會針對系統指派的身分識別提供。
tenantId	string (uuid)	系統指派身分識別的租用戶標識碼。此屬性只會針對系統指派的身分識別提供。
type	ManagedServiceIdentityType	受控服務識別的類型（允許 SystemAssigned 和 UserAssigned 類型）。
userAssignedIdentities	<string, UserAssignedIdentity>	User-Assigned 身分識別與資源相關聯的使用者指派身分識別集。 userAssignedIdentities 字典索引鍵的格式為 ARM 資源標識符：'/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}。字典值可以是要求中的空白物件（{}）。

ManagedServiceIdentityType

列舉型別

受控服務識別的類型（允許 SystemAssigned 和 UserAssigned 類型）。

值	Description
None
SystemAssigned
UserAssigned
SystemAssigned, UserAssigned

PrivateEndpoint

Object

私人端點資源。

名稱	類型	Description
id	string	私人端點的 ARM 識別碼

PrivateEndpointConnection

Object

私人端點聯機資源。

名稱	類型	Description
id	string	資源的完整資源標識碼。例如 - /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

列舉型別

目前的布建狀態。

值	Description
Succeeded
Creating
Deleting
Failed

PrivateEndpointServiceConnectionStatus

列舉型別

私人端點連線狀態。

值	Description
Pending
Approved
Rejected

PrivateLinkServiceConnectionState

Object

服務取用者與提供者之間連線狀態的相關信息集合。

名稱	類型	Description
actionsRequired	string	訊息，指出服務提供者上的變更是否需要取用者的任何更新。
description	string	核准/拒絕連線的原因。
status	PrivateEndpointServiceConnectionStatus	指出服務擁有者是否已核准/拒絕/移除連線。

ProvisioningState

列舉型別

目前的佈建狀態

值	Description
Succeeded
Failed
Canceled
Creating
Updating
Deleting

PublicNetworkAccess

列舉型別

公用網路流量是否可以存取Redis叢集。只能設定「啟用」或「停用」。 null 只會針對使用舊 API 版本建立的叢集傳回，這些叢集沒有此內容且無法設定。

值	Description
Enabled
Disabled

RedundancyMode

列舉型別

說明叢集目前的備援策略，這會影響預期的 SLA。

值	Description
None	沒有冗餘。將會發生可用性遺失。
LR	具有高可用性的本地備援。
ZR	區域冗餘。更高的可用性。

ResourceState

列舉型別

目前的資源狀態

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

Sku

Object

SKU 參數提供給建立 Redis Enterprise 叢集作業。

名稱	類型	Description
capacity	integer (int32)	此屬性僅與 Enterprise 和 EnterpriseFlash SKU 搭配使用。決定叢集的大小。企業 SKU 的有效值為（2、4、6、...）和 EnterpriseFlash SKU 的有效值為（3、9、15...）。
name	SkuName	要部署的 Redis 企業叢集層級。可能的值：（『Balanced_B5』、『MemoryOptimized_M10』、『ComputeOptimized_X5』等等）。如需 SKU 的詳細資訊，請參閱最新的定價檔。請注意，未來可能會支援其他 SKU。

SkuName

列舉型別

要部署的 Redis 企業叢集層級。可能的值：（『Balanced_B5』、『MemoryOptimized_M10』、『ComputeOptimized_X5』等等）。如需 SKU 的詳細資訊，請參閱最新的定價檔。請注意，未來可能會支援其他 SKU。

值	Description
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 的一致性，才會提及它們。

值	Description
1.0
1.1
1.2

UserAssignedIdentity

Object

使用者指派的身分識別屬性

名稱	類型	Description
clientId	string (uuid)	指派之身分識別的用戶端標識碼。
principalId	string (uuid)	指派之身分識別的主體標識碼。