Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. RedisCloud
  3. API Docs
  4. ActiveActiveSubscriptionDatabase
Redis Cloud v1.3.5 published on Wednesday, Dec 20, 2023 by RedisLabs
RedisLabs/pulumi-rediscloud

rediscloud.ActiveActiveSubscriptionDatabase

Explore with Pulumi AI

rediscloud logo
Redis Cloud v1.3.5 published on Wednesday, Dec 20, 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 * 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"],
    };
}

    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"])

    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

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

    Constructor syntax

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

@overload
def ActiveActiveSubscriptionDatabase(resource_name: str,
                                     opts: Optional[ResourceOptions] = None,
                                     memory_limit_in_gb: Optional[float] = None,
                                     subscription_id: Optional[str] = None,
                                     global_password: Optional[str] = None,
                                     external_endpoint_for_oss_cluster_api: Optional[bool] = None,
                                     global_alerts: Optional[Sequence[ActiveActiveSubscriptionDatabaseGlobalAlertArgs]] = None,
                                     global_data_persistence: Optional[str] = None,
                                     client_ssl_certificate: Optional[str] = None,
                                     global_source_ips: Optional[Sequence[str]] = None,
                                     enable_tls: Optional[bool] = None,
                                     name: Optional[str] = None,
                                     override_regions: Optional[Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]] = None,
                                     port: Optional[int] = None,
                                     data_eviction: Optional[str] = None,
                                     support_oss_cluster_api: Optional[bool] = 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.

    Parameters

    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.

    Constructor example

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

    var activeActiveSubscriptionDatabaseResource = new Rediscloud.ActiveActiveSubscriptionDatabase("activeActiveSubscriptionDatabaseResource", new()
{
    MemoryLimitInGb = 0,
    SubscriptionId = "string",
    GlobalPassword = "string",
    ExternalEndpointForOssClusterApi = false,
    GlobalAlerts = new[]
    {
        new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseGlobalAlertArgs
        {
            Name = "string",
            Value = 0,
        },
    },
    GlobalDataPersistence = "string",
    ClientSslCertificate = "string",
    GlobalSourceIps = new[]
    {
        "string",
    },
    EnableTls = false,
    Name = "string",
    OverrideRegions = new[]
    {
        new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs
        {
            Name = "string",
            OverrideGlobalAlerts = new[]
            {
                new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs
                {
                    Name = "string",
                    Value = 0,
                },
            },
            OverrideGlobalDataPersistence = "string",
            OverrideGlobalPassword = "string",
            OverrideGlobalSourceIps = new[]
            {
                "string",
            },
            RemoteBackup = new Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackupArgs
            {
                Interval = "string",
                StoragePath = "string",
                StorageType = "string",
                TimeUtc = "string",
            },
        },
    },
    Port = 0,
    DataEviction = "string",
    SupportOssClusterApi = false,
});

    example, err := rediscloud.NewActiveActiveSubscriptionDatabase(ctx, "activeActiveSubscriptionDatabaseResource", &rediscloud.ActiveActiveSubscriptionDatabaseArgs{
	MemoryLimitInGb:                  pulumi.Float64(0),
	SubscriptionId:                   pulumi.String("string"),
	GlobalPassword:                   pulumi.String("string"),
	ExternalEndpointForOssClusterApi: pulumi.Bool(false),
	GlobalAlerts: rediscloud.ActiveActiveSubscriptionDatabaseGlobalAlertArray{
		&rediscloud.ActiveActiveSubscriptionDatabaseGlobalAlertArgs{
			Name:  pulumi.String("string"),
			Value: pulumi.Int(0),
		},
	},
	GlobalDataPersistence: pulumi.String("string"),
	ClientSslCertificate:  pulumi.String("string"),
	GlobalSourceIps: pulumi.StringArray{
		pulumi.String("string"),
	},
	EnableTls: pulumi.Bool(false),
	Name:      pulumi.String("string"),
	OverrideRegions: rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArray{
		&rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionArgs{
			Name: pulumi.String("string"),
			OverrideGlobalAlerts: rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArray{
				&rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs{
					Name:  pulumi.String("string"),
					Value: pulumi.Int(0),
				},
			},
			OverrideGlobalDataPersistence: pulumi.String("string"),
			OverrideGlobalPassword:        pulumi.String("string"),
			OverrideGlobalSourceIps: pulumi.StringArray{
				pulumi.String("string"),
			},
			RemoteBackup: &rediscloud.ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackupArgs{
				Interval:    pulumi.String("string"),
				StoragePath: pulumi.String("string"),
				StorageType: pulumi.String("string"),
				TimeUtc:     pulumi.String("string"),
			},
		},
	},
	Port:                 pulumi.Int(0),
	DataEviction:         pulumi.String("string"),
	SupportOssClusterApi: pulumi.Bool(false),
})

    var activeActiveSubscriptionDatabaseResource = new ActiveActiveSubscriptionDatabase("activeActiveSubscriptionDatabaseResource", ActiveActiveSubscriptionDatabaseArgs.builder()
    .memoryLimitInGb(0.0)
    .subscriptionId("string")
    .globalPassword("string")
    .externalEndpointForOssClusterApi(false)
    .globalAlerts(ActiveActiveSubscriptionDatabaseGlobalAlertArgs.builder()
        .name("string")
        .value(0)
        .build())
    .globalDataPersistence("string")
    .clientSslCertificate("string")
    .globalSourceIps("string")
    .enableTls(false)
    .name("string")
    .overrideRegions(ActiveActiveSubscriptionDatabaseOverrideRegionArgs.builder()
        .name("string")
        .overrideGlobalAlerts(ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlertArgs.builder()
            .name("string")
            .value(0)
            .build())
        .overrideGlobalDataPersistence("string")
        .overrideGlobalPassword("string")
        .overrideGlobalSourceIps("string")
        .remoteBackup(ActiveActiveSubscriptionDatabaseOverrideRegionRemoteBackupArgs.builder()
            .interval("string")
            .storagePath("string")
            .storageType("string")
            .timeUtc("string")
            .build())
        .build())
    .port(0)
    .dataEviction("string")
    .supportOssClusterApi(false)
    .build());

    active_active_subscription_database_resource = rediscloud.ActiveActiveSubscriptionDatabase("activeActiveSubscriptionDatabaseResource",
    memory_limit_in_gb=0,
    subscription_id="string",
    global_password="string",
    external_endpoint_for_oss_cluster_api=False,
    global_alerts=[{
        "name": "string",
        "value": 0,
    }],
    global_data_persistence="string",
    client_ssl_certificate="string",
    global_source_ips=["string"],
    enable_tls=False,
    name="string",
    override_regions=[{
        "name": "string",
        "override_global_alerts": [{
            "name": "string",
            "value": 0,
        }],
        "override_global_data_persistence": "string",
        "override_global_password": "string",
        "override_global_source_ips": ["string"],
        "remote_backup": {
            "interval": "string",
            "storage_path": "string",
            "storage_type": "string",
            "time_utc": "string",
        },
    }],
    port=0,
    data_eviction="string",
    support_oss_cluster_api=False)

    const activeActiveSubscriptionDatabaseResource = new rediscloud.ActiveActiveSubscriptionDatabase("activeActiveSubscriptionDatabaseResource", {
    memoryLimitInGb: 0,
    subscriptionId: "string",
    globalPassword: "string",
    externalEndpointForOssClusterApi: false,
    globalAlerts: [{
        name: "string",
        value: 0,
    }],
    globalDataPersistence: "string",
    clientSslCertificate: "string",
    globalSourceIps: ["string"],
    enableTls: false,
    name: "string",
    overrideRegions: [{
        name: "string",
        overrideGlobalAlerts: [{
            name: "string",
            value: 0,
        }],
        overrideGlobalDataPersistence: "string",
        overrideGlobalPassword: "string",
        overrideGlobalSourceIps: ["string"],
        remoteBackup: {
            interval: "string",
            storagePath: "string",
            storageType: "string",
            timeUtc: "string",
        },
    }],
    port: 0,
    dataEviction: "string",
    supportOssClusterApi: false,
});

    type: rediscloud:ActiveActiveSubscriptionDatabase
properties:
    clientSslCertificate: string
    dataEviction: string
    enableTls: false
    externalEndpointForOssClusterApi: false
    globalAlerts:
        - name: string
          value: 0
    globalDataPersistence: string
    globalPassword: string
    globalSourceIps:
        - string
    memoryLimitInGb: 0
    name: string
    overrideRegions:
        - name: string
          overrideGlobalAlerts:
            - name: string
              value: 0
          overrideGlobalDataPersistence: string
          overrideGlobalPassword: string
          overrideGlobalSourceIps:
            - string
          remoteBackup:
            interval: string
            storagePath: string
            storageType: string
            timeUtc: string
    port: 0
    subscriptionId: string
    supportOssClusterApi: false

    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

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

    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)
    resources:  _:    type: rediscloud:ActiveActiveSubscriptionDatabase    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    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.

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

    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.5 published on Wednesday, Dec 20, 2023 by RedisLabs
    RedisLabs/pulumi-rediscloud