The azure-native:redisenterprise:Database resource, part of the Pulumi Azure Native provider, defines a database within a Redis Enterprise cluster: its modules, persistence, clustering policy, and optional geo-replication. This guide focuses on three capabilities: module configuration, clustering and eviction policies, and active geo-replication across regions.
Databases belong to Redis Enterprise clusters and reference Azure resource groups. Geo-replication requires existing databases in other regions. The examples are intentionally small. Combine them with your own cluster infrastructure and networking configuration.
Configure modules, persistence, and eviction policies
Teams building caching layers often need specialized Redis capabilities like probabilistic data structures, time-series storage, or full-text search.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const database = new azure_native.redisenterprise.Database("database", {
accessKeysAuthentication: azure_native.redisenterprise.AccessKeysAuthentication.Enabled,
clientProtocol: azure_native.redisenterprise.Protocol.Encrypted,
clusterName: "cache1",
clusteringPolicy: azure_native.redisenterprise.ClusteringPolicy.EnterpriseCluster,
databaseName: "default",
deferUpgrade: azure_native.redisenterprise.DeferUpgradeSetting.NotDeferred,
evictionPolicy: azure_native.redisenterprise.EvictionPolicy.AllKeysLRU,
modules: [
{
args: "ERROR_RATE 0.00 INITIAL_SIZE 400",
name: "RedisBloom",
},
{
args: "RETENTION_POLICY 20",
name: "RedisTimeSeries",
},
{
name: "RediSearch",
},
],
persistence: {
aofEnabled: true,
aofFrequency: azure_native.redisenterprise.AofFrequency.AofFrequency_1s,
},
port: 10000,
resourceGroupName: "rg1",
});
import pulumi
import pulumi_azure_native as azure_native
database = azure_native.redisenterprise.Database("database",
access_keys_authentication=azure_native.redisenterprise.AccessKeysAuthentication.ENABLED,
client_protocol=azure_native.redisenterprise.Protocol.ENCRYPTED,
cluster_name="cache1",
clustering_policy=azure_native.redisenterprise.ClusteringPolicy.ENTERPRISE_CLUSTER,
database_name="default",
defer_upgrade=azure_native.redisenterprise.DeferUpgradeSetting.NOT_DEFERRED,
eviction_policy=azure_native.redisenterprise.EvictionPolicy.ALL_KEYS_LRU,
modules=[
{
"args": "ERROR_RATE 0.00 INITIAL_SIZE 400",
"name": "RedisBloom",
},
{
"args": "RETENTION_POLICY 20",
"name": "RedisTimeSeries",
},
{
"name": "RediSearch",
},
],
persistence={
"aof_enabled": True,
"aof_frequency": azure_native.redisenterprise.AofFrequency.AOF_FREQUENCY_1S,
},
port=10000,
resource_group_name="rg1")
package main
import (
redisenterprise "github.com/pulumi/pulumi-azure-native-sdk/redisenterprise/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := redisenterprise.NewDatabase(ctx, "database", &redisenterprise.DatabaseArgs{
AccessKeysAuthentication: pulumi.String(redisenterprise.AccessKeysAuthenticationEnabled),
ClientProtocol: pulumi.String(redisenterprise.ProtocolEncrypted),
ClusterName: pulumi.String("cache1"),
ClusteringPolicy: pulumi.String(redisenterprise.ClusteringPolicyEnterpriseCluster),
DatabaseName: pulumi.String("default"),
DeferUpgrade: pulumi.String(redisenterprise.DeferUpgradeSettingNotDeferred),
EvictionPolicy: pulumi.String(redisenterprise.EvictionPolicyAllKeysLRU),
Modules: redisenterprise.ModuleArray{
&redisenterprise.ModuleArgs{
Args: pulumi.String("ERROR_RATE 0.00 INITIAL_SIZE 400"),
Name: pulumi.String("RedisBloom"),
},
&redisenterprise.ModuleArgs{
Args: pulumi.String("RETENTION_POLICY 20"),
Name: pulumi.String("RedisTimeSeries"),
},
&redisenterprise.ModuleArgs{
Name: pulumi.String("RediSearch"),
},
},
Persistence: &redisenterprise.PersistenceArgs{
AofEnabled: pulumi.Bool(true),
AofFrequency: pulumi.String(redisenterprise.AofFrequency_1s),
},
Port: pulumi.Int(10000),
ResourceGroupName: pulumi.String("rg1"),
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var database = new AzureNative.RedisEnterprise.Database("database", new()
{
AccessKeysAuthentication = AzureNative.RedisEnterprise.AccessKeysAuthentication.Enabled,
ClientProtocol = AzureNative.RedisEnterprise.Protocol.Encrypted,
ClusterName = "cache1",
ClusteringPolicy = AzureNative.RedisEnterprise.ClusteringPolicy.EnterpriseCluster,
DatabaseName = "default",
DeferUpgrade = AzureNative.RedisEnterprise.DeferUpgradeSetting.NotDeferred,
EvictionPolicy = AzureNative.RedisEnterprise.EvictionPolicy.AllKeysLRU,
Modules = new[]
{
new AzureNative.RedisEnterprise.Inputs.ModuleArgs
{
Args = "ERROR_RATE 0.00 INITIAL_SIZE 400",
Name = "RedisBloom",
},
new AzureNative.RedisEnterprise.Inputs.ModuleArgs
{
Args = "RETENTION_POLICY 20",
Name = "RedisTimeSeries",
},
new AzureNative.RedisEnterprise.Inputs.ModuleArgs
{
Name = "RediSearch",
},
},
Persistence = new AzureNative.RedisEnterprise.Inputs.PersistenceArgs
{
AofEnabled = true,
AofFrequency = AzureNative.RedisEnterprise.AofFrequency.AofFrequency_1s,
},
Port = 10000,
ResourceGroupName = "rg1",
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redisenterprise.Database;
import com.pulumi.azurenative.redisenterprise.DatabaseArgs;
import com.pulumi.azurenative.redisenterprise.inputs.ModuleArgs;
import com.pulumi.azurenative.redisenterprise.inputs.PersistenceArgs;
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 database = new Database("database", DatabaseArgs.builder()
.accessKeysAuthentication("Enabled")
.clientProtocol("Encrypted")
.clusterName("cache1")
.clusteringPolicy("EnterpriseCluster")
.databaseName("default")
.deferUpgrade("NotDeferred")
.evictionPolicy("AllKeysLRU")
.modules(
ModuleArgs.builder()
.args("ERROR_RATE 0.00 INITIAL_SIZE 400")
.name("RedisBloom")
.build(),
ModuleArgs.builder()
.args("RETENTION_POLICY 20")
.name("RedisTimeSeries")
.build(),
ModuleArgs.builder()
.name("RediSearch")
.build())
.persistence(PersistenceArgs.builder()
.aofEnabled(true)
.aofFrequency("1s")
.build())
.port(10000)
.resourceGroupName("rg1")
.build());
}
}
resources:
database:
type: azure-native:redisenterprise:Database
properties:
accessKeysAuthentication: Enabled
clientProtocol: Encrypted
clusterName: cache1
clusteringPolicy: EnterpriseCluster
databaseName: default
deferUpgrade: NotDeferred
evictionPolicy: AllKeysLRU
modules:
- args: ERROR_RATE 0.00 INITIAL_SIZE 400
name: RedisBloom
- args: RETENTION_POLICY 20
name: RedisTimeSeries
- name: RediSearch
persistence:
aofEnabled: true
aofFrequency: 1s
port: 10000
resourceGroupName: rg1
The modules array enables Redis extensions at creation time. Each module accepts custom arguments: RedisBloom configures error rates and initial size, RedisTimeSeries sets retention policies. The persistence block enables append-only file (AOF) logging with a 1-second write frequency. The evictionPolicy determines which keys Redis removes when memory fills; AllKeysLRU evicts least-recently-used keys across all data. The clusteringPolicy set to EnterpriseCluster distributes data across multiple shards for horizontal scaling.
Create a single-shard database without clustering
Some workloads don’t need horizontal scaling across multiple shards. Single-shard databases simplify operations and reduce latency for datasets that fit in one node.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const database = new azure_native.redisenterprise.Database("database", {
clientProtocol: azure_native.redisenterprise.Protocol.Encrypted,
clusterName: "cache1",
clusteringPolicy: azure_native.redisenterprise.ClusteringPolicy.NoCluster,
databaseName: "default",
evictionPolicy: azure_native.redisenterprise.EvictionPolicy.NoEviction,
port: 10000,
resourceGroupName: "rg1",
});
import pulumi
import pulumi_azure_native as azure_native
database = azure_native.redisenterprise.Database("database",
client_protocol=azure_native.redisenterprise.Protocol.ENCRYPTED,
cluster_name="cache1",
clustering_policy=azure_native.redisenterprise.ClusteringPolicy.NO_CLUSTER,
database_name="default",
eviction_policy=azure_native.redisenterprise.EvictionPolicy.NO_EVICTION,
port=10000,
resource_group_name="rg1")
package main
import (
redisenterprise "github.com/pulumi/pulumi-azure-native-sdk/redisenterprise/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := redisenterprise.NewDatabase(ctx, "database", &redisenterprise.DatabaseArgs{
ClientProtocol: pulumi.String(redisenterprise.ProtocolEncrypted),
ClusterName: pulumi.String("cache1"),
ClusteringPolicy: pulumi.String(redisenterprise.ClusteringPolicyNoCluster),
DatabaseName: pulumi.String("default"),
EvictionPolicy: pulumi.String(redisenterprise.EvictionPolicyNoEviction),
Port: pulumi.Int(10000),
ResourceGroupName: pulumi.String("rg1"),
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var database = new AzureNative.RedisEnterprise.Database("database", new()
{
ClientProtocol = AzureNative.RedisEnterprise.Protocol.Encrypted,
ClusterName = "cache1",
ClusteringPolicy = AzureNative.RedisEnterprise.ClusteringPolicy.NoCluster,
DatabaseName = "default",
EvictionPolicy = AzureNative.RedisEnterprise.EvictionPolicy.NoEviction,
Port = 10000,
ResourceGroupName = "rg1",
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redisenterprise.Database;
import com.pulumi.azurenative.redisenterprise.DatabaseArgs;
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 database = new Database("database", DatabaseArgs.builder()
.clientProtocol("Encrypted")
.clusterName("cache1")
.clusteringPolicy("NoCluster")
.databaseName("default")
.evictionPolicy("NoEviction")
.port(10000)
.resourceGroupName("rg1")
.build());
}
}
resources:
database:
type: azure-native:redisenterprise:Database
properties:
clientProtocol: Encrypted
clusterName: cache1
clusteringPolicy: NoCluster
databaseName: default
evictionPolicy: NoEviction
port: 10000
resourceGroupName: rg1
The clusteringPolicy set to NoCluster keeps all data on a single shard. The evictionPolicy set to NoEviction prevents Redis from removing keys when memory fills, causing write operations to fail instead. This configuration suits workloads where data loss is unacceptable and memory capacity is carefully managed. The clientProtocol set to Encrypted requires TLS connections from Redis clients.
Link databases across regions for geo-replication
Applications serving global users need low-latency reads from multiple regions. Active geo-replication keeps databases synchronized across geographic locations.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const database = new azure_native.redisenterprise.Database("database", {
accessKeysAuthentication: azure_native.redisenterprise.AccessKeysAuthentication.Enabled,
clientProtocol: azure_native.redisenterprise.Protocol.Encrypted,
clusterName: "cache1",
clusteringPolicy: azure_native.redisenterprise.ClusteringPolicy.EnterpriseCluster,
databaseName: "default",
evictionPolicy: azure_native.redisenterprise.EvictionPolicy.NoEviction,
geoReplication: {
groupNickname: "groupName",
linkedDatabases: [
{
id: "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
},
{
id: "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
},
],
},
port: 10000,
resourceGroupName: "rg1",
});
import pulumi
import pulumi_azure_native as azure_native
database = azure_native.redisenterprise.Database("database",
access_keys_authentication=azure_native.redisenterprise.AccessKeysAuthentication.ENABLED,
client_protocol=azure_native.redisenterprise.Protocol.ENCRYPTED,
cluster_name="cache1",
clustering_policy=azure_native.redisenterprise.ClusteringPolicy.ENTERPRISE_CLUSTER,
database_name="default",
eviction_policy=azure_native.redisenterprise.EvictionPolicy.NO_EVICTION,
geo_replication={
"group_nickname": "groupName",
"linked_databases": [
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
},
{
"id": "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
},
],
},
port=10000,
resource_group_name="rg1")
package main
import (
redisenterprise "github.com/pulumi/pulumi-azure-native-sdk/redisenterprise/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := redisenterprise.NewDatabase(ctx, "database", &redisenterprise.DatabaseArgs{
AccessKeysAuthentication: pulumi.String(redisenterprise.AccessKeysAuthenticationEnabled),
ClientProtocol: pulumi.String(redisenterprise.ProtocolEncrypted),
ClusterName: pulumi.String("cache1"),
ClusteringPolicy: pulumi.String(redisenterprise.ClusteringPolicyEnterpriseCluster),
DatabaseName: pulumi.String("default"),
EvictionPolicy: pulumi.String(redisenterprise.EvictionPolicyNoEviction),
GeoReplication: &redisenterprise.DatabasePropertiesGeoReplicationArgs{
GroupNickname: pulumi.String("groupName"),
LinkedDatabases: redisenterprise.LinkedDatabaseArray{
&redisenterprise.LinkedDatabaseArgs{
Id: pulumi.String("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default"),
},
&redisenterprise.LinkedDatabaseArgs{
Id: pulumi.String("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default"),
},
},
},
Port: pulumi.Int(10000),
ResourceGroupName: pulumi.String("rg1"),
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var database = new AzureNative.RedisEnterprise.Database("database", new()
{
AccessKeysAuthentication = AzureNative.RedisEnterprise.AccessKeysAuthentication.Enabled,
ClientProtocol = AzureNative.RedisEnterprise.Protocol.Encrypted,
ClusterName = "cache1",
ClusteringPolicy = AzureNative.RedisEnterprise.ClusteringPolicy.EnterpriseCluster,
DatabaseName = "default",
EvictionPolicy = AzureNative.RedisEnterprise.EvictionPolicy.NoEviction,
GeoReplication = new AzureNative.RedisEnterprise.Inputs.DatabasePropertiesGeoReplicationArgs
{
GroupNickname = "groupName",
LinkedDatabases = new[]
{
new AzureNative.RedisEnterprise.Inputs.LinkedDatabaseArgs
{
Id = "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default",
},
new AzureNative.RedisEnterprise.Inputs.LinkedDatabaseArgs
{
Id = "/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default",
},
},
},
Port = 10000,
ResourceGroupName = "rg1",
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redisenterprise.Database;
import com.pulumi.azurenative.redisenterprise.DatabaseArgs;
import com.pulumi.azurenative.redisenterprise.inputs.DatabasePropertiesGeoReplicationArgs;
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 database = new Database("database", DatabaseArgs.builder()
.accessKeysAuthentication("Enabled")
.clientProtocol("Encrypted")
.clusterName("cache1")
.clusteringPolicy("EnterpriseCluster")
.databaseName("default")
.evictionPolicy("NoEviction")
.geoReplication(DatabasePropertiesGeoReplicationArgs.builder()
.groupNickname("groupName")
.linkedDatabases(
LinkedDatabaseArgs.builder()
.id("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default")
.build(),
LinkedDatabaseArgs.builder()
.id("/subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default")
.build())
.build())
.port(10000)
.resourceGroupName("rg1")
.build());
}
}
resources:
database:
type: azure-native:redisenterprise:Database
properties:
accessKeysAuthentication: Enabled
clientProtocol: Encrypted
clusterName: cache1
clusteringPolicy: EnterpriseCluster
databaseName: default
evictionPolicy: NoEviction
geoReplication:
groupNickname: groupName
linkedDatabases:
- id: /subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8f/resourceGroups/rg1/providers/Microsoft.Cache/redisEnterprise/cache1/databases/default
- id: /subscriptions/e7b5a9d2-6b6a-4d2f-9143-20d9a10f5b8e/resourceGroups/rg2/providers/Microsoft.Cache/redisEnterprise/cache2/databases/default
port: 10000
resourceGroupName: rg1
The geoReplication block links databases across regions into a replication group. The groupNickname identifies the replication topology. The linkedDatabases array lists database resource IDs; changes to any database propagate to all linked members. Both databases must use the same clustering policy and eviction settings. This configuration enables multi-region writes with eventual consistency.
Beyond these examples
These snippets focus on specific database-level features: module configuration and persistence settings, clustering policies and eviction strategies, and active geo-replication across regions. They’re intentionally minimal rather than full Redis deployments.
The examples reference pre-existing infrastructure such as Redis Enterprise clusters (clusterName), Azure resource groups, and existing databases for geo-replication linking. They focus on configuring the database rather than provisioning the cluster infrastructure.
To keep things focused, common database patterns are omitted, including:
- Upgrade deferral (deferUpgrade)
- Authentication modes (accessKeysAuthentication)
- Port customization (defaults to available port)
- Module arguments tuning for specific workloads
These omissions are intentional: the goal is to illustrate how each database feature is wired, not provide drop-in Redis modules. See the Redis Enterprise Database resource reference for all available configuration options.
Let's configure Azure Redis Enterprise Databases
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Configuration & Immutability
What properties can't be changed after creating the database?
Several properties are immutable:
clusterName, databaseName, resourceGroupName, port, modules, and geoReplication. Changing these requires recreating the database.Why can't I change my clustering policy from EnterpriseCluster to NoCluster?
The
clusteringPolicy can only be updated if the current value is NoCluster. Once set to OSSCluster or EnterpriseCluster, it cannot be changed without deleting and recreating the database.Can I update access key authentication after creating the database?
Yes,
accessKeysAuthentication can be toggled between Enabled and Disabled even after database creation, unlike most other properties.Clustering & Scaling
What's the difference between clustering policies?
Three options are available:
NoCluster (single shard), OSSCluster (default, Redis OSS cluster mode), and EnterpriseCluster (Redis Enterprise clustering). Choose based on your sharding and scaling requirements.Modules & Features
How do I enable Redis modules like RedisBloom or RediSearch?
Configure the
modules array at creation time with module names and optional arguments. For example, RedisBloom can include args: "ERROR_RATE 0.00 INITIAL_SIZE 400".Why can't I add Redis modules after creating the database?
Modules are immutable and can only be added at creation time. Plan all required modules (RedisBloom, RedisTimeSeries, RediSearch) before creating the database.
Persistence & Data Durability
How do I configure AOF persistence for my database?
Set
persistence.aofEnabled to true and specify aofFrequency (e.g., 1s for one-second intervals) to enable append-only file persistence.What eviction policies are available?
Available policies include
VolatileLRU (default), AllKeysLRU, and NoEviction. Choose based on your caching strategy and memory management needs.Geo-Replication
How do I set up active geo-replication across regions?
Configure
geoReplication with a groupNickname and linkedDatabases array containing resource IDs of databases in different regions. This property is immutable after creation.Security & Access
Should I use encrypted or plaintext client protocol?
The
clientProtocol defaults to Encrypted (TLS-encrypted connections). Use Plaintext only if your clients don’t support TLS, as encrypted connections are more secure.