Docs Packages
  1. Pulumi Registry
  2. RedisCloud
  3. API Docs
  4. ActiveActiveSubscriptionDatabase
rediscloud logo
Redis Cloud v1.2.6, May 15 23

rediscloud.ActiveActiveSubscriptionDatabase

Explore with Pulumi AI

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()));
    }
}

Coming soon!

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,
                }],
            },
        ],
    });
    const us_east_1_public_endpoints = database_resource.publicEndpoint["us-east-1"];
    const us_east_2_private_endpoints = database_resource.privateEndpoint["us-east-1"];
    return {
        "us-east-1-public-endpoints": us_east_1_public_endpoints,
        "us-east-2-private-endpoints": us_east_2_private_endpoints,
    };
}

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

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.ActiveActiveSubscriptionDatabaseGlobalAlertArgs>

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

OverrideRegions List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs>

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

OverrideRegions []ActiveActiveSubscriptionDatabaseOverrideRegionArgs

Override region specific configuration, documented below

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

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<ActiveActiveSubscriptionDatabaseGlobalAlertArgs>

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions List<ActiveActiveSubscriptionDatabaseOverrideRegionArgs>

Override region specific configuration, documented below

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

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 ActiveActiveSubscriptionDatabaseGlobalAlertArgs[]

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions ActiveActiveSubscriptionDatabaseOverrideRegionArgs[]

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

override_regions Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions List<Property Map>

Override region specific configuration, documented below

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,
        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.ActiveActiveSubscriptionDatabaseGlobalAlertArgs>

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

OverrideRegions List<RedisLabs.Rediscloud.Inputs.ActiveActiveSubscriptionDatabaseOverrideRegionArgs>

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

OverrideRegions []ActiveActiveSubscriptionDatabaseOverrideRegionArgs

Override region specific configuration, documented below

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

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<ActiveActiveSubscriptionDatabaseGlobalAlertArgs>

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions List<ActiveActiveSubscriptionDatabaseOverrideRegionArgs>

Override region specific configuration, documented below

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

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 ActiveActiveSubscriptionDatabaseGlobalAlertArgs[]

A block defining Redis database alert of regions that dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions ActiveActiveSubscriptionDatabaseOverrideRegionArgs[]

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

override_regions Sequence[ActiveActiveSubscriptionDatabaseOverrideRegionArgs]

Override region specific configuration, documented below

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

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 dont override global settings, documented below, can be specified multiple times

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 dont 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 dont 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

overrideRegions List<Property Map>

Override region specific configuration, documented below

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

supportOssClusterApi Boolean

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

Supporting Types

ActiveActiveSubscriptionDatabaseGlobalAlert

Name string

A meaningful name to identify the database

Value int

Alert value

Name string

A meaningful name to identify the database

Value int

Alert value

name String

A meaningful name to identify the database

value Integer

Alert value

name string

A meaningful name to identify the database

value number

Alert value

name str

A meaningful name to identify the database

value int

Alert value

name String

A meaningful name to identify the database

value Number

Alert value

ActiveActiveSubscriptionDatabaseOverrideRegion

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

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

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

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

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

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

ActiveActiveSubscriptionDatabaseOverrideRegionOverrideGlobalAlert

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

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 configuraton, you will need to manually add them to your Terraform configuration and run terraform apply 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.