rediscloud.Subscription

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",
            },
        },
    });

});

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

    }
}

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

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
variables:
  card:
    fn::invoke:
      Function: rediscloud:getPaymentMethod
      Arguments:
        cardType: Visa