1. Packages
  2. RedisCloud
  3. API Docs
  4. SubscriptionDatabase
Redis Cloud v1.3.1 published on Friday, Sep 29, 2023 by RedisLabs

rediscloud.SubscriptionDatabase

Explore with Pulumi AI

rediscloud logo
Redis Cloud v1.3.1 published on Friday, Sep 29, 2023 by RedisLabs

    Creates a Database within a specified Subscription in your Redis Enterprise Cloud Account.

    Example Usage

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Rediscloud = Pulumi.Rediscloud;
    using Rediscloud = RedisLabs.Rediscloud;
    
    return await Deployment.RunAsync(() => 
    {
        var card = Rediscloud.GetPaymentMethod.Invoke(new()
        {
            CardType = "Visa",
        });
    
        var subscription_resource = new Rediscloud.Subscription("subscription-resource", new()
        {
            PaymentMethod = "credit-card",
            PaymentMethodId = card.Apply(getPaymentMethodResult => getPaymentMethodResult.Id),
            MemoryStorage = "ram",
            CloudProvider = new Rediscloud.Inputs.SubscriptionCloudProviderArgs
            {
                Provider = data.Rediscloud_cloud_account.Account.Provider_type,
                Regions = new[]
                {
                    new Rediscloud.Inputs.SubscriptionCloudProviderRegionArgs
                    {
                        Region = "eu-west-1",
                        MultipleAvailabilityZones = true,
                        NetworkingDeploymentCidr = "10.0.0.0/24",
                        PreferredAvailabilityZones = new[]
                        {
                            "euw1-az1, euw1-az2, euw1-az3",
                        },
                    },
                },
            },
            CreationPlan = new Rediscloud.Inputs.SubscriptionCreationPlanArgs
            {
                MemoryLimitInGb = 15,
                Quantity = 1,
                Replication = true,
                ThroughputMeasurementBy = "operations-per-second",
                ThroughputMeasurementValue = 20000,
                Modules = new[]
                {
                    "RedisJSON",
                },
            },
        });
    
        // The primary database to provision
        var database_resource = new Rediscloud.SubscriptionDatabase("database-resource", new()
        {
            SubscriptionId = subscription_resource.Id,
            MemoryLimitInGb = 15,
            DataPersistence = "aof-every-write",
            ThroughputMeasurementBy = "operations-per-second",
            ThroughputMeasurementValue = 20000,
            Replication = true,
            Modules = new[]
            {
                new Rediscloud.Inputs.SubscriptionDatabaseModuleArgs
                {
                    Name = "RedisJSON",
                },
            },
            Alerts = new[]
            {
                new Rediscloud.Inputs.SubscriptionDatabaseAlertArgs
                {
                    Name = "dataset-size",
                    Value = 40,
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn = new[]
            {
                subscription_resource,
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/RedisLabs/pulumi-rediscloud/sdk/go/rediscloud"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		card, err := rediscloud.GetPaymentMethod(ctx, &rediscloud.GetPaymentMethodArgs{
    			CardType: pulumi.StringRef("Visa"),
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = rediscloud.NewSubscription(ctx, "subscription-resource", &rediscloud.SubscriptionArgs{
    			PaymentMethod:   pulumi.String("credit-card"),
    			PaymentMethodId: *pulumi.String(card.Id),
    			MemoryStorage:   pulumi.String("ram"),
    			CloudProvider: &rediscloud.SubscriptionCloudProviderArgs{
    				Provider: pulumi.Any(data.Rediscloud_cloud_account.Account.Provider_type),
    				Regions: rediscloud.SubscriptionCloudProviderRegionArray{
    					&rediscloud.SubscriptionCloudProviderRegionArgs{
    						Region:                    pulumi.String("eu-west-1"),
    						MultipleAvailabilityZones: pulumi.Bool(true),
    						NetworkingDeploymentCidr:  pulumi.String("10.0.0.0/24"),
    						PreferredAvailabilityZones: pulumi.StringArray{
    							pulumi.String("euw1-az1, euw1-az2, euw1-az3"),
    						},
    					},
    				},
    			},
    			CreationPlan: &rediscloud.SubscriptionCreationPlanArgs{
    				MemoryLimitInGb:            pulumi.Float64(15),
    				Quantity:                   pulumi.Int(1),
    				Replication:                pulumi.Bool(true),
    				ThroughputMeasurementBy:    pulumi.String("operations-per-second"),
    				ThroughputMeasurementValue: pulumi.Int(20000),
    				Modules: pulumi.StringArray{
    					pulumi.String("RedisJSON"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = rediscloud.NewSubscriptionDatabase(ctx, "database-resource", &rediscloud.SubscriptionDatabaseArgs{
    			SubscriptionId:             subscription_resource.ID(),
    			MemoryLimitInGb:            pulumi.Float64(15),
    			DataPersistence:            pulumi.String("aof-every-write"),
    			ThroughputMeasurementBy:    pulumi.String("operations-per-second"),
    			ThroughputMeasurementValue: pulumi.Int(20000),
    			Replication:                pulumi.Bool(true),
    			Modules: rediscloud.SubscriptionDatabaseModuleArray{
    				&rediscloud.SubscriptionDatabaseModuleArgs{
    					Name: pulumi.String("RedisJSON"),
    				},
    			},
    			Alerts: rediscloud.SubscriptionDatabaseAlertArray{
    				&rediscloud.SubscriptionDatabaseAlertArgs{
    					Name:  pulumi.String("dataset-size"),
    					Value: pulumi.Int(40),
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			subscription_resource,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.rediscloud.RediscloudFunctions;
    import com.pulumi.rediscloud.inputs.GetPaymentMethodArgs;
    import com.pulumi.rediscloud.Subscription;
    import com.pulumi.rediscloud.SubscriptionArgs;
    import com.pulumi.rediscloud.inputs.SubscriptionCloudProviderArgs;
    import com.pulumi.rediscloud.inputs.SubscriptionCreationPlanArgs;
    import com.pulumi.rediscloud.SubscriptionDatabase;
    import com.pulumi.rediscloud.SubscriptionDatabaseArgs;
    import com.pulumi.rediscloud.inputs.SubscriptionDatabaseModuleArgs;
    import com.pulumi.rediscloud.inputs.SubscriptionDatabaseAlertArgs;
    import com.pulumi.resources.CustomResourceOptions;
    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 card = RediscloudFunctions.getPaymentMethod(GetPaymentMethodArgs.builder()
                .cardType("Visa")
                .build());
    
            var subscription_resource = new Subscription("subscription-resource", SubscriptionArgs.builder()        
                .paymentMethod("credit-card")
                .paymentMethodId(card.applyValue(getPaymentMethodResult -> getPaymentMethodResult.id()))
                .memoryStorage("ram")
                .cloudProvider(SubscriptionCloudProviderArgs.builder()
                    .provider(data.rediscloud_cloud_account().account().provider_type())
                    .regions(SubscriptionCloudProviderRegionArgs.builder()
                        .region("eu-west-1")
                        .multipleAvailabilityZones(true)
                        .networkingDeploymentCidr("10.0.0.0/24")
                        .preferredAvailabilityZones("euw1-az1, euw1-az2, euw1-az3")
                        .build())
                    .build())
                .creationPlan(SubscriptionCreationPlanArgs.builder()
                    .memoryLimitInGb(15)
                    .quantity(1)
                    .replication(true)
                    .throughputMeasurementBy("operations-per-second")
                    .throughputMeasurementValue(20000)
                    .modules("RedisJSON")
                    .build())
                .build());
    
            var database_resource = new SubscriptionDatabase("database-resource", SubscriptionDatabaseArgs.builder()        
                .subscriptionId(subscription_resource.id())
                .memoryLimitInGb(15)
                .dataPersistence("aof-every-write")
                .throughputMeasurementBy("operations-per-second")
                .throughputMeasurementValue(20000)
                .replication(true)
                .modules(SubscriptionDatabaseModuleArgs.builder()
                    .name("RedisJSON")
                    .build())
                .alerts(SubscriptionDatabaseAlertArgs.builder()
                    .name("dataset-size")
                    .value(40)
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(subscription_resource)
                    .build());
    
        }
    }
    
    import pulumi
    import pulumi_rediscloud as rediscloud
    
    card = rediscloud.get_payment_method(card_type="Visa")
    subscription_resource = rediscloud.Subscription("subscription-resource",
        payment_method="credit-card",
        payment_method_id=card.id,
        memory_storage="ram",
        cloud_provider=rediscloud.SubscriptionCloudProviderArgs(
            provider=data["rediscloud_cloud_account"]["account"]["provider_type"],
            regions=[rediscloud.SubscriptionCloudProviderRegionArgs(
                region="eu-west-1",
                multiple_availability_zones=True,
                networking_deployment_cidr="10.0.0.0/24",
                preferred_availability_zones=["euw1-az1, euw1-az2, euw1-az3"],
            )],
        ),
        creation_plan=rediscloud.SubscriptionCreationPlanArgs(
            memory_limit_in_gb=15,
            quantity=1,
            replication=True,
            throughput_measurement_by="operations-per-second",
            throughput_measurement_value=20000,
            modules=["RedisJSON"],
        ))
    # The primary database to provision
    database_resource = rediscloud.SubscriptionDatabase("database-resource",
        subscription_id=subscription_resource.id,
        memory_limit_in_gb=15,
        data_persistence="aof-every-write",
        throughput_measurement_by="operations-per-second",
        throughput_measurement_value=20000,
        replication=True,
        modules=[rediscloud.SubscriptionDatabaseModuleArgs(
            name="RedisJSON",
        )],
        alerts=[rediscloud.SubscriptionDatabaseAlertArgs(
            name="dataset-size",
            value=40,
        )],
        opts=pulumi.ResourceOptions(depends_on=[subscription_resource]))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as rediscloud from "@pulumi/rediscloud";
    import * as rediscloud from "@rediscloud/pulumi-rediscloud";
    
    const card = rediscloud.getPaymentMethod({
        cardType: "Visa",
    });
    const subscription_resource = new rediscloud.Subscription("subscription-resource", {
        paymentMethod: "credit-card",
        paymentMethodId: card.then(card => card.id),
        memoryStorage: "ram",
        cloudProvider: {
            provider: data.rediscloud_cloud_account.account.provider_type,
            regions: [{
                region: "eu-west-1",
                multipleAvailabilityZones: true,
                networkingDeploymentCidr: "10.0.0.0/24",
                preferredAvailabilityZones: ["euw1-az1, euw1-az2, euw1-az3"],
            }],
        },
        creationPlan: {
            memoryLimitInGb: 15,
            quantity: 1,
            replication: true,
            throughputMeasurementBy: "operations-per-second",
            throughputMeasurementValue: 20000,
            modules: ["RedisJSON"],
        },
    });
    // The primary database to provision
    const database_resource = new rediscloud.SubscriptionDatabase("database-resource", {
        subscriptionId: subscription_resource.id,
        memoryLimitInGb: 15,
        dataPersistence: "aof-every-write",
        throughputMeasurementBy: "operations-per-second",
        throughputMeasurementValue: 20000,
        replication: true,
        modules: [{
            name: "RedisJSON",
        }],
        alerts: [{
            name: "dataset-size",
            value: 40,
        }],
    }, {
        dependsOn: [subscription_resource],
    });
    
    resources:
      subscription-resource:
        type: rediscloud:Subscription
        properties:
          paymentMethod: credit-card
          paymentMethodId: ${card.id}
          memoryStorage: ram
          cloudProvider:
            provider: ${data.rediscloud_cloud_account.account.provider_type}
            regions:
              - region: eu-west-1
                multipleAvailabilityZones: true
                networkingDeploymentCidr: 10.0.0.0/24
                preferredAvailabilityZones:
                  - euw1-az1, euw1-az2, euw1-az3
          creationPlan:
            memoryLimitInGb: 15
            quantity: 1
            replication: true
            throughputMeasurementBy: operations-per-second
            throughputMeasurementValue: 20000
            modules:
              - RedisJSON
      # The primary database to provision
      database-resource:
        type: rediscloud:SubscriptionDatabase
        properties:
          subscriptionId: ${["subscription-resource"].id}
          memoryLimitInGb: 15
          dataPersistence: aof-every-write
          throughputMeasurementBy: operations-per-second
          throughputMeasurementValue: 20000
          replication: true
          modules:
            - name: RedisJSON
          alerts:
            - name: dataset-size
              value: 40
        options:
          dependson:
            - ${["subscription-resource"]}
    variables:
      card:
        fn::invoke:
          Function: rediscloud:getPaymentMethod
          Arguments:
            cardType: Visa
    

    Create SubscriptionDatabase Resource

    new SubscriptionDatabase(name: string, args: SubscriptionDatabaseArgs, opts?: CustomResourceOptions);
    @overload
    def SubscriptionDatabase(resource_name: str,
                             opts: Optional[ResourceOptions] = None,
                             alerts: Optional[Sequence[SubscriptionDatabaseAlertArgs]] = None,
                             average_item_size_in_bytes: Optional[int] = None,
                             client_ssl_certificate: Optional[str] = None,
                             data_eviction: Optional[str] = None,
                             data_persistence: Optional[str] = None,
                             enable_tls: Optional[bool] = None,
                             external_endpoint_for_oss_cluster_api: Optional[bool] = None,
                             hashing_policies: Optional[Sequence[str]] = None,
                             memory_limit_in_gb: Optional[float] = None,
                             modules: Optional[Sequence[SubscriptionDatabaseModuleArgs]] = None,
                             name: Optional[str] = None,
                             password: Optional[str] = None,
                             periodic_backup_path: Optional[str] = None,
                             port: Optional[int] = None,
                             protocol: Optional[str] = None,
                             remote_backup: Optional[SubscriptionDatabaseRemoteBackupArgs] = None,
                             replica_ofs: Optional[Sequence[str]] = None,
                             replication: Optional[bool] = None,
                             source_ips: Optional[Sequence[str]] = None,
                             subscription_id: Optional[str] = None,
                             support_oss_cluster_api: Optional[bool] = None,
                             throughput_measurement_by: Optional[str] = None,
                             throughput_measurement_value: Optional[int] = None)
    @overload
    def SubscriptionDatabase(resource_name: str,
                             args: SubscriptionDatabaseArgs,
                             opts: Optional[ResourceOptions] = None)
    func NewSubscriptionDatabase(ctx *Context, name string, args SubscriptionDatabaseArgs, opts ...ResourceOption) (*SubscriptionDatabase, error)
    public SubscriptionDatabase(string name, SubscriptionDatabaseArgs args, CustomResourceOptions? opts = null)
    public SubscriptionDatabase(String name, SubscriptionDatabaseArgs args)
    public SubscriptionDatabase(String name, SubscriptionDatabaseArgs args, CustomResourceOptions options)
    
    type: rediscloud:SubscriptionDatabase
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args SubscriptionDatabaseArgs
    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 SubscriptionDatabaseArgs
    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 SubscriptionDatabaseArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SubscriptionDatabaseArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SubscriptionDatabaseArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    SubscriptionDatabase Resource Properties

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

    Inputs

    The SubscriptionDatabase resource accepts the following input properties:

    MemoryLimitInGb double

    Maximum memory usage for this specific database

    SubscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    ThroughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    ThroughputMeasurementValue int

    Throughput value (as applies to selected measurement method)

    Alerts List<RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseAlert>

    A block defining Redis database alert, documented below, can be specified multiple times

    AverageItemSizeInBytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    ClientSslCertificate string

    SSL certificate to authenticate user connections

    DataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    DataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    EnableTls bool

    Use TLS for authentication. Default: ‘false’

    ExternalEndpointForOssClusterApi bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    HashingPolicies List<string>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    Modules List<RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseModule>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    Name string

    A meaningful name to identify the database

    Password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    PeriodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    Port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    Protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    RemoteBackup RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    ReplicaOfs List<string>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    Replication bool

    Databases replication. Default: ‘true’

    SourceIps List<string>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    SupportOssClusterApi bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    MemoryLimitInGb float64

    Maximum memory usage for this specific database

    SubscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    ThroughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    ThroughputMeasurementValue int

    Throughput value (as applies to selected measurement method)

    Alerts []SubscriptionDatabaseAlertArgs

    A block defining Redis database alert, documented below, can be specified multiple times

    AverageItemSizeInBytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    ClientSslCertificate string

    SSL certificate to authenticate user connections

    DataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    DataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    EnableTls bool

    Use TLS for authentication. Default: ‘false’

    ExternalEndpointForOssClusterApi bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    HashingPolicies []string

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    Modules []SubscriptionDatabaseModuleArgs

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    Name string

    A meaningful name to identify the database

    Password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    PeriodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    Port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    Protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    RemoteBackup SubscriptionDatabaseRemoteBackupArgs

    Specifies the backup options for the database, documented below

    ReplicaOfs []string

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    Replication bool

    Databases replication. Default: ‘true’

    SourceIps []string

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    SupportOssClusterApi bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    memoryLimitInGb Double

    Maximum memory usage for this specific database

    subscriptionId String

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    throughputMeasurementBy String

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue Integer

    Throughput value (as applies to selected measurement method)

    alerts List<SubscriptionDatabaseAlert>

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes Integer

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate String

    SSL certificate to authenticate user connections

    dataEviction String

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence String

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    enableTls Boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi Boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies List<String>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    modules List<SubscriptionDatabaseModule>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name String

    A meaningful name to identify the database

    password String

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath String

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port Integer

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    protocol String

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    remoteBackup SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    replicaOfs List<String>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication Boolean

    Databases replication. Default: ‘true’

    sourceIps List<String>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    supportOssClusterApi Boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    memoryLimitInGb number

    Maximum memory usage for this specific database

    subscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    throughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue number

    Throughput value (as applies to selected measurement method)

    alerts SubscriptionDatabaseAlert[]

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes number

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate string

    SSL certificate to authenticate user connections

    dataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    enableTls boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies string[]

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    modules SubscriptionDatabaseModule[]

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name string

    A meaningful name to identify the database

    password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port number

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    remoteBackup SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    replicaOfs string[]

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication boolean

    Databases replication. Default: ‘true’

    sourceIps string[]

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    supportOssClusterApi boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    memory_limit_in_gb float

    Maximum memory usage for this specific database

    subscription_id str

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    throughput_measurement_by str

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughput_measurement_value int

    Throughput value (as applies to selected measurement method)

    alerts Sequence[SubscriptionDatabaseAlertArgs]

    A block defining Redis database alert, documented below, can be specified multiple times

    average_item_size_in_bytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    client_ssl_certificate str

    SSL certificate to authenticate user connections

    data_eviction str

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    data_persistence str

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    enable_tls bool

    Use TLS for authentication. Default: ‘false’

    external_endpoint_for_oss_cluster_api bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashing_policies Sequence[str]

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    modules Sequence[SubscriptionDatabaseModuleArgs]

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name str

    A meaningful name to identify the database

    password str

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodic_backup_path str

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    protocol str

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    remote_backup SubscriptionDatabaseRemoteBackupArgs

    Specifies the backup options for the database, documented below

    replica_ofs Sequence[str]

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication bool

    Databases replication. Default: ‘true’

    source_ips Sequence[str]

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    support_oss_cluster_api bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    memoryLimitInGb Number

    Maximum memory usage for this specific database

    subscriptionId String

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    throughputMeasurementBy String

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue Number

    Throughput value (as applies to selected measurement method)

    alerts List<Property Map>

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes Number

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate String

    SSL certificate to authenticate user connections

    dataEviction String

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence String

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    enableTls Boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi Boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies List<String>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    modules List<Property Map>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name String

    A meaningful name to identify the database

    password String

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath String

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port Number

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    protocol String

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    remoteBackup Property Map

    Specifies the backup options for the database, documented below

    replicaOfs List<String>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication Boolean

    Databases replication. Default: ‘true’

    sourceIps List<String>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    supportOssClusterApi Boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    Outputs

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

    DbId int

    Identifier of the database created

    Id string

    The provider-assigned unique ID for this managed resource.

    PrivateEndpoint string

    Private endpoint to access the database

    PublicEndpoint string

    Public endpoint to access the database

    DbId int

    Identifier of the database created

    Id string

    The provider-assigned unique ID for this managed resource.

    PrivateEndpoint string

    Private endpoint to access the database

    PublicEndpoint string

    Public endpoint to access the database

    dbId Integer

    Identifier of the database created

    id String

    The provider-assigned unique ID for this managed resource.

    privateEndpoint String

    Private endpoint to access the database

    publicEndpoint String

    Public endpoint to access the database

    dbId number

    Identifier of the database created

    id string

    The provider-assigned unique ID for this managed resource.

    privateEndpoint string

    Private endpoint to access the database

    publicEndpoint string

    Public endpoint to access the database

    db_id int

    Identifier of the database created

    id str

    The provider-assigned unique ID for this managed resource.

    private_endpoint str

    Private endpoint to access the database

    public_endpoint str

    Public endpoint to access the database

    dbId Number

    Identifier of the database created

    id String

    The provider-assigned unique ID for this managed resource.

    privateEndpoint String

    Private endpoint to access the database

    publicEndpoint String

    Public endpoint to access the database

    Look up Existing SubscriptionDatabase Resource

    Get an existing SubscriptionDatabase 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?: SubscriptionDatabaseState, opts?: CustomResourceOptions): SubscriptionDatabase
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            alerts: Optional[Sequence[SubscriptionDatabaseAlertArgs]] = None,
            average_item_size_in_bytes: Optional[int] = None,
            client_ssl_certificate: Optional[str] = None,
            data_eviction: Optional[str] = None,
            data_persistence: Optional[str] = None,
            db_id: Optional[int] = None,
            enable_tls: Optional[bool] = None,
            external_endpoint_for_oss_cluster_api: Optional[bool] = None,
            hashing_policies: Optional[Sequence[str]] = None,
            memory_limit_in_gb: Optional[float] = None,
            modules: Optional[Sequence[SubscriptionDatabaseModuleArgs]] = None,
            name: Optional[str] = None,
            password: Optional[str] = None,
            periodic_backup_path: Optional[str] = None,
            port: Optional[int] = None,
            private_endpoint: Optional[str] = None,
            protocol: Optional[str] = None,
            public_endpoint: Optional[str] = None,
            remote_backup: Optional[SubscriptionDatabaseRemoteBackupArgs] = None,
            replica_ofs: Optional[Sequence[str]] = None,
            replication: Optional[bool] = None,
            source_ips: Optional[Sequence[str]] = None,
            subscription_id: Optional[str] = None,
            support_oss_cluster_api: Optional[bool] = None,
            throughput_measurement_by: Optional[str] = None,
            throughput_measurement_value: Optional[int] = None) -> SubscriptionDatabase
    func GetSubscriptionDatabase(ctx *Context, name string, id IDInput, state *SubscriptionDatabaseState, opts ...ResourceOption) (*SubscriptionDatabase, error)
    public static SubscriptionDatabase Get(string name, Input<string> id, SubscriptionDatabaseState? state, CustomResourceOptions? opts = null)
    public static SubscriptionDatabase get(String name, Output<String> id, SubscriptionDatabaseState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    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:
    Alerts List<RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseAlert>

    A block defining Redis database alert, documented below, can be specified multiple times

    AverageItemSizeInBytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    ClientSslCertificate string

    SSL certificate to authenticate user connections

    DataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    DataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    DbId int

    Identifier of the database created

    EnableTls bool

    Use TLS for authentication. Default: ‘false’

    ExternalEndpointForOssClusterApi bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    HashingPolicies List<string>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    MemoryLimitInGb double

    Maximum memory usage for this specific database

    Modules List<RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseModule>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    Name string

    A meaningful name to identify the database

    Password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    PeriodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    Port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    PrivateEndpoint string

    Private endpoint to access the database

    Protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    PublicEndpoint string

    Public endpoint to access the database

    RemoteBackup RedisLabs.Rediscloud.Inputs.SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    ReplicaOfs List<string>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    Replication bool

    Databases replication. Default: ‘true’

    SourceIps List<string>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    SubscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    SupportOssClusterApi bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    ThroughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    ThroughputMeasurementValue int

    Throughput value (as applies to selected measurement method)

    Alerts []SubscriptionDatabaseAlertArgs

    A block defining Redis database alert, documented below, can be specified multiple times

    AverageItemSizeInBytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    ClientSslCertificate string

    SSL certificate to authenticate user connections

    DataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    DataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    DbId int

    Identifier of the database created

    EnableTls bool

    Use TLS for authentication. Default: ‘false’

    ExternalEndpointForOssClusterApi bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    HashingPolicies []string

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    MemoryLimitInGb float64

    Maximum memory usage for this specific database

    Modules []SubscriptionDatabaseModuleArgs

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    Name string

    A meaningful name to identify the database

    Password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    PeriodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    Port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    PrivateEndpoint string

    Private endpoint to access the database

    Protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    PublicEndpoint string

    Public endpoint to access the database

    RemoteBackup SubscriptionDatabaseRemoteBackupArgs

    Specifies the backup options for the database, documented below

    ReplicaOfs []string

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    Replication bool

    Databases replication. Default: ‘true’

    SourceIps []string

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    SubscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    SupportOssClusterApi bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    ThroughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    ThroughputMeasurementValue int

    Throughput value (as applies to selected measurement method)

    alerts List<SubscriptionDatabaseAlert>

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes Integer

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate String

    SSL certificate to authenticate user connections

    dataEviction String

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence String

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    dbId Integer

    Identifier of the database created

    enableTls Boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi Boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies List<String>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    memoryLimitInGb Double

    Maximum memory usage for this specific database

    modules List<SubscriptionDatabaseModule>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name String

    A meaningful name to identify the database

    password String

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath String

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port Integer

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    privateEndpoint String

    Private endpoint to access the database

    protocol String

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    publicEndpoint String

    Public endpoint to access the database

    remoteBackup SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    replicaOfs List<String>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication Boolean

    Databases replication. Default: ‘true’

    sourceIps List<String>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    subscriptionId String

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    supportOssClusterApi Boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    throughputMeasurementBy String

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue Integer

    Throughput value (as applies to selected measurement method)

    alerts SubscriptionDatabaseAlert[]

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes number

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate string

    SSL certificate to authenticate user connections

    dataEviction string

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence string

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    dbId number

    Identifier of the database created

    enableTls boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies string[]

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    memoryLimitInGb number

    Maximum memory usage for this specific database

    modules SubscriptionDatabaseModule[]

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name string

    A meaningful name to identify the database

    password string

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath string

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port number

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    privateEndpoint string

    Private endpoint to access the database

    protocol string

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    publicEndpoint string

    Public endpoint to access the database

    remoteBackup SubscriptionDatabaseRemoteBackup

    Specifies the backup options for the database, documented below

    replicaOfs string[]

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication boolean

    Databases replication. Default: ‘true’

    sourceIps string[]

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    subscriptionId string

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    supportOssClusterApi boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    throughputMeasurementBy string

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue number

    Throughput value (as applies to selected measurement method)

    alerts Sequence[SubscriptionDatabaseAlertArgs]

    A block defining Redis database alert, documented below, can be specified multiple times

    average_item_size_in_bytes int

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    client_ssl_certificate str

    SSL certificate to authenticate user connections

    data_eviction str

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    data_persistence str

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    db_id int

    Identifier of the database created

    enable_tls bool

    Use TLS for authentication. Default: ‘false’

    external_endpoint_for_oss_cluster_api bool

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashing_policies Sequence[str]

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    memory_limit_in_gb float

    Maximum memory usage for this specific database

    modules Sequence[SubscriptionDatabaseModuleArgs]

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name str

    A meaningful name to identify the database

    password str

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodic_backup_path str

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port int

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    private_endpoint str

    Private endpoint to access the database

    protocol str

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    public_endpoint str

    Public endpoint to access the database

    remote_backup SubscriptionDatabaseRemoteBackupArgs

    Specifies the backup options for the database, documented below

    replica_ofs Sequence[str]

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication bool

    Databases replication. Default: ‘true’

    source_ips Sequence[str]

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    subscription_id str

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    support_oss_cluster_api bool

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    throughput_measurement_by str

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughput_measurement_value int

    Throughput value (as applies to selected measurement method)

    alerts List<Property Map>

    A block defining Redis database alert, documented below, can be specified multiple times

    averageItemSizeInBytes Number

    Relevant only to ram-and-flash clusters. Estimated average size (measured in bytes) of the items stored in the database. Default: 1000

    clientSslCertificate String

    SSL certificate to authenticate user connections

    dataEviction String

    The data items eviction policy (either: 'allkeys-lru', 'allkeys-lfu', 'allkeys-random', 'volatile-lru', 'volatile-lfu', 'volatile-random', 'volatile-ttl' or 'noeviction'). Default: 'volatile-lru'

    dataPersistence String

    Rate of database's storage data persistence (either: 'none', 'aof-every-1-second', 'aof-every-write', 'snapshot-every-1-hour', 'snapshot-every-6-hours' or 'snapshot-every-12-hours'). Default: ‘none’

    dbId Number

    Identifier of the database created

    enableTls Boolean

    Use TLS for authentication. Default: ‘false’

    externalEndpointForOssClusterApi Boolean

    Should use the external endpoint for open-source (OSS) Cluster API. Can only be enabled if OSS Cluster API support is enabled. Default: 'false'

    hashingPolicies List<String>

    List of regular expression rules to shard the database by. See the documentation on clustering for more information on the hashing policy. This cannot be set when support_oss_cluster_api is set to true.

    memoryLimitInGb Number

    Maximum memory usage for this specific database

    modules List<Property Map>

    A list of modules objects, documented below. Modifying this attribute will force creation of a new resource.

    name String

    A meaningful name to identify the database

    password String

    Password to access the database. If omitted, a random 32 character long alphanumeric password will be automatically generated

    periodicBackupPath String

    Path that will be used to store database backup files. Deprecated: Use remote_backup block instead

    Deprecated:

    Use remote_backup block instead

    port Number

    TCP port on which the database is available - must be between 10000 and 19999. Modifying this attribute will force creation of a new resource.

    privateEndpoint String

    Private endpoint to access the database

    protocol String

    The protocol that will be used to access the database, (either ‘redis’ or ‘memcached’) Default: ‘redis’. Modifying this attribute will force creation of a new resource.

    publicEndpoint String

    Public endpoint to access the database

    remoteBackup Property Map

    Specifies the backup options for the database, documented below

    replicaOfs List<String>

    Set of Redis database URIs, in the format redis://user:password@host:port, that this database will be a replica of. If the URI provided is Redis Labs Cloud instance, only host and port should be provided. Cannot be enabled when support_oss_cluster_api is enabled.

    replication Boolean

    Databases replication. Default: ‘true’

    sourceIps List<String>

    List of source IP addresses or subnet masks. If specified, Redis clients will be able to connect to this database only from within the specified source IP addresses ranges (example: [‘192.168.10.0/32’, ‘192.168.12.0/24’])

    subscriptionId String

    The ID of the subscription to create the database in. Modifying this attribute will force creation of a new resource.

    supportOssClusterApi Boolean

    Support Redis open-source (OSS) Cluster API. Default: ‘false’

    throughputMeasurementBy String

    Throughput measurement method, (either ‘number-of-shards’ or ‘operations-per-second’)

    throughputMeasurementValue Number

    Throughput value (as applies to selected measurement method)

    Supporting Types

    SubscriptionDatabaseAlert, SubscriptionDatabaseAlertArgs

    Name string

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    Value int

    Alert value

    Name string

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    Value int

    Alert value

    name String

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    value Integer

    Alert value

    name string

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    value number

    Alert value

    name str

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    value int

    Alert value

    name String

    Alert name. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    value Number

    Alert value

    SubscriptionDatabaseModule, SubscriptionDatabaseModuleArgs

    Name string

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    
    Name string

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    
    name String

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    
    name string

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    
    name str

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    
    name String

    Name of the Redis database module to enable. Modifying this attribute will force creation of a new resource.

    Example:

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

    const modules = [ { name: "RedisJSON", }, { name: "RedisBloom", }, ];

    import pulumi
    
    modules = [
        {
            "name": "RedisJSON",
        },
        {
            "name": "RedisBloom",
        },
    ]
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    
    return await Deployment.RunAsync(() => 
    {
        var modules = new[]
        {
            
            {
                { "name", "RedisJSON" },
            },
            
            {
                { "name", "RedisBloom" },
            },
        };
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_ := []map[string]interface{}{
    			map[string]interface{}{
    				"name": "RedisJSON",
    			},
    			map[string]interface{}{
    				"name": "RedisBloom",
    			},
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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 modules =         
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);
    
        }
    }
    
    variables:
      modules:
        - name: RedisJSON
        - name: RedisBloom
    

    SubscriptionDatabaseRemoteBackup, SubscriptionDatabaseRemoteBackupArgs

    Interval string

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    StoragePath string

    Defines a URI representing the backup storage location

    StorageType string

    Defines the provider of the storage location

    TimeUtc string

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    Interval string

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    StoragePath string

    Defines a URI representing the backup storage location

    StorageType string

    Defines the provider of the storage location

    TimeUtc string

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    interval String

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    storagePath String

    Defines a URI representing the backup storage location

    storageType String

    Defines the provider of the storage location

    timeUtc String

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    interval string

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    storagePath string

    Defines a URI representing the backup storage location

    storageType string

    Defines the provider of the storage location

    timeUtc string

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    interval str

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    storage_path str

    Defines a URI representing the backup storage location

    storage_type str

    Defines the provider of the storage location

    time_utc str

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    interval String

    Defines the interval between backups. Should be in the following format 'every-x-hours'. x is one of [24,12,6,4,2,1]. For example: 'every-4-hours'

    storagePath String

    Defines a URI representing the backup storage location

    storageType String

    Defines the provider of the storage location

    timeUtc String

    Defines the hour automatic backups are made - only applicable when the interval is every-12-hours or every-24-hours. For example: '14:00'

    Import

    rediscloud_subscription_database can be imported using the ID of the subscription and the ID of the database in the format {subscription ID}/{database ID}, e.g.

     $ pulumi import rediscloud:index/subscriptionDatabase:SubscriptionDatabase database-resource 123456/12345678
    

    Package Details

    Repository
    rediscloud RedisLabs/pulumi-rediscloud
    License
    Apache-2.0
    Notes

    This Pulumi package is based on the rediscloud Terraform Provider.

    rediscloud logo
    Redis Cloud v1.3.1 published on Friday, Sep 29, 2023 by RedisLabs