pulumi-azure-native-kotlin/com.pulumi.azurenative.redis.kotlin/Redis

Redis

class Redis : KotlinCustomResource

A single Redis item in List or Get Operation. Uses Azure REST API version 2024-11-01. Other available API versions: 2015-08-01, 2016-04-01, 2017-02-01, 2017-10-01, 2018-03-01, 2019-07-01, 2020-06-01, 2020-12-01, 2021-06-01, 2022-05-01, 2022-06-01, 2023-04-01, 2023-05-01-preview, 2023-08-01, 2024-03-01, 2024-04-01-preview. These can be accessed by generating a local SDK package using the CLI command pulumi package add azure-native redis [ApiVersion]. See the ../../../version-guide/#accessing-any-api-version-via-local-packages for details.

Example Usage

RedisCacheCreate

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        RedisVersion = "4",
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        Zones = new[]
        {
            "1",
        },
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			RedisVersion:       pulumi.String("4"),
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP: pulumi.String("192.168.0.5"),
			SubnetId: pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			Zones: pulumi.StringArray{
				pulumi.String("1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .redisVersion("4")
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zones("1")
            .build());
    }
}
Content copied to clipboard

RedisCacheCreateAutomaticZonalAllocationPolicy

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        ZonalAllocationPolicy = AzureNative.Redis.ZonalAllocationPolicy.Automatic,
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP:              pulumi.String("192.168.0.5"),
			SubnetId:              pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			ZonalAllocationPolicy: pulumi.String(redis.ZonalAllocationPolicyAutomatic),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zonalAllocationPolicy("Automatic")
            .build());
    }
}
Content copied to clipboard

RedisCacheCreateDefaultVersion

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        Zones = new[]
        {
            "1",
        },
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP: pulumi.String("192.168.0.5"),
			SubnetId: pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			Zones: pulumi.StringArray{
				pulumi.String("1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zones("1")
            .build());
    }
}
Content copied to clipboard

RedisCacheCreateLatestVersion

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        RedisVersion = "Latest",
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        Zones = new[]
        {
            "1",
        },
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			RedisVersion:       pulumi.String("Latest"),
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP: pulumi.String("192.168.0.5"),
			SubnetId: pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			Zones: pulumi.StringArray{
				pulumi.String("1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .redisVersion("Latest")
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zones("1")
            .build());
    }
}
Content copied to clipboard

RedisCacheCreateNoZonesZonalAllocationPolicy

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        ZonalAllocationPolicy = AzureNative.Redis.ZonalAllocationPolicy.NoZones,
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP:              pulumi.String("192.168.0.5"),
			SubnetId:              pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			ZonalAllocationPolicy: pulumi.String(redis.ZonalAllocationPolicyNoZones),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zonalAllocationPolicy("NoZones")
            .build());
    }
}
Content copied to clipboard

