Docs Packages
  1. Packages
  2. RedisCloud
  3. API Docs
  4. ActiveActiveSubscriptionDatabase
Redis Cloud v1.3.1 published on Friday, Sep 29, 2023 by RedisLabs
RedisLabs/pulumi-rediscloud

rediscloud.ActiveActiveSubscriptionDatabase

Explore with Pulumi AI

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

    Creates a Database within a specified Active-Active 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.ActiveActiveSubscription("subscription-resource", new()
    {
        PaymentMethodId = card.Apply(getPaymentMethodResult => getPaymentMethodResult.Id),
        CloudProvider = "AWS",
        CreationPlan = new Rediscloud.Inputs.ActiveActiveSubscriptionCreationPlanArgs
        {
            MemoryLimitInGb = 1,
            Quantity = 1,
            Regions = new[]
            {
                new Rediscloud.Inputs.ActiveActiveSubscriptionCreationPlanRegionArgs
                {
                    Region = "us-east-1",
                    NetworkingDeploymentCidr = "192.168.0.0/24",
                    WriteOperationsPerSecond = 1000,
                    ReadOperationsPerSecond = 1000,
                },
                new Rediscloud.Inputs.ActiveActiveSubscriptionCreationPlanRegionArgs
                {
                    Region = "us-east-2",
                    NetworkingDeploymentCidr = "10.0.1.0/24",
                    WriteOperationsPerSecond = 1000,
                    ReadOperationsPerSecond = 2000,
                },
            },
        },
    });

    var database_resource = new Rediscloud.ActiveActiveSubscriptionDatabase("database-resource", new()
    {
        SubscriptionId = subscription_resource.Id,
        MemoryLimitInGb = 1,
        GlobalDataPersistence = "aof-every-1-second",
        GlobalPassword = "some-random-pass-2",
        GlobalSourceIps = new[]
        {
            "192.168.0.0/16",
        },
        GlobalAlerts = new[]
        {
            new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseGlobalAlertArgs
            {
                Name = "dataset-size",
                Value = 40,
            },
        },
        OverrideRegions = new[]
        {
            new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs
            {
                Name = "us-east-2",
                OverrideGlobalSourceIps = new[]
                {
                    "192.10.0.0/16",
                },
            },
            new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs
            {
                Name = "us-east-1",
                OverrideGlobalDataPersistence = "none",
                OverrideGlobalPassword = "region-specific-password",
                OverrideGlobalAlerts = new[]
                {
                    new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs
                    {
                        Name = "dataset-size",
                        Value = 60,
                    },
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["us-east-1-public-endpoints"] = database_resource.PublicEndpoint.Apply(publicEndpoint => publicEndpoint.Us_east_1),
        ["us-east-2-private-endpoints"] = database_resource.PrivateEndpoint.Apply(privateEndpoint => privateEndpoint.Us_east_1),
    };
});

    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.NewActiveActiveSubscription(ctx, "subscription-resource", &rediscloud.ActiveActiveSubscriptionArgs{
			PaymentMethodId: *pulumi.String(card.Id),
			CloudProvider:   pulumi.String("AWS"),
			CreationPlan: &rediscloud.ActiveActiveSubscriptionCreationPlanArgs{
				MemoryLimitInGb: pulumi.Float64(1),
				Quantity:        pulumi.Int(1),
				Regions: rediscloud.ActiveActiveSubscriptionCreationPlanRegionArray{
					&rediscloud.ActiveActiveSubscriptionCreationPlanRegionArgs{
						Region:                   pulumi.String("us-east-1"),
						NetworkingDeploymentCidr: pulumi.String("192.168.0.0/24"),
						WriteOperationsPerSecond: pulumi.Int(1000),
						ReadOperationsPerSecond:  pulumi.Int(1000),
					},
					&rediscloud.ActiveActiveSubscriptionCreationPlanRegionArgs{
						Region:                   pulumi.String("us-east-2"),
						NetworkingDeploymentCidr: pulumi.String("10.0.1.0/24"),
						WriteOperationsPerSecond: pulumi.Int(1000),
						ReadOperationsPerSecond:  pulumi.Int(2000),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = rediscloud.NewActiveActiveSubscriptionDatabase(ctx, "database-resource", &rediscloud.ActiveActiveSubscriptionDatabaseArgs{
			SubscriptionId:        subscription_resource.ID(),
			MemoryLimitInGb:       pulumi.Float64(1),
			GlobalDataPersistence: pulumi.String("aof-every-1-second"),
			GlobalPassword:        pulumi.String("some-random-pass-2"),
			GlobalSourceIps: pulumi.StringArray{
				pulumi.String("192.168.0.0/16"),
			},
			GlobalAlerts: rediscloud.ActiveActiveSubscriptionDatabaseGlobalAlertArray{
				&rediscloud.ActiveActiveSubscriptionDatabaseGlobalAlertArgs{
					Name:  pulumi.String("dataset-size"),
					Value: pulumi.Int(40),
				},
			},
			OverrideRegions: rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArray{
				&rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArgs{
					Name: pulumi.String("us-east-2"),
					OverrideGlobalSourceIps: pulumi.StringArray{
						pulumi.String("192.10.0.0/16"),
					},
				},
				&rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArgs{
					Name:                          pulumi.String("us-east-1"),
					OverrideGlobalDataPersistence: pulumi.String("none"),
					OverrideGlobalPassword:        pulumi.String("region-specific-password"),
					OverrideGlobalAlerts: rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArray{
						&rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs{
							Name:  pulumi.String("dataset-size"),
							Value: pulumi.Int(60),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("us-east-1-public-endpoints", database_resource.PublicEndpoint.ApplyT(func(publicEndpoint map[string]string) (string, error) {
			return publicEndpoint.UsEast1, nil
		}).(pulumi.StringOutput))
		ctx.Export("us-east-2-private-endpoints", database_resource.PrivateEndpoint.ApplyT(func(privateEndpoint map[string]string) (string, error) {
			return privateEndpoint.UsEast1, nil
		}).(pulumi.StringOutput))
		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.ActiveActiveSubscription;
import com.pulumi.rediscloud.ActiveActiveSubscriptionArgs;
import com.pulumi.rediscloud.inputs.ActiveActiveSubscriptionCreationPlanArgs;
import com.pulumi.rediscloud.ActiveActiveSubscriptionDatabase;
import com.pulumi.rediscloud.ActiveActiveSubscriptionDatabaseArgs;
import com.pulumi.rediscloud.inputs.ActiveActiveSubscriptionDatabaseGlobalAlertArgs;
import com.pulumi.rediscloud.inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs;
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 ActiveActiveSubscription("subscription-resource", ActiveActiveSubscriptionArgs.builder()        
            .paymentMethodId(card.applyValue(getPaymentMethodResult -> getPaymentMethodResult.id()))
            .cloudProvider("AWS")
            .creationPlan(ActiveActiveSubscriptionCreationPlanArgs.builder()
                .memoryLimitInGb(1)
                .quantity(1)
                .regions(                
                    ActiveActiveSubscriptionCreationPlanRegionArgs.builder()
                        .region("us-east-1")
                        .networkingDeploymentCidr("192.168.0.0/24")
                        .writeOperationsPerSecond(1000)
                        .readOperationsPerSecond(1000)
                        .build(),
                    ActiveActiveSubscriptionCreationPlanRegionArgs.builder()
                        .region("us-east-2")
                        .networkingDeploymentCidr("10.0.1.0/24")
                        .writeOperationsPerSecond(1000)
                        .readOperationsPerSecond(2000)
                        .build())
                .build())
            .build());

        var database_resource = new ActiveActiveSubscriptionDatabase("database-resource", ActiveActiveSubscriptionDatabaseArgs.builder()        
            .subscriptionId(subscription_resource.id())
            .memoryLimitInGb(1)
            .globalDataPersistence("aof-every-1-second")
            .globalPassword("some-random-pass-2")
            .globalSourceIps("192.168.0.0/16")
            .globalAlerts(ActiveActiveSubscriptionDatabaseGlobalAlertArgs.builder()
                .name("dataset-size")
                .value(40)
                .build())
            .overrideRegions(            
                ActiveActiveSubscriptionDatabaseOverrideRegionArgs.builder()
                    .name("us-east-2")
                    .overrideGlobalSourceIps("192.10.0.0/16")
                    .build(),
                ActiveActiveSubscriptionDatabaseOverrideRegionArgs.builder()
                    .name("us-east-1")
                    .overrideGlobalDataPersistence("none")
                    .overrideGlobalPassword("region-specific-password")
                    .overrideGlobalAlerts(ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs.builder()
                        .name("dataset-size")
                        .value(60)
                        .build())
                    .build())
            .build());

        ctx.export("us-east-1-public-endpoints", database_resource.publicEndpoint().applyValue(publicEndpoint -> publicEndpoint.us-east-1()));
        ctx.export("us-east-2-private-endpoints", database_resource.privateEndpoint().applyValue(privateEndpoint -> privateEndpoint.us-east-1()));
    }
}

    import pulumi
import pulumi_rediscloud as rediscloud

card = rediscloud.get_payment_method(card_type="Visa")
subscription_resource = rediscloud.ActiveActiveSubscription("subscription-resource",
    payment_method_id=card.id,
    cloud_provider="AWS",
    creation_plan=rediscloud.ActiveActiveSubscriptionCreationPlanArgs(
        memory_limit_in_gb=1,
        quantity=1,
        regions=[
            rediscloud.ActiveActiveSubscriptionCreationPlanRegionArgs(
                region="us-east-1",
                networking_deployment_cidr="192.168.0.0/24",
                write_operations_per_second=1000,
                read_operations_per_second=1000,
            ),
            rediscloud.ActiveActiveSubscriptionCreationPlanRegionArgs(
                region="us-east-2",
                networking_deployment_cidr="10.0.1.0/24",
                write_operations_per_second=1000,
                read_operations_per_second=2000,
            ),
        ],
    ))
database_resource = rediscloud.ActiveActiveSubscriptionDatabase("database-resource",
    subscription_id=subscription_resource.id,
    memory_limit_in_gb=1,
    global_data_persistence="aof-every-1-second",
    global_password="some-random-pass-2",
    global_source_ips=["192.168.0.0/16"],
    global_alerts=[rediscloud.ActiveActiveSubscriptionDatabaseGlobalAlertArgs(
        name="dataset-size",
        value=40,
    )],
    override_regions=[
        rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArgs(
            name="us-east-2",
            override_global_source_ips=["192.10.0.0/16"],
        ),
        rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArgs(
            name="us-east-1",
            override_global_data_persistence="none",
            override_global_password="region-specific-password",
            override_global_alerts=[rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs(
                name="dataset-size",
                value=60,
            )],
        ),
    ])
pulumi.export("us-east-1-public-endpoints", database_resource.public_endpoint["us-east-1"])
pulumi.export("us-east-2-private-endpoints", database_resource.private_endpoint["us-east-1"])

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

export = async () => {
    const card = await rediscloud.getPaymentMethod({
        cardType: "Visa",
    });
    const subscription_resource = new rediscloud.ActiveActiveSubscription("subscription-resource", {
        paymentMethodId: card.id,
        cloudProvider: "AWS",
        creationPlan: {
            memoryLimitInGb: 1,
            quantity: 1,
            regions: [
                {
                    region: "us-east-1",
                    networkingDeploymentCidr: "192.168.0.0/24",
                    writeOperationsPerSecond: 1000,
                    readOperationsPerSecond: 1000,
                },
                {
                    region: "us-east-2",
                    networkingDeploymentCidr: "10.0.1.0/24",
                    writeOperationsPerSecond: 1000,
                    readOperationsPerSecond: 2000,
                },
            ],
        },
    });
    const database_resource = new rediscloud.ActiveActiveSubscriptionDatabase("database-resource", {
        subscriptionId: subscription_resource.id,
        memoryLimitInGb: 1,
        globalDataPersistence: "aof-every-1-second",
        globalPassword: "some-random-pass-2",
        globalSourceIps: ["192.168.0.0/16"],
        globalAlerts: [{
            name: "dataset-size",
            value: 40,
        }],
        overrideRegions: [
            {
                name: "us-east-2",
                overrideGlobalSourceIps: ["192.10.0.0/16"],
            },
            {
                name: "us-east-1",
                overrideGlobalDataPersistence: "none",
                overrideGlobalPassword: "region-specific-password",
                overrideGlobalAlerts: [{
                    name: "dataset-size",
                    value: 60,
                }],
            },
        ],
    });
    return {
        "us-east-1-public-endpoints": database_resource.publicEndpoint["us-east-1"],
        "us-east-2-private-endpoints": database_resource.privateEndpoint["us-east-1"],
    };
}

    resources:
  subscription-resource:
    type: rediscloud:ActiveActiveSubscription
    properties:
      paymentMethodId: ${card.id}
      cloudProvider: AWS
      creationPlan:
        memoryLimitInGb: 1
        quantity: 1
        regions:
          - region: us-east-1
            networkingDeploymentCidr: 192.168.0.0/24
            writeOperationsPerSecond: 1000
            readOperationsPerSecond: 1000
          - region: us-east-2
            networkingDeploymentCidr: 10.0.1.0/24
            writeOperationsPerSecond: 1000
            readOperationsPerSecond: 2000
  database-resource:
    type: rediscloud:ActiveActiveSubscriptionDatabase
    properties:
      subscriptionId: ${["subscription-resource"].id}
      memoryLimitInGb: 1
      globalDataPersistence: aof-every-1-second
      globalPassword: some-random-pass-2
      globalSourceIps:
        - 192.168.0.0/16
      globalAlerts:
        - name: dataset-size
          value: 40
      overrideRegions:
        - name: us-east-2
          overrideGlobalSourceIps:
            - 192.10.0.0/16
        - name: us-east-1
          overrideGlobalDataPersistence: none
          overrideGlobalPassword: region-specific-password
          overrideGlobalAlerts:
            - name: dataset-size
              value: 60
variables:
  card:
    fn::invoke:
      Function: rediscloud:getPaymentMethod
      Arguments:
        cardType: Visa
outputs:
  us-east-1-public-endpoints: ${["database-resource"].publicEndpoint"us-east-1"[%!s(MISSING)]}
  us-east-2-private-endpoints: ${["database-resource"].privateEndpoint"us-east-1"[%!s(MISSING)]}

    Create ActiveActiveSubscriptionDatabase Resource

    new ActiveActiveSubscriptionDatabase(name: string, args: ActiveActiveSubscriptionDatabaseArgs, opts?: CustomResourceOptions);
    @overload
def ActiveActiveSubscriptionDatabase(resource_name: str,
                                     opts: Optional[ResourceOptions] = None,
                                     client_ssl_certificate: Optional[str] = None,
                                     data_eviction: Optional[str] = None,
                                     enable_tls: Optional[bool] = None,
                                     external_endpoint_for_oss_cluster_api: Optional[bool] = None,
                                     global_alerts: Optional[Sequence[ActiveActiveSubscriptionDatabaseGlobalAlertArgs]] = None,
                                     global_data_persistence: Optional[str] = None,
                                     global_password: Optional[str] = None,
                                     global_source_ips: Optional[Sequence[str]] = None,
                                     memory_limit_in_gb: Optional[float] = None,
                                     name: Optional[str] = None,
                                     override_regions: Optional[Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]] = None,
                                     port: Optional[int] = None,
                                     subscription_id: Optional[str] = None,
                                     support_oss_cluster_api: Optional[bool] = None)
@overload
def ActiveActiveSubscriptionDatabase(resource_name: str,
                                     args: ActiveActiveSubscriptionDatabaseArgs,
                                     opts: Optional[ResourceOptions] = None)
    func NewActiveActiveSubscriptionDatabase(ctx *Context, name string, args ActiveActiveSubscriptionDatabaseArgs, opts ...ResourceOption) (*ActiveActiveSubscriptionDatabase, error)
    public ActiveActiveSubscriptionDatabase(string name, ActiveActiveSubscriptionDatabaseArgs args, CustomResourceOptions? opts = null)
    public ActiveActiveSubscriptionDatabase(String name, ActiveActiveSubscriptionDatabaseArgs args)
public ActiveActiveSubscriptionDatabase(String name, ActiveActiveSubscriptionDatabaseArgs args, CustomResourceOptions options)

    type: rediscloud:ActiveActiveSubscriptionDatabase
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ActiveActiveSubscriptionDatabaseArgs
    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 ActiveActiveSubscriptionDatabaseArgs
    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 ActiveActiveSubscriptionDatabaseArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ActiveActiveSubscriptionDatabaseArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ActiveActiveSubscriptionDatabaseArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    ActiveActiveSubscriptionDatabase 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 ActiveActiveSubscriptionDatabase resource accepts the following input properties:

    MemoryLimitInGb double

    Maximum memory usage for this specific database, including replication and other overhead

    SubscriptionId string

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

    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')

    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'

    GlobalAlerts List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseGlobalAlert>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    GlobalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    GlobalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    GlobalSourceIps List<string>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    OverrideRegions List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegion>

    Override region specific configuration, documented below

    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.

    SupportOssClusterApi bool

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

    MemoryLimitInGb float64

    Maximum memory usage for this specific database, including replication and other overhead

    SubscriptionId string

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

    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')

    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'

    GlobalAlerts []ActiveActiveSubscriptionDatabaseGlobalAlertArgs

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    GlobalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    GlobalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    GlobalSourceIps []string

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    OverrideRegions []ActiveActiveSubscriptionDatabaseOverrideRegionArgs

    Override region specific configuration, documented below

    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.

    SupportOssClusterApi bool

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

    memoryLimitInGb Double

    Maximum memory usage for this specific database, including replication and other overhead

    subscriptionId String

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

    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')

    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'

    globalAlerts List<ActiveActiveSubscriptionDatabaseGlobalAlert>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence String

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword String

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps List<String>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions List<ActiveActiveSubscriptionDatabaseOverrideRegion>

    Override region specific configuration, documented below

    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.

    supportOssClusterApi Boolean

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

    memoryLimitInGb number

    Maximum memory usage for this specific database, including replication and other overhead

    subscriptionId string

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

    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')

    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'

    globalAlerts ActiveActiveSubscriptionDatabaseGlobalAlert[]

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps string[]

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions ActiveActiveSubscriptionDatabaseOverrideRegion[]

    Override region specific configuration, documented below

    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.

    supportOssClusterApi boolean

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

    memory_limit_in_gb float

    Maximum memory usage for this specific database, including replication and other overhead

    subscription_id str

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

    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')

    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'

    global_alerts Sequence[ActiveActiveSubscriptionDatabaseGlobalAlertArgs]

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    global_data_persistence str

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    global_password str

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    global_source_ips Sequence[str]

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    name str

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    override_regions Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]

    Override region specific configuration, documented below

    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.

    support_oss_cluster_api bool

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

    memoryLimitInGb Number

    Maximum memory usage for this specific database, including replication and other overhead

    subscriptionId String

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

    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')

    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'

    globalAlerts List<Property Map>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence String

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword String

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps List<String>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions List<Property Map>

    Override region specific configuration, documented below

    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.

    supportOssClusterApi Boolean

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

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ActiveActiveSubscriptionDatabase 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 Dictionary<string, string>

    A map of which private endpoints can to access the database per region, uses region name as key.

    PublicEndpoint Dictionary<string, string>

    A map of which public endpoints can to access the database per region, uses region name as key.

    DbId int

    Identifier of the database created

    Id string

    The provider-assigned unique ID for this managed resource.

    PrivateEndpoint map[string]string

    A map of which private endpoints can to access the database per region, uses region name as key.

    PublicEndpoint map[string]string

    A map of which public endpoints can to access the database per region, uses region name as key.

    dbId Integer

    Identifier of the database created

    id String

    The provider-assigned unique ID for this managed resource.

    privateEndpoint Map<String,String>

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint Map<String,String>

    A map of which public endpoints can to access the database per region, uses region name as key.

    dbId number

    Identifier of the database created

    id string

    The provider-assigned unique ID for this managed resource.

    privateEndpoint {[key: string]: string}

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint {[key: string]: string}

    A map of which public endpoints can to access the database per region, uses region name as key.

    db_id int

    Identifier of the database created

    id str

    The provider-assigned unique ID for this managed resource.

    private_endpoint Mapping[str, str]

    A map of which private endpoints can to access the database per region, uses region name as key.

    public_endpoint Mapping[str, str]

    A map of which public endpoints can to access the database per region, uses region name as key.

    dbId Number

    Identifier of the database created

    id String

    The provider-assigned unique ID for this managed resource.

    privateEndpoint Map<String>

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint Map<String>

    A map of which public endpoints can to access the database per region, uses region name as key.

    Look up Existing ActiveActiveSubscriptionDatabase Resource

    Get an existing ActiveActiveSubscriptionDatabase 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?: ActiveActiveSubscriptionDatabaseState, opts?: CustomResourceOptions): ActiveActiveSubscriptionDatabase
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        client_ssl_certificate: Optional[str] = None,
        data_eviction: Optional[str] = None,
        db_id: Optional[int] = None,
        enable_tls: Optional[bool] = None,
        external_endpoint_for_oss_cluster_api: Optional[bool] = None,
        global_alerts: Optional[Sequence[ActiveActiveSubscriptionDatabaseGlobalAlertArgs]] = None,
        global_data_persistence: Optional[str] = None,
        global_password: Optional[str] = None,
        global_source_ips: Optional[Sequence[str]] = None,
        memory_limit_in_gb: Optional[float] = None,
        name: Optional[str] = None,
        override_regions: Optional[Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]] = None,
        port: Optional[int] = None,
        private_endpoint: Optional[Mapping[str, str]] = None,
        public_endpoint: Optional[Mapping[str, str]] = None,
        subscription_id: Optional[str] = None,
        support_oss_cluster_api: Optional[bool] = None) -> ActiveActiveSubscriptionDatabase
    func GetActiveActiveSubscriptionDatabase(ctx *Context, name string, id IDInput, state *ActiveActiveSubscriptionDatabaseState, opts ...ResourceOption) (*ActiveActiveSubscriptionDatabase, error)
    public static ActiveActiveSubscriptionDatabase Get(string name, Input<string> id, ActiveActiveSubscriptionDatabaseState? state, CustomResourceOptions? opts = null)
    public static ActiveActiveSubscriptionDatabase get(String name, Output<String> id, ActiveActiveSubscriptionDatabaseState 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:
    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')

    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'

    GlobalAlerts List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseGlobalAlert>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    GlobalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    GlobalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    GlobalSourceIps List<string>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    MemoryLimitInGb double

    Maximum memory usage for this specific database, including replication and other overhead

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    OverrideRegions List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegion>

    Override region specific configuration, documented below

    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 Dictionary<string, string>

    A map of which private endpoints can to access the database per region, uses region name as key.

    PublicEndpoint Dictionary<string, string>

    A map of which public endpoints can to access the database per region, uses region name as key.

    SubscriptionId string

    The ID of the Active-Active 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’

    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')

    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'

    GlobalAlerts []ActiveActiveSubscriptionDatabaseGlobalAlertArgs

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    GlobalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    GlobalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    GlobalSourceIps []string

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    MemoryLimitInGb float64

    Maximum memory usage for this specific database, including replication and other overhead

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    OverrideRegions []ActiveActiveSubscriptionDatabaseOverrideRegionArgs

    Override region specific configuration, documented below

    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 map[string]string

    A map of which private endpoints can to access the database per region, uses region name as key.

    PublicEndpoint map[string]string

    A map of which public endpoints can to access the database per region, uses region name as key.

    SubscriptionId string

    The ID of the Active-Active 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’

    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')

    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'

    globalAlerts List<ActiveActiveSubscriptionDatabaseGlobalAlert>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence String

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword String

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps List<String>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    memoryLimitInGb Double

    Maximum memory usage for this specific database, including replication and other overhead

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions List<ActiveActiveSubscriptionDatabaseOverrideRegion>

    Override region specific configuration, documented below

    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 Map<String,String>

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint Map<String,String>

    A map of which public endpoints can to access the database per region, uses region name as key.

    subscriptionId String

    The ID of the Active-Active 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’

    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')

    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'

    globalAlerts ActiveActiveSubscriptionDatabaseGlobalAlert[]

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence string

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword string

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps string[]

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    memoryLimitInGb number

    Maximum memory usage for this specific database, including replication and other overhead

    name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions ActiveActiveSubscriptionDatabaseOverrideRegion[]

    Override region specific configuration, documented below

    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 {[key: string]: string}

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint {[key: string]: string}

    A map of which public endpoints can to access the database per region, uses region name as key.

    subscriptionId string

    The ID of the Active-Active 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’

    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')

    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'

    global_alerts Sequence[ActiveActiveSubscriptionDatabaseGlobalAlertArgs]

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    global_data_persistence str

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    global_password str

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    global_source_ips Sequence[str]

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    memory_limit_in_gb float

    Maximum memory usage for this specific database, including replication and other overhead

    name str

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    override_regions Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]

    Override region specific configuration, documented below

    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 Mapping[str, str]

    A map of which private endpoints can to access the database per region, uses region name as key.

    public_endpoint Mapping[str, str]

    A map of which public endpoints can to access the database per region, uses region name as key.

    subscription_id str

    The ID of the Active-Active 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’

    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')

    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'

    globalAlerts List<Property Map>

    A block defining Redis database alert of regions that don't override global settings, documented below, can be specified multiple times. (either: 'dataset-size', 'datasets-size', 'throughput-higher-than', 'throughput-lower-than', 'latency', 'syncsource-error', 'syncsource-lag' or 'connections-limit')

    globalDataPersistence String

    Global rate of database data persistence (in persistent storage) of regions that dont override global settings. Default: 'none'

    globalPassword String

    Password to access the database of regions that don't override global settings. If left empty, the password will be generated automatically

    globalSourceIps List<String>

    List of source IP addresses or subnet masks of regions that don't override global settings. 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'])

    memoryLimitInGb Number

    Maximum memory usage for this specific database, including replication and other overhead

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    overrideRegions List<Property Map>

    Override region specific configuration, documented below

    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 Map<String>

    A map of which private endpoints can to access the database per region, uses region name as key.

    publicEndpoint Map<String>

    A map of which public endpoints can to access the database per region, uses region name as key.

    subscriptionId String

    The ID of the Active-Active 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’

    Supporting Types

    ActiveActiveSubscriptionDatabaseGlobalAlert, ActiveActiveSubscriptionDatabaseGlobalAlertArgs

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    Value int

    Alert value

    Name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    Value int

    Alert value

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    value Integer

    Alert value

    name string

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    value number

    Alert value

    name str

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    value int

    Alert value

    name String

    A meaningful name to identify the database. Modifying this attribute will force creation of a new resource.

    value Number

    Alert value

    ActiveActiveSubscriptionDatabaseOverrideRegion, ActiveActiveSubscriptionDatabaseOverrideRegionArgs

    Name string

    Region name.

    OverrideGlobalAlerts List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert>

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    OverrideGlobalDataPersistence string

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    OverrideGlobalPassword string

    If specified, this regional instance of an Active-Active database password will be used to access the database

    OverrideGlobalSourceIps List<string>

    List of regional instance of an Active-Active database 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'] )

    RemoteBackup RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup

    Specifies the backup options for the database in this region, documented below

    Name string

    Region name.

    OverrideGlobalAlerts []ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    OverrideGlobalDataPersistence string

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    OverrideGlobalPassword string

    If specified, this regional instance of an Active-Active database password will be used to access the database

    OverrideGlobalSourceIps []string

    List of regional instance of an Active-Active database 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'] )

    RemoteBackup ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup

    Specifies the backup options for the database in this region, documented below

    name String

    Region name.

    overrideGlobalAlerts List<ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert>

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    overrideGlobalDataPersistence String

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    overrideGlobalPassword String

    If specified, this regional instance of an Active-Active database password will be used to access the database

    overrideGlobalSourceIps List<String>

    List of regional instance of an Active-Active database 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'] )

    remoteBackup ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup

    Specifies the backup options for the database in this region, documented below

    name string

    Region name.

    overrideGlobalAlerts ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert[]

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    overrideGlobalDataPersistence string

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    overrideGlobalPassword string

    If specified, this regional instance of an Active-Active database password will be used to access the database

    overrideGlobalSourceIps string[]

    List of regional instance of an Active-Active database 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'] )

    remoteBackup ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup

    Specifies the backup options for the database in this region, documented below

    name str

    Region name.

    override_global_alerts Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert]

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    override_global_data_persistence str

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    override_global_password str

    If specified, this regional instance of an Active-Active database password will be used to access the database

    override_global_source_ips Sequence[str]

    List of regional instance of an Active-Active database 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'] )

    remote_backup ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup

    Specifies the backup options for the database in this region, documented below

    name String

    Region name.

    overrideGlobalAlerts List<Property Map>

    A block defining Redis regional instance of an Active-Active database alert, documented below, can be specified multiple times

    overrideGlobalDataPersistence String

    Regional instance of an Active-Active database data persistence rate (in persistent storage)

    overrideGlobalPassword String

    If specified, this regional instance of an Active-Active database password will be used to access the database

    overrideGlobalSourceIps List<String>

    List of regional instance of an Active-Active database 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'] )

    remoteBackup Property Map

    Specifies the backup options for the database in this region, documented below

    ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert, ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs

    Name string

    Alert name

    Value int

    Alert value

    Name string

    Alert name

    Value int

    Alert value

    name String

    Alert name

    value Integer

    Alert value

    name string

    Alert name

    value number

    Alert value

    name str

    Alert name

    value int

    Alert value

    name String

    Alert name

    value Number

    Alert value

    ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackup, ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackupArgs

    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_active_active_subscription_database can be imported using the ID of the Active-Active subscription and the ID of the database in the format {subscription ID}/{database ID}, e.g.

     $ pulumi import rediscloud:index/activeActiveSubscriptionDatabase:ActiveActiveSubscriptionDatabase database-resource 123456/12345678

    NoteDue to constraints in the Redis Cloud API, the import process will not import global attributes or override region attributes. If you wish to use these attributes in your Terraform configuration, you will need to manually add them to your Terraform configuration and run pulumi up to update the database.

    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
    RedisLabs/pulumi-rediscloud