rediscloud.SubscriptionDatabase

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Rediscloud = Pulumi.Rediscloud;
using Rediscloud = RedisLabs.Rediscloud;

return await Deployment.RunAsync(() => 
{
    var card = Rediscloud.GetPaymentMethod.Invoke(new()
    {
        CardType = "Visa",
    });

    var subscription_resource = new Rediscloud.Subscription("subscription-resource", new()
    {
        PaymentMethod = "credit-card",
        PaymentMethodId = card.Apply(getPaymentMethodResult => getPaymentMethodResult.Id),
        MemoryStorage = "ram",
        CloudProvider = new Rediscloud.Inputs.SubscriptionCloudProviderArgs
        {
            Provider = data.Rediscloud_cloud_account.Account.Provider_type,
            Regions = new[]
            {
                new Rediscloud.Inputs.SubscriptionCloudProviderRegionArgs
                {
                    Region = "eu-west-1",
                    MultipleAvailabilityZones = true,
                    NetworkingDeploymentCidr = "10.0.0.0/24",
                    PreferredAvailabilityZones = new[]
                    {
                        "euw1-az1, euw1-az2, euw1-az3",
                    },
                },
            },
        },
        CreationPlan = new Rediscloud.Inputs.SubscriptionCreationPlanArgs
        {
            MemoryLimitInGb = 15,
            Quantity = 1,
            Replication = true,
            ThroughputMeasurementBy = "operations-per-second",
            ThroughputMeasurementValue = 20000,
            Modules = new[]
            {
                "RedisJSON",
            },
        },
    });

    // The primary database to provision
    var database_resource = new Rediscloud.SubscriptionDatabase("database-resource", new()
    {
        SubscriptionId = subscription_resource.Id,
        MemoryLimitInGb = 15,
        DataPersistence = "aof-every-write",
        ThroughputMeasurementBy = "operations-per-second",
        ThroughputMeasurementValue = 20000,
        Replication = true,
        Modules = new[]
        {
            new Rediscloud.Inputs.SubscriptionDatabaseModuleArgs
            {
                Name = "RedisJSON",
            },
        },
        Alerts = new[]
        {
            new Rediscloud.Inputs.SubscriptionDatabaseAlertArgs
            {
                Name = "dataset-size",
                Value = 40,
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            subscription_resource,
        },
    });

});

package main

import (
	"github.com/RedisLabs/pulumi-rediscloud/sdk/go/rediscloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		card, err := rediscloud.GetPaymentMethod(ctx, &rediscloud.GetPaymentMethodArgs{
			CardType: pulumi.StringRef("Visa"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = rediscloud.NewSubscription(ctx, "subscription-resource", &rediscloud.SubscriptionArgs{
			PaymentMethod:   pulumi.String("credit-card"),
			PaymentMethodId: *pulumi.String(card.Id),
			MemoryStorage:   pulumi.String("ram"),
			CloudProvider: &rediscloud.SubscriptionCloudProviderArgs{
				Provider: pulumi.Any(data.Rediscloud_cloud_account.Account.Provider_type),
				Regions: rediscloud.SubscriptionCloudProviderRegionArray{
					&rediscloud.SubscriptionCloudProviderRegionArgs{
						Region:                    pulumi.String("eu-west-1"),
						MultipleAvailabilityZones: pulumi.Bool(true),
						NetworkingDeploymentCidr:  pulumi.String("10.0.0.0/24"),
						PreferredAvailabilityZones: pulumi.StringArray{
							pulumi.String("euw1-az1, euw1-az2, euw1-az3"),
						},
					},
				},
			},
			CreationPlan: &rediscloud.SubscriptionCreationPlanArgs{
				MemoryLimitInGb:            pulumi.Float64(15),
				Quantity:                   pulumi.Int(1),
				Replication:                pulumi.Bool(true),
				ThroughputMeasurementBy:    pulumi.String("operations-per-second"),
				ThroughputMeasurementValue: pulumi.Int(20000),
				Modules: pulumi.StringArray{
					pulumi.String("RedisJSON"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = rediscloud.NewSubscriptionDatabase(ctx, "database-resource", &rediscloud.SubscriptionDatabaseArgs{
			SubscriptionId:             subscription_resource.ID(),
			MemoryLimitInGb:            pulumi.Float64(15),
			DataPersistence:            pulumi.String("aof-every-write"),
			ThroughputMeasurementBy:    pulumi.String("operations-per-second"),
			ThroughputMeasurementValue: pulumi.Int(20000),
			Replication:                pulumi.Bool(true),
			Modules: rediscloud.SubscriptionDatabaseModuleArray{
				&rediscloud.SubscriptionDatabaseModuleArgs{
					Name: pulumi.String("RedisJSON"),
				},
			},
			Alerts: rediscloud.SubscriptionDatabaseAlertArray{
				&rediscloud.SubscriptionDatabaseAlertArgs{
					Name:  pulumi.String("dataset-size"),
					Value: pulumi.Int(40),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			subscription_resource,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rediscloud.RediscloudFunctions;
import com.pulumi.rediscloud.inputs.GetPaymentMethodArgs;
import com.pulumi.rediscloud.Subscription;
import com.pulumi.rediscloud.SubscriptionArgs;
import com.pulumi.rediscloud.inputs.SubscriptionCloudProviderArgs;
import com.pulumi.rediscloud.inputs.SubscriptionCreationPlanArgs;
import com.pulumi.rediscloud.SubscriptionDatabase;
import com.pulumi.rediscloud.SubscriptionDatabaseArgs;
import com.pulumi.rediscloud.inputs.SubscriptionDatabaseModuleArgs;
import com.pulumi.rediscloud.inputs.SubscriptionDatabaseAlertArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var card = RediscloudFunctions.getPaymentMethod(GetPaymentMethodArgs.builder()
            .cardType("Visa")
            .build());

        var subscription_resource = new Subscription("subscription-resource", SubscriptionArgs.builder()        
            .paymentMethod("credit-card")
            .paymentMethodId(card.applyValue(getPaymentMethodResult -> getPaymentMethodResult.id()))
            .memoryStorage("ram")
            .cloudProvider(SubscriptionCloudProviderArgs.builder()
                .provider(data.rediscloud_cloud_account().account().provider_type())
                .regions(SubscriptionCloudProviderRegionArgs.builder()
                    .region("eu-west-1")
                    .multipleAvailabilityZones(true)
                    .networkingDeploymentCidr("10.0.0.0/24")
                    .preferredAvailabilityZones("euw1-az1, euw1-az2, euw1-az3")
                    .build())
                .build())
            .creationPlan(SubscriptionCreationPlanArgs.builder()
                .memoryLimitInGb(15)
                .quantity(1)
                .replication(true)
                .throughputMeasurementBy("operations-per-second")
                .throughputMeasurementValue(20000)
                .modules("RedisJSON")
                .build())
            .build());

        var database_resource = new SubscriptionDatabase("database-resource", SubscriptionDatabaseArgs.builder()        
            .subscriptionId(subscription_resource.id())
            .memoryLimitInGb(15)
            .dataPersistence("aof-every-write")
            .throughputMeasurementBy("operations-per-second")
            .throughputMeasurementValue(20000)
            .replication(true)
            .modules(SubscriptionDatabaseModuleArgs.builder()
                .name("RedisJSON")
                .build())
            .alerts(SubscriptionDatabaseAlertArgs.builder()
                .name("dataset-size")
                .value(40)
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(subscription_resource)
                .build());

    }
}

import pulumi
import pulumi_rediscloud as rediscloud

card = rediscloud.get_payment_method(card_type="Visa")
subscription_resource = rediscloud.Subscription("subscription-resource",
    payment_method="credit-card",
    payment_method_id=card.id,
    memory_storage="ram",
    cloud_provider=rediscloud.SubscriptionCloudProviderArgs(
        provider=data["rediscloud_cloud_account"]["account"]["provider_type"],
        regions=[rediscloud.SubscriptionCloudProviderRegionArgs(
            region="eu-west-1",
            multiple_availability_zones=True,
            networking_deployment_cidr="10.0.0.0/24",
            preferred_availability_zones=["euw1-az1, euw1-az2, euw1-az3"],
        )],
    ),
    creation_plan=rediscloud.SubscriptionCreationPlanArgs(
        memory_limit_in_gb=15,
        quantity=1,
        replication=True,
        throughput_measurement_by="operations-per-second",
        throughput_measurement_value=20000,
        modules=["RedisJSON"],
    ))
# The primary database to provision
database_resource = rediscloud.SubscriptionDatabase("database-resource",
    subscription_id=subscription_resource.id,
    memory_limit_in_gb=15,
    data_persistence="aof-every-write",
    throughput_measurement_by="operations-per-second",
    throughput_measurement_value=20000,
    replication=True,
    modules=[rediscloud.SubscriptionDatabaseModuleArgs(
        name="RedisJSON",
    )],
    alerts=[rediscloud.SubscriptionDatabaseAlertArgs(
        name="dataset-size",
        value=40,
    )],
    opts=pulumi.ResourceOptions(depends_on=[subscription_resource]))

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

const card = rediscloud.getPaymentMethod({
    cardType: "Visa",
});
const subscription_resource = new rediscloud.Subscription("subscription-resource", {
    paymentMethod: "credit-card",
    paymentMethodId: card.then(card => card.id),
    memoryStorage: "ram",
    cloudProvider: {
        provider: data.rediscloud_cloud_account.account.provider_type,
        regions: [{
            region: "eu-west-1",
            multipleAvailabilityZones: true,
            networkingDeploymentCidr: "10.0.0.0/24",
            preferredAvailabilityZones: ["euw1-az1, euw1-az2, euw1-az3"],
        }],
    },
    creationPlan: {
        memoryLimitInGb: 15,
        quantity: 1,
        replication: true,
        throughputMeasurementBy: "operations-per-second",
        throughputMeasurementValue: 20000,
        modules: ["RedisJSON"],
    },
});
// The primary database to provision
const database_resource = new rediscloud.SubscriptionDatabase("database-resource", {
    subscriptionId: subscription_resource.id,
    memoryLimitInGb: 15,
    dataPersistence: "aof-every-write",
    throughputMeasurementBy: "operations-per-second",
    throughputMeasurementValue: 20000,
    replication: true,
    modules: [{
        name: "RedisJSON",
    }],
    alerts: [{
        name: "dataset-size",
        value: 40,
    }],
}, {
    dependsOn: [subscription_resource],
});

resources:
  subscription-resource:
    type: rediscloud:Subscription
    properties:
      paymentMethod: credit-card
      paymentMethodId: ${card.id}
      memoryStorage: ram
      cloudProvider:
        provider: ${data.rediscloud_cloud_account.account.provider_type}
        regions:
          - region: eu-west-1
            multipleAvailabilityZones: true
            networkingDeploymentCidr: 10.0.0.0/24
            preferredAvailabilityZones:
              - euw1-az1, euw1-az2, euw1-az3
      creationPlan:
        memoryLimitInGb: 15
        quantity: 1
        replication: true
        throughputMeasurementBy: operations-per-second
        throughputMeasurementValue: 20000
        modules:
          - RedisJSON
  # The primary database to provision
  database-resource:
    type: rediscloud:SubscriptionDatabase
    properties:
      subscriptionId: ${["subscription-resource"].id}
      memoryLimitInGb: 15
      dataPersistence: aof-every-write
      throughputMeasurementBy: operations-per-second
      throughputMeasurementValue: 20000
      replication: true
      modules:
        - name: RedisJSON
      alerts:
        - name: dataset-size
          value: 40
    options:
      dependson:
        - ${["subscription-resource"]}
variables:
  card:
    fn::invoke:
      Function: rediscloud:getPaymentMethod
      Arguments:
        cardType: Visa