RedisCacheCreateUserDefinedZonalAllocationPolicy

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var redis = new AzureNative.Redis.Redis("redis", new()
    {
        EnableNonSslPort = true,
        Location = "East US",
        MinimumTlsVersion = AzureNative.Redis.TlsVersion.TlsVersion_1_2,
        Name = "cache1",
        RedisConfiguration = new AzureNative.Redis.Inputs.RedisCommonPropertiesRedisConfigurationArgs
        {
            MaxmemoryPolicy = "allkeys-lru",
        },
        RedisVersion = "Latest",
        ReplicasPerPrimary = 2,
        ResourceGroupName = "rg1",
        ShardCount = 2,
        Sku = new AzureNative.Redis.Inputs.SkuArgs
        {
            Capacity = 1,
            Family = AzureNative.Redis.SkuFamily.P,
            Name = AzureNative.Redis.SkuName.Premium,
        },
        StaticIP = "192.168.0.5",
        SubnetId = "/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1",
        ZonalAllocationPolicy = AzureNative.Redis.ZonalAllocationPolicy.UserDefined,
        Zones = new[]
        {
            "1",
        },
    });
});
Content copied to clipboard
package main
import (
	redis "github.com/pulumi/pulumi-azure-native-sdk/redis/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redis.NewRedis(ctx, "redis", &redis.RedisArgs{
			EnableNonSslPort:  pulumi.Bool(true),
			Location:          pulumi.String("East US"),
			MinimumTlsVersion: pulumi.String(redis.TlsVersion_1_2),
			Name:              pulumi.String("cache1"),
			RedisConfiguration: &redis.RedisCommonPropertiesRedisConfigurationArgs{
				MaxmemoryPolicy: pulumi.String("allkeys-lru"),
			},
			RedisVersion:       pulumi.String("Latest"),
			ReplicasPerPrimary: pulumi.Int(2),
			ResourceGroupName:  pulumi.String("rg1"),
			ShardCount:         pulumi.Int(2),
			Sku: &redis.SkuArgs{
				Capacity: pulumi.Int(1),
				Family:   pulumi.String(redis.SkuFamilyP),
				Name:     pulumi.String(redis.SkuNamePremium),
			},
			StaticIP:              pulumi.String("192.168.0.5"),
			SubnetId:              pulumi.String("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			ZonalAllocationPolicy: pulumi.String(redis.ZonalAllocationPolicyUserDefined),
			Zones: pulumi.StringArray{
				pulumi.String("1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.redis.Redis;
import com.pulumi.azurenative.redis.RedisArgs;
import com.pulumi.azurenative.redis.inputs.RedisCommonPropertiesRedisConfigurationArgs;
import com.pulumi.azurenative.redis.inputs.SkuArgs;
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 redis = new Redis("redis", RedisArgs.builder()
            .enableNonSslPort(true)
            .location("East US")
            .minimumTlsVersion("1.2")
            .name("cache1")
            .redisConfiguration(RedisCommonPropertiesRedisConfigurationArgs.builder()
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .redisVersion("Latest")
            .replicasPerPrimary(2)
            .resourceGroupName("rg1")
            .shardCount(2)
            .sku(SkuArgs.builder()
                .capacity(1)
                .family("P")
                .name("Premium")
                .build())
            .staticIP("192.168.0.5")
            .subnetId("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1")
            .zonalAllocationPolicy("UserDefined")
            .zones("1")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:redis:Redis cache1 /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redis/{name}
Content copied to clipboard

Properties

Link copied to clipboard
val accessKeys: Output<RedisAccessKeysResponse>

The keys of the Redis cache - not set if this object is not the response to Create or Update redis cache

Link copied to clipboard
val azureApiVersion: Output<String>

The Azure API version of the resource.

Link copied to clipboard
val disableAccessKeyAuthentication: Output<Boolean>?

Authentication to Redis through access keys is disabled when set as true. Default value is false.

Link copied to clipboard
val enableNonSslPort: Output<Boolean>?

Specifies whether the non-ssl Redis server port (6379) is enabled.

Link copied to clipboard
val hostName: Output<String>

Redis host name.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val identity: Output<ManagedServiceIdentityResponse>?

The identity of the resource.

Link copied to clipboard
val instances: Output<List<RedisInstanceDetailsResponse>>

List of the Redis instances associated with the cache

Link copied to clipboard
val linkedServers: Output<List<RedisLinkedServerResponse>>

List of the linked servers associated with the cache

Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

Link copied to clipboard
val minimumTlsVersion: Output<String>?

Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val port: Output<Int>

Redis non-SSL port.

Link copied to clipboard
val privateEndpointConnections: Output<List<PrivateEndpointConnectionResponse>>

List of private endpoint connection associated with the specified redis cache

Link copied to clipboard
val provisioningState: Output<String>

Redis instance provisioning status.

Link copied to clipboard
val publicNetworkAccess: Output<String>?

Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled' or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method. Default value is 'Enabled'

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val redisConfiguration: Output<RedisCommonPropertiesResponseRedisConfiguration>?

All Redis Settings. Few possible keys: rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta, maxmemory-policy,notify-keyspace-events, aof-backup-enabled, aof-storage-connection-string-0, aof-storage-connection-string-1 etc.

Link copied to clipboard
val redisVersion: Output<String>?

Redis version. This should be in the form 'major.minor' (only 'major' is required) or the value 'latest' which refers to the latest stable Redis version that is available. Supported versions: 4.0, 6.0 (latest). Default value is 'latest'.

Link copied to clipboard
val replicasPerMaster: Output<Int>?

The number of replicas to be created per primary.

Link copied to clipboard
val replicasPerPrimary: Output<Int>?

The number of replicas to be created per primary.

Link copied to clipboard
val shardCount: Output<Int>?

The number of shards to be created on a Premium Cluster Cache.

Link copied to clipboard
val sku: Output<SkuResponse>

The SKU of the Redis cache to deploy.

Link copied to clipboard
val sslPort: Output<Int>

Redis SSL port.

Link copied to clipboard
val staticIP: Output<String>?

Static IP address. Optionally, may be specified when deploying a Redis cache inside an existing Azure Virtual Network; auto assigned by default.

Link copied to clipboard
val subnetId: Output<String>?

The full resource ID of a subnet in a virtual network to deploy the Redis cache in. Example format: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

Link copied to clipboard
val tenantSettings: Output<Map<String, String>>?

A dictionary of tenant settings

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val updateChannel: Output<String>?

Optional: Specifies the update channel for the monthly Redis updates your Redis Cache will receive. Caches using 'Preview' update channel get latest Redis updates at least 4 weeks ahead of 'Stable' channel caches. Default value is 'Stable'.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val zonalAllocationPolicy: Output<String>?

Optional: Specifies how availability zones are allocated to the Redis cache. 'Automatic' enables zone redundancy and Azure will automatically select zones based on regional availability and capacity. 'UserDefined' will select availability zones passed in by you using the 'zones' parameter. 'NoZones' will produce a non-zonal cache. If 'zonalAllocationPolicy' is not passed, it will be set to 'UserDefined' when zones are passed in, otherwise, it will be set to 'Automatic' in regions where zones are supported and 'NoZones' in regions where zones are not supported.

Link copied to clipboard
val zones: Output<List<String>>?

A list of availability zones denoting where the resource needs to come from.