1. Packages
  2. Azure Classic
  3. API Docs
  4. managedredis
  5. ManagedRedis

We recommend using Azure Native.

Azure v6.30.0 published on Thursday, Nov 20, 2025 by Pulumi
Schema (JSON)
pulumi/pulumi-azure

azure.managedredis.ManagedRedis

azure logo

We recommend using Azure Native.

Azure v6.30.0 published on Thursday, Nov 20, 2025 by Pulumi
Schema (JSON)
pulumi/pulumi-azure

    Manages a Managed Redis. This resource supersedes azure.redis.EnterpriseCluster and azure.redis.EnterpriseDatabase resources. Please refer to the migration guide for more information on migrating from Redis Enterprise to Managed Redis: Migrating from Redis Enterprise to Managed Redis.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleManagedRedis = new azure.managedredis.ManagedRedis("example", {
    name: "example-managed-redis",
    resourceGroupName: example.name,
    location: example.location,
    skuName: "Balanced_B3",
    defaultDatabase: {
        geoReplicationGroupName: "myGeoGroup",
    },
});

    import pulumi
import pulumi_azure as azure

example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_managed_redis = azure.managedredis.ManagedRedis("example",
    name="example-managed-redis",
    resource_group_name=example.name,
    location=example.location,
    sku_name="Balanced_B3",
    default_database={
        "geo_replication_group_name": "myGeoGroup",
    })

    package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/managedredis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		_, err = managedredis.NewManagedRedis(ctx, "example", &managedredis.ManagedRedisArgs{
			Name:              pulumi.String("example-managed-redis"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			SkuName:           pulumi.String("Balanced_B3"),
			DefaultDatabase: &managedredis.ManagedRedisDefaultDatabaseArgs{
				GeoReplicationGroupName: pulumi.String("myGeoGroup"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });

    var exampleManagedRedis = new Azure.ManagedRedis.ManagedRedis("example", new()
    {
        Name = "example-managed-redis",
        ResourceGroupName = example.Name,
        Location = example.Location,
        SkuName = "Balanced_B3",
        DefaultDatabase = new Azure.ManagedRedis.Inputs.ManagedRedisDefaultDatabaseArgs
        {
            GeoReplicationGroupName = "myGeoGroup",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.managedredis.ManagedRedis;
import com.pulumi.azure.managedredis.ManagedRedisArgs;
import com.pulumi.azure.managedredis.inputs.ManagedRedisDefaultDatabaseArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());

        var exampleManagedRedis = new ManagedRedis("exampleManagedRedis", ManagedRedisArgs.builder()
            .name("example-managed-redis")
            .resourceGroupName(example.name())
            .location(example.location())
            .skuName("Balanced_B3")
            .defaultDatabase(ManagedRedisDefaultDatabaseArgs.builder()
                .geoReplicationGroupName("myGeoGroup")
                .build())
            .build());

    }
}

    resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleManagedRedis:
    type: azure:managedredis:ManagedRedis
    name: example
    properties:
      name: example-managed-redis
      resourceGroupName: ${example.name}
      location: ${example.location}
      skuName: Balanced_B3
      defaultDatabase:
        geoReplicationGroupName: myGeoGroup

    With Customer Managed Key

    import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const current = azure.core.getClientConfig({});
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleUserAssignedIdentity = new azure.authorization.UserAssignedIdentity("example", {
    name: "example",
    resourceGroupName: example.name,
    location: example.location,
});
const exampleKeyVault = new azure.keyvault.KeyVault("example", {
    name: "example",
    location: example.location,
    resourceGroupName: example.name,
    tenantId: current.then(current => current.tenantId),
    skuName: "standard",
    purgeProtectionEnabled: true,
    accessPolicies: [
        {
            tenantId: current.then(current => current.tenantId),
            objectId: current.then(current => current.objectId),
            keyPermissions: [
                "Create",
                "Delete",
                "Get",
                "List",
                "Purge",
                "Recover",
                "Update",
                "GetRotationPolicy",
                "SetRotationPolicy",
            ],
        },
        {
            tenantId: current.then(current => current.tenantId),
            objectId: exampleUserAssignedIdentity.principalId,
            keyPermissions: [
                "Get",
                "WrapKey",
                "UnwrapKey",
            ],
        },
    ],
});
const exampleKey = new azure.keyvault.Key("example", {
    name: "managedrediscmk",
    keyVaultId: exampleKeyVault.id,
    keyType: "RSA",
    keySize: 2048,
    keyOpts: [
        "unwrapKey",
        "wrapKey",
    ],
});
const exampleManagedRedis = new azure.managedredis.ManagedRedis("example", {
    name: "example-managed-redis",
    resourceGroupName: example.name,
    location: example.location,
    skuName: "Balanced_B3",
    identity: {
        type: "UserAssigned",
        identityIds: [exampleUserAssignedIdentity.id],
    },
    customerManagedKey: {
        keyVaultKeyId: exampleKey.id,
        userAssignedIdentityId: exampleUserAssignedIdentity.id,
    },
    defaultDatabase: {
        geoReplicationGroupName: "myGeoGroup",
    },
});

    import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_user_assigned_identity = azure.authorization.UserAssignedIdentity("example",
    name="example",
    resource_group_name=example.name,
    location=example.location)
example_key_vault = azure.keyvault.KeyVault("example",
    name="example",
    location=example.location,
    resource_group_name=example.name,
    tenant_id=current.tenant_id,
    sku_name="standard",
    purge_protection_enabled=True,
    access_policies=[
        {
            "tenant_id": current.tenant_id,
            "object_id": current.object_id,
            "key_permissions": [
                "Create",
                "Delete",
                "Get",
                "List",
                "Purge",
                "Recover",
                "Update",
                "GetRotationPolicy",
                "SetRotationPolicy",
            ],
        },
        {
            "tenant_id": current.tenant_id,
            "object_id": example_user_assigned_identity.principal_id,
            "key_permissions": [
                "Get",
                "WrapKey",
                "UnwrapKey",
            ],
        },
    ])
example_key = azure.keyvault.Key("example",
    name="managedrediscmk",
    key_vault_id=example_key_vault.id,
    key_type="RSA",
    key_size=2048,
    key_opts=[
        "unwrapKey",
        "wrapKey",
    ])
example_managed_redis = azure.managedredis.ManagedRedis("example",
    name="example-managed-redis",
    resource_group_name=example.name,
    location=example.location,
    sku_name="Balanced_B3",
    identity={
        "type": "UserAssigned",
        "identity_ids": [example_user_assigned_identity.id],
    },
    customer_managed_key={
        "key_vault_key_id": example_key.id,
        "user_assigned_identity_id": example_user_assigned_identity.id,
    },
    default_database={
        "geo_replication_group_name": "myGeoGroup",
    })

    package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/keyvault"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/managedredis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := core.GetClientConfig(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleUserAssignedIdentity, err := authorization.NewUserAssignedIdentity(ctx, "example", &authorization.UserAssignedIdentityArgs{
			Name:              pulumi.String("example"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
		})
		if err != nil {
			return err
		}
		exampleKeyVault, err := keyvault.NewKeyVault(ctx, "example", &keyvault.KeyVaultArgs{
			Name:                   pulumi.String("example"),
			Location:               example.Location,
			ResourceGroupName:      example.Name,
			TenantId:               pulumi.String(current.TenantId),
			SkuName:                pulumi.String("standard"),
			PurgeProtectionEnabled: pulumi.Bool(true),
			AccessPolicies: keyvault.KeyVaultAccessPolicyArray{
				&keyvault.KeyVaultAccessPolicyArgs{
					TenantId: pulumi.String(current.TenantId),
					ObjectId: pulumi.String(current.ObjectId),
					KeyPermissions: pulumi.StringArray{
						pulumi.String("Create"),
						pulumi.String("Delete"),
						pulumi.String("Get"),
						pulumi.String("List"),
						pulumi.String("Purge"),
						pulumi.String("Recover"),
						pulumi.String("Update"),
						pulumi.String("GetRotationPolicy"),
						pulumi.String("SetRotationPolicy"),
					},
				},
				&keyvault.KeyVaultAccessPolicyArgs{
					TenantId: pulumi.String(current.TenantId),
					ObjectId: exampleUserAssignedIdentity.PrincipalId,
					KeyPermissions: pulumi.StringArray{
						pulumi.String("Get"),
						pulumi.String("WrapKey"),
						pulumi.String("UnwrapKey"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleKey, err := keyvault.NewKey(ctx, "example", &keyvault.KeyArgs{
			Name:       pulumi.String("managedrediscmk"),
			KeyVaultId: exampleKeyVault.ID(),
			KeyType:    pulumi.String("RSA"),
			KeySize:    pulumi.Int(2048),
			KeyOpts: pulumi.StringArray{
				pulumi.String("unwrapKey"),
				pulumi.String("wrapKey"),
			},
		})
		if err != nil {
			return err
		}
		_, err = managedredis.NewManagedRedis(ctx, "example", &managedredis.ManagedRedisArgs{
			Name:              pulumi.String("example-managed-redis"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			SkuName:           pulumi.String("Balanced_B3"),
			Identity: &managedredis.ManagedRedisIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					exampleUserAssignedIdentity.ID(),
				},
			},
			CustomerManagedKey: &managedredis.ManagedRedisCustomerManagedKeyArgs{
				KeyVaultKeyId:          exampleKey.ID(),
				UserAssignedIdentityId: exampleUserAssignedIdentity.ID(),
			},
			DefaultDatabase: &managedredis.ManagedRedisDefaultDatabaseArgs{
				GeoReplicationGroupName: pulumi.String("myGeoGroup"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var current = Azure.Core.GetClientConfig.Invoke();

    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });

    var exampleUserAssignedIdentity = new Azure.Authorization.UserAssignedIdentity("example", new()
    {
        Name = "example",
        ResourceGroupName = example.Name,
        Location = example.Location,
    });

    var exampleKeyVault = new Azure.KeyVault.KeyVault("example", new()
    {
        Name = "example",
        Location = example.Location,
        ResourceGroupName = example.Name,
        TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
        SkuName = "standard",
        PurgeProtectionEnabled = true,
        AccessPolicies = new[]
        {
            new Azure.KeyVault.Inputs.KeyVaultAccessPolicyArgs
            {
                TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
                ObjectId = current.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
                KeyPermissions = new[]
                {
                    "Create",
                    "Delete",
                    "Get",
                    "List",
                    "Purge",
                    "Recover",
                    "Update",
                    "GetRotationPolicy",
                    "SetRotationPolicy",
                },
            },
            new Azure.KeyVault.Inputs.KeyVaultAccessPolicyArgs
            {
                TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
                ObjectId = exampleUserAssignedIdentity.PrincipalId,
                KeyPermissions = new[]
                {
                    "Get",
                    "WrapKey",
                    "UnwrapKey",
                },
            },
        },
    });

    var exampleKey = new Azure.KeyVault.Key("example", new()
    {
        Name = "managedrediscmk",
        KeyVaultId = exampleKeyVault.Id,
        KeyType = "RSA",
        KeySize = 2048,
        KeyOpts = new[]
        {
            "unwrapKey",
            "wrapKey",
        },
    });

    var exampleManagedRedis = new Azure.ManagedRedis.ManagedRedis("example", new()
    {
        Name = "example-managed-redis",
        ResourceGroupName = example.Name,
        Location = example.Location,
        SkuName = "Balanced_B3",
        Identity = new Azure.ManagedRedis.Inputs.ManagedRedisIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                exampleUserAssignedIdentity.Id,
            },
        },
        CustomerManagedKey = new Azure.ManagedRedis.Inputs.ManagedRedisCustomerManagedKeyArgs
        {
            KeyVaultKeyId = exampleKey.Id,
            UserAssignedIdentityId = exampleUserAssignedIdentity.Id,
        },
        DefaultDatabase = new Azure.ManagedRedis.Inputs.ManagedRedisDefaultDatabaseArgs
        {
            GeoReplicationGroupName = "myGeoGroup",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.keyvault.KeyVault;
import com.pulumi.azure.keyvault.KeyVaultArgs;
import com.pulumi.azure.keyvault.inputs.KeyVaultAccessPolicyArgs;
import com.pulumi.azure.keyvault.Key;
import com.pulumi.azure.keyvault.KeyArgs;
import com.pulumi.azure.managedredis.ManagedRedis;
import com.pulumi.azure.managedredis.ManagedRedisArgs;
import com.pulumi.azure.managedredis.inputs.ManagedRedisIdentityArgs;
import com.pulumi.azure.managedredis.inputs.ManagedRedisCustomerManagedKeyArgs;
import com.pulumi.azure.managedredis.inputs.ManagedRedisDefaultDatabaseArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var current = CoreFunctions.getClientConfig(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());

        var exampleUserAssignedIdentity = new UserAssignedIdentity("exampleUserAssignedIdentity", UserAssignedIdentityArgs.builder()
            .name("example")
            .resourceGroupName(example.name())
            .location(example.location())
            .build());

        var exampleKeyVault = new KeyVault("exampleKeyVault", KeyVaultArgs.builder()
            .name("example")
            .location(example.location())
            .resourceGroupName(example.name())
            .tenantId(current.tenantId())
            .skuName("standard")
            .purgeProtectionEnabled(true)
            .accessPolicies(            
                KeyVaultAccessPolicyArgs.builder()
                    .tenantId(current.tenantId())
                    .objectId(current.objectId())
                    .keyPermissions(                    
                        "Create",
                        "Delete",
                        "Get",
                        "List",
                        "Purge",
                        "Recover",
                        "Update",
                        "GetRotationPolicy",
                        "SetRotationPolicy")
                    .build(),
                KeyVaultAccessPolicyArgs.builder()
                    .tenantId(current.tenantId())
                    .objectId(exampleUserAssignedIdentity.principalId())
                    .keyPermissions(                    
                        "Get",
                        "WrapKey",
                        "UnwrapKey")
                    .build())
            .build());

        var exampleKey = new Key("exampleKey", KeyArgs.builder()
            .name("managedrediscmk")
            .keyVaultId(exampleKeyVault.id())
            .keyType("RSA")
            .keySize(2048)
            .keyOpts(            
                "unwrapKey",
                "wrapKey")
            .build());

        var exampleManagedRedis = new ManagedRedis("exampleManagedRedis", ManagedRedisArgs.builder()
            .name("example-managed-redis")
            .resourceGroupName(example.name())
            .location(example.location())
            .skuName("Balanced_B3")
            .identity(ManagedRedisIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(exampleUserAssignedIdentity.id())
                .build())
            .customerManagedKey(ManagedRedisCustomerManagedKeyArgs.builder()
                .keyVaultKeyId(exampleKey.id())
                .userAssignedIdentityId(exampleUserAssignedIdentity.id())
                .build())
            .defaultDatabase(ManagedRedisDefaultDatabaseArgs.builder()
                .geoReplicationGroupName("myGeoGroup")
                .build())
            .build());

    }
}

    resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleUserAssignedIdentity:
    type: azure:authorization:UserAssignedIdentity
    name: example
    properties:
      name: example
      resourceGroupName: ${example.name}
      location: ${example.location}
  exampleKeyVault:
    type: azure:keyvault:KeyVault
    name: example
    properties:
      name: example
      location: ${example.location}
      resourceGroupName: ${example.name}
      tenantId: ${current.tenantId}
      skuName: standard
      purgeProtectionEnabled: true
      accessPolicies:
        - tenantId: ${current.tenantId}
          objectId: ${current.objectId}
          keyPermissions:
            - Create
            - Delete
            - Get
            - List
            - Purge
            - Recover
            - Update
            - GetRotationPolicy
            - SetRotationPolicy
        - tenantId: ${current.tenantId}
          objectId: ${exampleUserAssignedIdentity.principalId}
          keyPermissions:
            - Get
            - WrapKey
            - UnwrapKey
  exampleKey:
    type: azure:keyvault:Key
    name: example
    properties:
      name: managedrediscmk
      keyVaultId: ${exampleKeyVault.id}
      keyType: RSA
      keySize: 2048
      keyOpts:
        - unwrapKey
        - wrapKey
  exampleManagedRedis:
    type: azure:managedredis:ManagedRedis
    name: example
    properties:
      name: example-managed-redis
      resourceGroupName: ${example.name}
      location: ${example.location}
      skuName: Balanced_B3
      identity:
        type: UserAssigned
        identityIds:
          - ${exampleUserAssignedIdentity.id}
      customerManagedKey:
        keyVaultKeyId: ${exampleKey.id}
        userAssignedIdentityId: ${exampleUserAssignedIdentity.id}
      defaultDatabase:
        geoReplicationGroupName: myGeoGroup
variables:
  current:
    fn::invoke:
      function: azure:core:getClientConfig
      arguments: {}

    API Providers

    This resource uses the following Azure API Providers:

    • Microsoft.Cache - 2025-07-01

    Create ManagedRedis Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ManagedRedis(name: string, args: ManagedRedisArgs, opts?: CustomResourceOptions);
    @overload
def ManagedRedis(resource_name: str,
                 args: ManagedRedisArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def ManagedRedis(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 resource_group_name: Optional[str] = None,
                 sku_name: Optional[str] = None,
                 customer_managed_key: Optional[ManagedRedisCustomerManagedKeyArgs] = None,
                 default_database: Optional[ManagedRedisDefaultDatabaseArgs] = None,
                 high_availability_enabled: Optional[bool] = None,
                 identity: Optional[ManagedRedisIdentityArgs] = None,
                 location: Optional[str] = None,
                 name: Optional[str] = None,
                 public_network_access: Optional[str] = None,
                 tags: Optional[Mapping[str, str]] = None)
    func NewManagedRedis(ctx *Context, name string, args ManagedRedisArgs, opts ...ResourceOption) (*ManagedRedis, error)
    public ManagedRedis(string name, ManagedRedisArgs args, CustomResourceOptions? opts = null)
    public ManagedRedis(String name, ManagedRedisArgs args)
public ManagedRedis(String name, ManagedRedisArgs args, CustomResourceOptions options)

    type: azure:managedredis:ManagedRedis
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ManagedRedisArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ManagedRedisArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ManagedRedisArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ManagedRedisArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ManagedRedisArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var managedRedisResource = new Azure.ManagedRedis.ManagedRedis("managedRedisResource", new()
{
    ResourceGroupName = "string",
    SkuName = "string",
    CustomerManagedKey = new Azure.ManagedRedis.Inputs.ManagedRedisCustomerManagedKeyArgs
    {
        KeyVaultKeyId = "string",
        UserAssignedIdentityId = "string",
    },
    DefaultDatabase = new Azure.ManagedRedis.Inputs.ManagedRedisDefaultDatabaseArgs
    {
        AccessKeysAuthenticationEnabled = false,
        ClientProtocol = "string",
        ClusteringPolicy = "string",
        EvictionPolicy = "string",
        GeoReplicationGroupName = "string",
        Modules = new[]
        {
            new Azure.ManagedRedis.Inputs.ManagedRedisDefaultDatabaseModuleArgs
            {
                Name = "string",
                Args = "string",
                Version = "string",
            },
        },
        Port = 0,
        PrimaryAccessKey = "string",
        SecondaryAccessKey = "string",
    },
    HighAvailabilityEnabled = false,
    Identity = new Azure.ManagedRedis.Inputs.ManagedRedisIdentityArgs
    {
        Type = "string",
        IdentityIds = new[]
        {
            "string",
        },
        PrincipalId = "string",
        TenantId = "string",
    },
    Location = "string",
    Name = "string",
    PublicNetworkAccess = "string",
    Tags = 
    {
        { "string", "string" },
    },
});

    example, err := managedredis.NewManagedRedis(ctx, "managedRedisResource", &managedredis.ManagedRedisArgs{
	ResourceGroupName: pulumi.String("string"),
	SkuName:           pulumi.String("string"),
	CustomerManagedKey: &managedredis.ManagedRedisCustomerManagedKeyArgs{
		KeyVaultKeyId:          pulumi.String("string"),
		UserAssignedIdentityId: pulumi.String("string"),
	},
	DefaultDatabase: &managedredis.ManagedRedisDefaultDatabaseArgs{
		AccessKeysAuthenticationEnabled: pulumi.Bool(false),
		ClientProtocol:                  pulumi.String("string"),
		ClusteringPolicy:                pulumi.String("string"),
		EvictionPolicy:                  pulumi.String("string"),
		GeoReplicationGroupName:         pulumi.String("string"),
		Modules: managedredis.ManagedRedisDefaultDatabaseModuleArray{
			&managedredis.ManagedRedisDefaultDatabaseModuleArgs{
				Name:    pulumi.String("string"),
				Args:    pulumi.String("string"),
				Version: pulumi.String("string"),
			},
		},
		Port:               pulumi.Int(0),
		PrimaryAccessKey:   pulumi.String("string"),
		SecondaryAccessKey: pulumi.String("string"),
	},
	HighAvailabilityEnabled: pulumi.Bool(false),
	Identity: &managedredis.ManagedRedisIdentityArgs{
		Type: pulumi.String("string"),
		IdentityIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		PrincipalId: pulumi.String("string"),
		TenantId:    pulumi.String("string"),
	},
	Location:            pulumi.String("string"),
	Name:                pulumi.String("string"),
	PublicNetworkAccess: pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

    var managedRedisResource = new ManagedRedis("managedRedisResource", ManagedRedisArgs.builder()
    .resourceGroupName("string")
    .skuName("string")
    .customerManagedKey(ManagedRedisCustomerManagedKeyArgs.builder()
        .keyVaultKeyId("string")
        .userAssignedIdentityId("string")
        .build())
    .defaultDatabase(ManagedRedisDefaultDatabaseArgs.builder()
        .accessKeysAuthenticationEnabled(false)
        .clientProtocol("string")
        .clusteringPolicy("string")
        .evictionPolicy("string")
        .geoReplicationGroupName("string")
        .modules(ManagedRedisDefaultDatabaseModuleArgs.builder()
            .name("string")
            .args("string")
            .version("string")
            .build())
        .port(0)
        .primaryAccessKey("string")
        .secondaryAccessKey("string")
        .build())
    .highAvailabilityEnabled(false)
    .identity(ManagedRedisIdentityArgs.builder()
        .type("string")
        .identityIds("string")
        .principalId("string")
        .tenantId("string")
        .build())
    .location("string")
    .name("string")
    .publicNetworkAccess("string")
    .tags(Map.of("string", "string"))
    .build());

    managed_redis_resource = azure.managedredis.ManagedRedis("managedRedisResource",
    resource_group_name="string",
    sku_name="string",
    customer_managed_key={
        "key_vault_key_id": "string",
        "user_assigned_identity_id": "string",
    },
    default_database={
        "access_keys_authentication_enabled": False,
        "client_protocol": "string",
        "clustering_policy": "string",
        "eviction_policy": "string",
        "geo_replication_group_name": "string",
        "modules": [{
            "name": "string",
            "args": "string",
            "version": "string",
        }],
        "port": 0,
        "primary_access_key": "string",
        "secondary_access_key": "string",
    },
    high_availability_enabled=False,
    identity={
        "type": "string",
        "identity_ids": ["string"],
        "principal_id": "string",
        "tenant_id": "string",
    },
    location="string",
    name="string",
    public_network_access="string",
    tags={
        "string": "string",
    })

    const managedRedisResource = new azure.managedredis.ManagedRedis("managedRedisResource", {
    resourceGroupName: "string",
    skuName: "string",
    customerManagedKey: {
        keyVaultKeyId: "string",
        userAssignedIdentityId: "string",
    },
    defaultDatabase: {
        accessKeysAuthenticationEnabled: false,
        clientProtocol: "string",
        clusteringPolicy: "string",
        evictionPolicy: "string",
        geoReplicationGroupName: "string",
        modules: [{
            name: "string",
            args: "string",
            version: "string",
        }],
        port: 0,
        primaryAccessKey: "string",
        secondaryAccessKey: "string",
    },
    highAvailabilityEnabled: false,
    identity: {
        type: "string",
        identityIds: ["string"],
        principalId: "string",
        tenantId: "string",
    },
    location: "string",
    name: "string",
    publicNetworkAccess: "string",
    tags: {
        string: "string",
    },
});

    type: azure:managedredis:ManagedRedis
properties:
    customerManagedKey:
        keyVaultKeyId: string
        userAssignedIdentityId: string
    defaultDatabase:
        accessKeysAuthenticationEnabled: false
        clientProtocol: string
        clusteringPolicy: string
        evictionPolicy: string
        geoReplicationGroupName: string
        modules:
            - args: string
              name: string
              version: string
        port: 0
        primaryAccessKey: string
        secondaryAccessKey: string
    highAvailabilityEnabled: false
    identity:
        identityIds:
            - string
        principalId: string
        tenantId: string
        type: string
    location: string
    name: string
    publicNetworkAccess: string
    resourceGroupName: string
    skuName: string
    tags:
        string: string

    ManagedRedis Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ManagedRedis resource accepts the following input properties:

    ResourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    SkuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    CustomerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    DefaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    HighAvailabilityEnabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    Identity ManagedRedisIdentity
    An identity block as defined below.
    Location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    Name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    PublicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    Tags Dictionary<string, string>
    A mapping of tags which should be assigned to the Managed Redis instance.
    ResourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    SkuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    CustomerManagedKey ManagedRedisCustomerManagedKeyArgs
    A customer_managed_key block as defined below.
    DefaultDatabase ManagedRedisDefaultDatabaseArgs
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    HighAvailabilityEnabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    Identity ManagedRedisIdentityArgs
    An identity block as defined below.
    Location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    Name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    PublicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    Tags map[string]string
    A mapping of tags which should be assigned to the Managed Redis instance.
    resourceGroupName String
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName String

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    customerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    defaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled Boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    identity ManagedRedisIdentity
    An identity block as defined below.
    location String
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name String
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess String
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    tags Map<String,String>
    A mapping of tags which should be assigned to the Managed Redis instance.
    resourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    customerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    defaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    identity ManagedRedisIdentity
    An identity block as defined below.
    location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    tags {[key: string]: string}
    A mapping of tags which should be assigned to the Managed Redis instance.
    resource_group_name str
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    sku_name str

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    customer_managed_key ManagedRedisCustomerManagedKeyArgs
    A customer_managed_key block as defined below.
    default_database ManagedRedisDefaultDatabaseArgs
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    high_availability_enabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    identity ManagedRedisIdentityArgs
    An identity block as defined below.
    location str
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name str
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    public_network_access str
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    tags Mapping[str, str]
    A mapping of tags which should be assigned to the Managed Redis instance.
    resourceGroupName String
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName String

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    customerManagedKey Property Map
    A customer_managed_key block as defined below.
    defaultDatabase Property Map
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled Boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    identity Property Map
    An identity block as defined below.
    location String
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name String
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess String
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    tags Map<String>
    A mapping of tags which should be assigned to the Managed Redis instance.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ManagedRedis resource produces the following output properties:

    Hostname string
    DNS name of the cluster endpoint.
    Id string
    The provider-assigned unique ID for this managed resource.
    Hostname string
    DNS name of the cluster endpoint.
    Id string
    The provider-assigned unique ID for this managed resource.
    hostname String
    DNS name of the cluster endpoint.
    id String
    The provider-assigned unique ID for this managed resource.
    hostname string
    DNS name of the cluster endpoint.
    id string
    The provider-assigned unique ID for this managed resource.
    hostname str
    DNS name of the cluster endpoint.
    id str
    The provider-assigned unique ID for this managed resource.
    hostname String
    DNS name of the cluster endpoint.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing ManagedRedis Resource

    Get an existing ManagedRedis resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ManagedRedisState, opts?: CustomResourceOptions): ManagedRedis
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        customer_managed_key: Optional[ManagedRedisCustomerManagedKeyArgs] = None,
        default_database: Optional[ManagedRedisDefaultDatabaseArgs] = None,
        high_availability_enabled: Optional[bool] = None,
        hostname: Optional[str] = None,
        identity: Optional[ManagedRedisIdentityArgs] = None,
        location: Optional[str] = None,
        name: Optional[str] = None,
        public_network_access: Optional[str] = None,
        resource_group_name: Optional[str] = None,
        sku_name: Optional[str] = None,
        tags: Optional[Mapping[str, str]] = None) -> ManagedRedis
    func GetManagedRedis(ctx *Context, name string, id IDInput, state *ManagedRedisState, opts ...ResourceOption) (*ManagedRedis, error)
    public static ManagedRedis Get(string name, Input<string> id, ManagedRedisState? state, CustomResourceOptions? opts = null)
    public static ManagedRedis get(String name, Output<String> id, ManagedRedisState state, CustomResourceOptions options)
    resources:  _:    type: azure:managedredis:ManagedRedis    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CustomerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    DefaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    HighAvailabilityEnabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    Hostname string
    DNS name of the cluster endpoint.
    Identity ManagedRedisIdentity
    An identity block as defined below.
    Location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    Name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    PublicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    ResourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    SkuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    Tags Dictionary<string, string>
    A mapping of tags which should be assigned to the Managed Redis instance.
    CustomerManagedKey ManagedRedisCustomerManagedKeyArgs
    A customer_managed_key block as defined below.
    DefaultDatabase ManagedRedisDefaultDatabaseArgs
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    HighAvailabilityEnabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    Hostname string
    DNS name of the cluster endpoint.
    Identity ManagedRedisIdentityArgs
    An identity block as defined below.
    Location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    Name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    PublicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    ResourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    SkuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    Tags map[string]string
    A mapping of tags which should be assigned to the Managed Redis instance.
    customerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    defaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled Boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    hostname String
    DNS name of the cluster endpoint.
    identity ManagedRedisIdentity
    An identity block as defined below.
    location String
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name String
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess String
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    resourceGroupName String
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName String

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    tags Map<String,String>
    A mapping of tags which should be assigned to the Managed Redis instance.
    customerManagedKey ManagedRedisCustomerManagedKey
    A customer_managed_key block as defined below.
    defaultDatabase ManagedRedisDefaultDatabase
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    hostname string
    DNS name of the cluster endpoint.
    identity ManagedRedisIdentity
    An identity block as defined below.
    location string
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name string
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess string
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    resourceGroupName string
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName string

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    tags {[key: string]: string}
    A mapping of tags which should be assigned to the Managed Redis instance.
    customer_managed_key ManagedRedisCustomerManagedKeyArgs
    A customer_managed_key block as defined below.
    default_database ManagedRedisDefaultDatabaseArgs
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    high_availability_enabled bool
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    hostname str
    DNS name of the cluster endpoint.
    identity ManagedRedisIdentityArgs
    An identity block as defined below.
    location str
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name str
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    public_network_access str
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    resource_group_name str
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    sku_name str

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    tags Mapping[str, str]
    A mapping of tags which should be assigned to the Managed Redis instance.
    customerManagedKey Property Map
    A customer_managed_key block as defined below.
    defaultDatabase Property Map
    A default_database block as defined below. A Managed Redis instance will not be functional without a database. This block is intentionally optional to allow removal and re-creation of the database for troubleshooting purposes. A default database can be created or deleted in-place, however most properties will trigger an entire cluster replacement if changed.
    highAvailabilityEnabled Boolean
    Whether to enable high availability for the Managed Redis instance. Defaults to true. Changing this forces a new Managed Redis instance to be created.
    hostname String
    DNS name of the cluster endpoint.
    identity Property Map
    An identity block as defined below.
    location String
    The Azure Region where the Managed Redis instance should exist. Refer to "Redis Cache" on the product availability documentation for supported locations. Changing this forces a new Managed Redis instance to be created.
    name String
    The name which should be used for this Managed Redis instance. Changing this forces a new Managed Redis instance to be created.
    publicNetworkAccess String
    The public network access setting for the Managed Redis instance. Possible values are Enabled and Disabled. Defaults to Enabled.
    resourceGroupName String
    The name of the Resource Group where the Managed Redis instance should exist. Changing this forces a new Managed Redis instance to be created.
    skuName String

    The features and specification of the Managed Redis instance to deploy. Refer to the documentation for valid values. Balanced_B3 SKU or higher is required for geo-replication. Changing this forces a new Managed Redis instance to be created.

    Note: Enterprise_ and EnterpriseFlash_ prefixed SKUs were previously used by Redis Enterprise, and not supported by Managed Redis.

    tags Map<String>
    A mapping of tags which should be assigned to the Managed Redis instance.

    Supporting Types

    ManagedRedisCustomerManagedKey, ManagedRedisCustomerManagedKeyArgs

    KeyVaultKeyId string
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    UserAssignedIdentityId string
    The ID of the User Assigned Identity that has access to the Key Vault Key.
    KeyVaultKeyId string
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    UserAssignedIdentityId string
    The ID of the User Assigned Identity that has access to the Key Vault Key.
    keyVaultKeyId String
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    userAssignedIdentityId String
    The ID of the User Assigned Identity that has access to the Key Vault Key.
    keyVaultKeyId string
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    userAssignedIdentityId string
    The ID of the User Assigned Identity that has access to the Key Vault Key.
    key_vault_key_id str
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    user_assigned_identity_id str
    The ID of the User Assigned Identity that has access to the Key Vault Key.
    keyVaultKeyId String
    The ID of the key vault key used for encryption. For example: https://example-vault-name.vault.azure.net/keys/example-key-name/a1b2c3d4.
    userAssignedIdentityId String
    The ID of the User Assigned Identity that has access to the Key Vault Key.

    ManagedRedisDefaultDatabase, ManagedRedisDefaultDatabaseArgs

    AccessKeysAuthenticationEnabled bool
    Whether access key authentication is enabled for the database. Defaults to false.
    ClientProtocol string
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    ClusteringPolicy string
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    EvictionPolicy string
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    GeoReplicationGroupName string
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    Modules List<ManagedRedisDefaultDatabaseModule>
    A module block as defined below. Refer to the modules documentation to learn more.
    Port int
    TCP port of the database endpoint.
    PrimaryAccessKey string
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    SecondaryAccessKey string
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    AccessKeysAuthenticationEnabled bool
    Whether access key authentication is enabled for the database. Defaults to false.
    ClientProtocol string
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    ClusteringPolicy string
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    EvictionPolicy string
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    GeoReplicationGroupName string
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    Modules []ManagedRedisDefaultDatabaseModule
    A module block as defined below. Refer to the modules documentation to learn more.
    Port int
    TCP port of the database endpoint.
    PrimaryAccessKey string
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    SecondaryAccessKey string
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    accessKeysAuthenticationEnabled Boolean
    Whether access key authentication is enabled for the database. Defaults to false.
    clientProtocol String
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    clusteringPolicy String
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    evictionPolicy String
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    geoReplicationGroupName String
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    modules List<ManagedRedisDefaultDatabaseModule>
    A module block as defined below. Refer to the modules documentation to learn more.
    port Integer
    TCP port of the database endpoint.
    primaryAccessKey String
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    secondaryAccessKey String
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    accessKeysAuthenticationEnabled boolean
    Whether access key authentication is enabled for the database. Defaults to false.
    clientProtocol string
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    clusteringPolicy string
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    evictionPolicy string
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    geoReplicationGroupName string
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    modules ManagedRedisDefaultDatabaseModule[]
    A module block as defined below. Refer to the modules documentation to learn more.
    port number
    TCP port of the database endpoint.
    primaryAccessKey string
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    secondaryAccessKey string
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    access_keys_authentication_enabled bool
    Whether access key authentication is enabled for the database. Defaults to false.
    client_protocol str
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    clustering_policy str
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    eviction_policy str
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    geo_replication_group_name str
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    modules Sequence[ManagedRedisDefaultDatabaseModule]
    A module block as defined below. Refer to the modules documentation to learn more.
    port int
    TCP port of the database endpoint.
    primary_access_key str
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    secondary_access_key str
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    accessKeysAuthenticationEnabled Boolean
    Whether access key authentication is enabled for the database. Defaults to false.
    clientProtocol String
    Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Possible values are Encrypted and Plaintext. Defaults to Encrypted.
    clusteringPolicy String
    Clustering policy specified at create time. Possible values are EnterpriseCluster and OSSCluster. Defaults to OSSCluster. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    evictionPolicy String
    Specifies the Redis eviction policy. Possible values are AllKeysLFU, AllKeysLRU, AllKeysRandom, VolatileLRU, VolatileLFU, VolatileTTL, VolatileRandom and NoEviction. Defaults to VolatileLRU.
    geoReplicationGroupName String
    The name of the geo-replication group. If provided, a geo-replication group will be created for this database with itself as the only member. Use azurerm_managed_redis_database_geo_replication resource to manage group membership, linking and unlinking. All databases to be linked have to have the same group name. Refer to the Managed Redis geo-replication documentation for more information. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    modules List<Property Map>
    A module block as defined below. Refer to the modules documentation to learn more.
    port Number
    TCP port of the database endpoint.
    primaryAccessKey String
    The Primary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.
    secondaryAccessKey String
    The Secondary Access Key for the Managed Redis Database Instance. Only exported if access_keys_authentication_enabled is set to true.

    ManagedRedisDefaultDatabaseModule, ManagedRedisDefaultDatabaseModuleArgs

    Name string
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    Args string

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    Version string
    Version of the module to be used.
    Name string
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    Args string

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    Version string
    Version of the module to be used.
    name String
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    args String

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    version String
    Version of the module to be used.
    name string
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    args string

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    version string
    Version of the module to be used.
    name str
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    args str

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    version str
    Version of the module to be used.
    name String
    The name which should be used for this module. Possible values are RedisBloom, RedisTimeSeries, RediSearch and RedisJSON. Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.
    args String

    Configuration options for the module (e.g. ERROR_RATE 0.00 INITIAL_SIZE 400). Changing this forces a new database to be created, data will be lost and Managed Redis will be unavailable during the operation.

    Note: Only RediSearch and RedisJSON modules are allowed with geo-replication.

    version String
    Version of the module to be used.

    ManagedRedisIdentity, ManagedRedisIdentityArgs

    Type string
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    IdentityIds List<string>

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    PrincipalId string
    TenantId string
    Type string
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    IdentityIds []string

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    PrincipalId string
    TenantId string
    type String
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    identityIds List<String>

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    principalId String
    tenantId String
    type string
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    identityIds string[]

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    principalId string
    tenantId string
    type str
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    identity_ids Sequence[str]

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    principal_id str
    tenant_id str
    type String
    Specifies the type of Managed Service Identity that should be configured on this Managed Redis instance. Possible values are SystemAssigned, UserAssigned, SystemAssigned, UserAssigned (to enable both).
    identityIds List<String>

    Specifies a list of User Assigned Managed Identity IDs to be assigned to this Managed Redis instance.

    Note: This is required when type is set to UserAssigned or SystemAssigned, UserAssigned.

    principalId String
    tenantId String

    Import

    Managed Redis instances can be imported using the resource id, e.g.

    $ pulumi import azure:managedredis/managedRedis:ManagedRedis example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Cache/redisEnterprise/cluster1

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Azure Classic pulumi/pulumi-azure
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the azurerm Terraform Provider.
    azure logo

    We recommend using Azure Native.

    Azure v6.30.0 published on Thursday, Nov 20, 2025 by Pulumi
    Schema (JSON)
    pulumi/pulumi-azure
      Meet Neo: Your AI Platform Teammate