Cluster class

A Google Cloud Redis Cluster instance.

To get more information about Cluster, see:

• API documentation
• How-to Guides
• Official Documentation

> Note: For Multiple VPC Networking if you want to use User-registered PSC Connections, then please use gcp.redis.ClusterUserCreatedConnections resource.

For Cross Region Replication, please follow the instructions below for performing certain update and failover (switchover and detach) operations

Cross Region Replication

Settings updated on primary and propagated to secondaries

The settings listed here are only allowed to be updated on the primary cluster and the changes are automatically propagated to the secondary clusters. To keep the Terraform configuration and state in sync for such settings, please follow the below steps to update them:

1. Update the setting on the primary cluster:

• Update the setting to its new desired value in the Terraform configuration file.
• Execute pulumi up to apply the change and wait for it to complete.

1. Detect configuration drift on the secondary cluster(s):

• Execute pulumi preview. This should reveal a diff for the modified setting. The proposed value in the pulumi preview should align with the updated value applied to the primary cluster in the preceding step.

1. Reconcile secondary cluster(s) configuration:

• Manually edit the Terraform configuration file(s) for the secondary cluster(s) to update the setting with the latest value from the state.
• Execute pulumi preview once again. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

Switchover

To perform a switchover, please follow the below steps:

1. Ensure that the Terraform configuration file for the secondary cluster that needs to become the new primary has the crossClusterReplicationConfig field. If it is not present:

• Add the crossClusterReplicationConfig field to the configuration file to match the latest value in the state.
• Execute pulumi preview. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

1. Update the crossClusterReplicationConfig field of the secondary that needs to become the new primary:

• Change cross_cluster_replication_config.cluster_role from SECONDARY to PRIMARY.
• Remove cross_cluster_replication_config.primary_cluster field.
• Set cross_cluster_replication_config.secondary_clusters list with the new secondaries. The new secondaries are the current primary and other secondary clusters(if any).

> You can refer to the current value of cross_cluster_replication_config.membership field to lookup the current primary and secondary clusters.

1. Execute switchover:

• Executepulumi up to apply the change and wait for it to complete.

1. Fix any configuration drifts on the previous primary and other secondary clusters:

• Execute pulumi preview. If any diffs are reported for crossClusterReplicationConfig field:
• Manually update crossClusterReplicationConfig field in the configuration file(s) for those clusters with the latest value from the state.
• Execute pulumi preview once again. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

Detach a secondary cluster

To detach a secondary cluster, please follow the below steps:

1. Ensure that the Terraform configuration file for the secondary cluster that needs to be detached has the crossClusterReplicationConfig field. If it is not present:

• Add the crossClusterReplicationConfig field to the configuration file to match the latest value in the state.
• Execute pulumi preview. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

1. Update the crossClusterReplicationConfig field of the secondary that needs to be detached:

• Change cross_cluster_replication_config.cluster_role from SECONDARY to NONE.
• Remove cross_cluster_replication_config.primary_cluster.

1. Execute detach:

• Executepulumi up to apply the change and wait for it to complete.

1. Fix any configuration drifts on the primary cluster:

• Execute pulumi preview. If any diff is reported for crossClusterReplicationConfig field:
• Manually update crossClusterReplicationConfig field in the configuration file with the latest value from the state.
• Execute pulumi preview once again. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

Detach secondary cluster(s) via primary cluster

To detach secondary clusters via primary, please follow the below steps:

1. Ensure that the Terraform configuration file for the primary cluster from which the secondary(ies) has(ve) to be detached has the crossClusterReplicationConfig field. If it is not present:

• Add the crossClusterReplicationConfig field to the configuration file to match the latest value in the state.
• Execute pulumi preview. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

1. Update the crossClusterReplicationConfig field of the primary cluster:

• If you are detaching all secondaries from the primary:
• Change cross_cluster_replication_config.cluster_role from PRIMARY to NONE.
• Remove cross_cluster_replication_config.secondary_clusters list field.
• If you are detaching a subset of secondaries:
• Update cross_cluster_replication_config.secondary_clusters list field to remove the secondary clusters that need to be detached.

1. Execute detach:

• Execute pulumi up to apply the change and wait for it to complete.

1. Fix any configuration drifts on the secondary cluster(s) that was detached:

• Execute pulumi preview. If any diffs are reported for crossClusterReplicationConfig field:
• Manually update crossClusterReplicationConfig field in the configuration file(s) for those clusters with the latest value from the state.
• Execute pulumi preview once again. This should not generate any diff, confirming the configuration is in sync with the infrastructure.

Example Usage

Redis Cluster Ha With Labels

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_ha_with_labels = new gcp.redis.Cluster("cluster-ha-with-labels", {
    name: "ha-cluster",
    shardCount: 3,
    labels: {
        my_key: "my_val",
        other_key: "other_val",
    },
    pscConfigs: [{
        network: consumerNet.id,
    }],
    region: "us-central1",
    replicaCount: 1,
    nodeType: "REDIS_SHARED_CORE_NANO",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorizationMode: "AUTH_MODE_DISABLED",
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    deletionProtectionEnabled: true,
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
}, {
    dependsOn: [_default],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_ha_with_labels = gcp.redis.Cluster("cluster-ha-with-labels",
    name="ha-cluster",
    shard_count=3,
    labels={
        "my_key": "my_val",
        "other_key": "other_val",
    },
    psc_configs=[{
        "network": consumer_net.id,
    }],
    region="us-central1",
    replica_count=1,
    node_type="REDIS_SHARED_CORE_NANO",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorization_mode="AUTH_MODE_DISABLED",
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    deletion_protection_enabled=True,
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    opts = pulumi.ResourceOptions(depends_on=[default]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_ha_with_labels = new Gcp.Redis.Cluster("cluster-ha-with-labels", new()
    {
        Name = "ha-cluster",
        ShardCount = 3,
        Labels =
        {
            { "my_key", "my_val" },
            { "other_key", "other_val" },
        },
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        Region = "us-central1",
        ReplicaCount = 1,
        NodeType = "REDIS_SHARED_CORE_NANO",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        AuthorizationMode = "AUTH_MODE_DISABLED",
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        DeletionProtectionEnabled = true,
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-ha-with-labels", &redis.ClusterArgs{
			Name:       pulumi.String("ha-cluster"),
			ShardCount: pulumi.Int(3),
			Labels: pulumi.StringMap{
				"my_key":    pulumi.String("my_val"),
				"other_key": pulumi.String("other_val"),
			},
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			Region:                pulumi.String("us-central1"),
			ReplicaCount:          pulumi.Int(1),
			NodeType:              pulumi.String("REDIS_SHARED_CORE_NANO"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "cluster-ha-with-labels" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "ha-cluster"
  shard_count = 3
  labels = {
    "my_key"    = "my_val"
    "other_key" = "other_val"
  }
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  region                  = "us-central1"
  replica_count           = 1
  node_type               = "REDIS_SHARED_CORE_NANO"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  authorization_mode      = "AUTH_MODE_DISABLED"
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  deletion_protection_enabled = true
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_ha_with_labels = new Cluster("cluster-ha-with-labels", ClusterArgs.builder()
            .name("ha-cluster")
            .shardCount(3)
            .labels(Map.ofEntries(
                Map.entry("my_key", "my_val"),
                Map.entry("other_key", "other_val")
            ))
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .region("us-central1")
            .replicaCount(1)
            .nodeType("REDIS_SHARED_CORE_NANO")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .authorizationMode("AUTH_MODE_DISABLED")
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .deletionProtectionEnabled(true)
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

    }
}

resources:
  cluster-ha-with-labels:
    type: gcp:redis:Cluster
    properties:
      name: ha-cluster
      shardCount: 3
      labels:
        my_key: my_val
        other_key: other_val
      pscConfigs:
        - network: ${consumerNet.id}
      region: us-central1
      replicaCount: 1
      nodeType: REDIS_SHARED_CORE_NANO
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      authorizationMode: AUTH_MODE_DISABLED
      redisConfigs:
        maxmemory-policy: volatile-ttl
      deletionProtectionEnabled: true
      zoneDistributionConfig:
        mode: MULTI_ZONE
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false

Redis Cluster Ha

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_ha = new gcp.redis.Cluster("cluster-ha", {
    name: "ha-cluster",
    shardCount: 3,
    pscConfigs: [{
        network: consumerNet.id,
    }],
    region: "us-central1",
    replicaCount: 1,
    nodeType: "REDIS_SHARED_CORE_NANO",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorizationMode: "AUTH_MODE_DISABLED",
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    deletionProtectionEnabled: true,
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
}, {
    dependsOn: [_default],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_ha = gcp.redis.Cluster("cluster-ha",
    name="ha-cluster",
    shard_count=3,
    psc_configs=[{
        "network": consumer_net.id,
    }],
    region="us-central1",
    replica_count=1,
    node_type="REDIS_SHARED_CORE_NANO",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorization_mode="AUTH_MODE_DISABLED",
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    deletion_protection_enabled=True,
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    opts = pulumi.ResourceOptions(depends_on=[default]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_ha = new Gcp.Redis.Cluster("cluster-ha", new()
    {
        Name = "ha-cluster",
        ShardCount = 3,
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        Region = "us-central1",
        ReplicaCount = 1,
        NodeType = "REDIS_SHARED_CORE_NANO",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        AuthorizationMode = "AUTH_MODE_DISABLED",
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        DeletionProtectionEnabled = true,
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-ha", &redis.ClusterArgs{
			Name:       pulumi.String("ha-cluster"),
			ShardCount: pulumi.Int(3),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			Region:                pulumi.String("us-central1"),
			ReplicaCount:          pulumi.Int(1),
			NodeType:              pulumi.String("REDIS_SHARED_CORE_NANO"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "cluster-ha" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "ha-cluster"
  shard_count = 3
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  region                  = "us-central1"
  replica_count           = 1
  node_type               = "REDIS_SHARED_CORE_NANO"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  authorization_mode      = "AUTH_MODE_DISABLED"
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  deletion_protection_enabled = true
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_ha = new Cluster("cluster-ha", ClusterArgs.builder()
            .name("ha-cluster")
            .shardCount(3)
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .region("us-central1")
            .replicaCount(1)
            .nodeType("REDIS_SHARED_CORE_NANO")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .authorizationMode("AUTH_MODE_DISABLED")
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .deletionProtectionEnabled(true)
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

    }
}

resources:
  cluster-ha:
    type: gcp:redis:Cluster
    properties:
      name: ha-cluster
      shardCount: 3
      pscConfigs:
        - network: ${consumerNet.id}
      region: us-central1
      replicaCount: 1
      nodeType: REDIS_SHARED_CORE_NANO
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      authorizationMode: AUTH_MODE_DISABLED
      redisConfigs:
        maxmemory-policy: volatile-ttl
      deletionProtectionEnabled: true
      zoneDistributionConfig:
        mode: MULTI_ZONE
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false

Redis Cluster Ha Single Zone

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_ha_single_zone = new gcp.redis.Cluster("cluster-ha-single-zone", {
    name: "ha-cluster-single-zone",
    shardCount: 3,
    pscConfigs: [{
        network: consumerNet.id,
    }],
    region: "us-central1",
    zoneDistributionConfig: {
        mode: "SINGLE_ZONE",
        zone: "us-central1-f",
    },
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
    deletionProtectionEnabled: true,
}, {
    dependsOn: [_default],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_ha_single_zone = gcp.redis.Cluster("cluster-ha-single-zone",
    name="ha-cluster-single-zone",
    shard_count=3,
    psc_configs=[{
        "network": consumer_net.id,
    }],
    region="us-central1",
    zone_distribution_config={
        "mode": "SINGLE_ZONE",
        "zone": "us-central1-f",
    },
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    deletion_protection_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[default]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_ha_single_zone = new Gcp.Redis.Cluster("cluster-ha-single-zone", new()
    {
        Name = "ha-cluster-single-zone",
        ShardCount = 3,
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        Region = "us-central1",
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "SINGLE_ZONE",
            Zone = "us-central1-f",
        },
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
        DeletionProtectionEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-ha-single-zone", &redis.ClusterArgs{
			Name:       pulumi.String("ha-cluster-single-zone"),
			ShardCount: pulumi.Int(3),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			Region: pulumi.String("us-central1"),
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("SINGLE_ZONE"),
				Zone: pulumi.String("us-central1-f"),
			},
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "cluster-ha-single-zone" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "ha-cluster-single-zone"
  shard_count = 3
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  region = "us-central1"
  zone_distribution_config = {
    mode = "SINGLE_ZONE"
    zone = "us-central1-f"
  }
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
  deletion_protection_enabled = true
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_ha_single_zone = new Cluster("cluster-ha-single-zone", ClusterArgs.builder()
            .name("ha-cluster-single-zone")
            .shardCount(3)
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .region("us-central1")
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("SINGLE_ZONE")
                .zone("us-central1-f")
                .build())
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .deletionProtectionEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

    }
}

resources:
  cluster-ha-single-zone:
    type: gcp:redis:Cluster
    properties:
      name: ha-cluster-single-zone
      shardCount: 3
      pscConfigs:
        - network: ${consumerNet.id}
      region: us-central1
      zoneDistributionConfig:
        mode: SINGLE_ZONE
        zone: us-central1-f
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
      deletionProtectionEnabled: true
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false

Redis Cluster Secondary

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "mynetwork",
    autoCreateSubnetworks: false,
});
const primaryClusterConsumerSubnet = new gcp.compute.Subnetwork("primary_cluster_consumer_subnet", {
    name: "mysubnet-primary-cluster",
    ipCidrRange: "10.0.1.0/29",
    region: "us-east1",
    network: consumerNet.id,
});
const primaryClusterRegionScp = new gcp.networkconnectivity.ServiceConnectionPolicy("primary_cluster_region_scp", {
    name: "mypolicy-primary-cluster",
    location: "us-east1",
    serviceClass: "gcp-memorystore-redis",
    description: "Primary cluster service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [primaryClusterConsumerSubnet.id],
    },
});
// Primary cluster
const primaryCluster = new gcp.redis.Cluster("primary_cluster", {
    name: "my-primary-cluster",
    region: "us-east1",
    pscConfigs: [{
        network: consumerNet.id,
    }],
    authorizationMode: "AUTH_MODE_DISABLED",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    shardCount: 3,
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    nodeType: "REDIS_HIGHMEM_MEDIUM",
    persistenceConfig: {
        mode: "RDB",
        rdbConfig: {
            rdbSnapshotPeriod: "ONE_HOUR",
            rdbSnapshotStartTime: "2024-10-02T15:01:23Z",
        },
    },
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    replicaCount: 1,
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
    deletionProtectionEnabled: true,
}, {
    dependsOn: [primaryClusterRegionScp],
});
const secondaryClusterConsumerSubnet = new gcp.compute.Subnetwork("secondary_cluster_consumer_subnet", {
    name: "mysubnet-secondary-cluster",
    ipCidrRange: "10.0.2.0/29",
    region: "europe-west1",
    network: consumerNet.id,
});
const secondaryClusterRegionScp = new gcp.networkconnectivity.ServiceConnectionPolicy("secondary_cluster_region_scp", {
    name: "mypolicy-secondary-cluster",
    location: "europe-west1",
    serviceClass: "gcp-memorystore-redis",
    description: "Secondary cluster service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [secondaryClusterConsumerSubnet.id],
    },
});
// Secondary cluster
const secondaryCluster = new gcp.redis.Cluster("secondary_cluster", {
    name: "my-secondary-cluster",
    region: "europe-west1",
    pscConfigs: [{
        network: consumerNet.id,
    }],
    authorizationMode: "AUTH_MODE_DISABLED",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    shardCount: 3,
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    nodeType: "REDIS_HIGHMEM_MEDIUM",
    persistenceConfig: {
        mode: "RDB",
        rdbConfig: {
            rdbSnapshotPeriod: "ONE_HOUR",
            rdbSnapshotStartTime: "2024-10-02T15:01:23Z",
        },
    },
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    replicaCount: 2,
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "WEDNESDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
    deletionProtectionEnabled: true,
    crossClusterReplicationConfig: {
        clusterRole: "SECONDARY",
        primaryCluster: {
            cluster: primaryCluster.id,
        },
    },
}, {
    dependsOn: [secondaryClusterRegionScp],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="mynetwork",
    auto_create_subnetworks=False)
primary_cluster_consumer_subnet = gcp.compute.Subnetwork("primary_cluster_consumer_subnet",
    name="mysubnet-primary-cluster",
    ip_cidr_range="10.0.1.0/29",
    region="us-east1",
    network=consumer_net.id)
primary_cluster_region_scp = gcp.networkconnectivity.ServiceConnectionPolicy("primary_cluster_region_scp",
    name="mypolicy-primary-cluster",
    location="us-east1",
    service_class="gcp-memorystore-redis",
    description="Primary cluster service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [primary_cluster_consumer_subnet.id],
    })
# Primary cluster
primary_cluster = gcp.redis.Cluster("primary_cluster",
    name="my-primary-cluster",
    region="us-east1",
    psc_configs=[{
        "network": consumer_net.id,
    }],
    authorization_mode="AUTH_MODE_DISABLED",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    shard_count=3,
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    node_type="REDIS_HIGHMEM_MEDIUM",
    persistence_config={
        "mode": "RDB",
        "rdb_config": {
            "rdb_snapshot_period": "ONE_HOUR",
            "rdb_snapshot_start_time": "2024-10-02T15:01:23Z",
        },
    },
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    replica_count=1,
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    deletion_protection_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[primary_cluster_region_scp]))
secondary_cluster_consumer_subnet = gcp.compute.Subnetwork("secondary_cluster_consumer_subnet",
    name="mysubnet-secondary-cluster",
    ip_cidr_range="10.0.2.0/29",
    region="europe-west1",
    network=consumer_net.id)
secondary_cluster_region_scp = gcp.networkconnectivity.ServiceConnectionPolicy("secondary_cluster_region_scp",
    name="mypolicy-secondary-cluster",
    location="europe-west1",
    service_class="gcp-memorystore-redis",
    description="Secondary cluster service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [secondary_cluster_consumer_subnet.id],
    })
# Secondary cluster
secondary_cluster = gcp.redis.Cluster("secondary_cluster",
    name="my-secondary-cluster",
    region="europe-west1",
    psc_configs=[{
        "network": consumer_net.id,
    }],
    authorization_mode="AUTH_MODE_DISABLED",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    shard_count=3,
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    node_type="REDIS_HIGHMEM_MEDIUM",
    persistence_config={
        "mode": "RDB",
        "rdb_config": {
            "rdb_snapshot_period": "ONE_HOUR",
            "rdb_snapshot_start_time": "2024-10-02T15:01:23Z",
        },
    },
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    replica_count=2,
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "WEDNESDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    deletion_protection_enabled=True,
    cross_cluster_replication_config={
        "cluster_role": "SECONDARY",
        "primary_cluster": {
            "cluster": primary_cluster.id,
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[secondary_cluster_region_scp]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "mynetwork",
        AutoCreateSubnetworks = false,
    });

    var primaryClusterConsumerSubnet = new Gcp.Compute.Subnetwork("primary_cluster_consumer_subnet", new()
    {
        Name = "mysubnet-primary-cluster",
        IpCidrRange = "10.0.1.0/29",
        Region = "us-east1",
        Network = consumerNet.Id,
    });

    var primaryClusterRegionScp = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("primary_cluster_region_scp", new()
    {
        Name = "mypolicy-primary-cluster",
        Location = "us-east1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "Primary cluster service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                primaryClusterConsumerSubnet.Id,
            },
        },
    });

    // Primary cluster
    var primaryCluster = new Gcp.Redis.Cluster("primary_cluster", new()
    {
        Name = "my-primary-cluster",
        Region = "us-east1",
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        AuthorizationMode = "AUTH_MODE_DISABLED",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        ShardCount = 3,
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        NodeType = "REDIS_HIGHMEM_MEDIUM",
        PersistenceConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigArgs
        {
            Mode = "RDB",
            RdbConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigRdbConfigArgs
            {
                RdbSnapshotPeriod = "ONE_HOUR",
                RdbSnapshotStartTime = "2024-10-02T15:01:23Z",
            },
        },
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        ReplicaCount = 1,
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
        DeletionProtectionEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            primaryClusterRegionScp,
        },
    });

    var secondaryClusterConsumerSubnet = new Gcp.Compute.Subnetwork("secondary_cluster_consumer_subnet", new()
    {
        Name = "mysubnet-secondary-cluster",
        IpCidrRange = "10.0.2.0/29",
        Region = "europe-west1",
        Network = consumerNet.Id,
    });

    var secondaryClusterRegionScp = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("secondary_cluster_region_scp", new()
    {
        Name = "mypolicy-secondary-cluster",
        Location = "europe-west1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "Secondary cluster service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                secondaryClusterConsumerSubnet.Id,
            },
        },
    });

    // Secondary cluster
    var secondaryCluster = new Gcp.Redis.Cluster("secondary_cluster", new()
    {
        Name = "my-secondary-cluster",
        Region = "europe-west1",
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        AuthorizationMode = "AUTH_MODE_DISABLED",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        ShardCount = 3,
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        NodeType = "REDIS_HIGHMEM_MEDIUM",
        PersistenceConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigArgs
        {
            Mode = "RDB",
            RdbConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigRdbConfigArgs
            {
                RdbSnapshotPeriod = "ONE_HOUR",
                RdbSnapshotStartTime = "2024-10-02T15:01:23Z",
            },
        },
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        ReplicaCount = 2,
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "WEDNESDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
        DeletionProtectionEnabled = true,
        CrossClusterReplicationConfig = new Gcp.Redis.Inputs.ClusterCrossClusterReplicationConfigArgs
        {
            ClusterRole = "SECONDARY",
            PrimaryCluster = new Gcp.Redis.Inputs.ClusterCrossClusterReplicationConfigPrimaryClusterArgs
            {
                Cluster = primaryCluster.Id,
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            secondaryClusterRegionScp,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("mynetwork"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		primaryClusterConsumerSubnet, err := compute.NewSubnetwork(ctx, "primary_cluster_consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("mysubnet-primary-cluster"),
			IpCidrRange: pulumi.String("10.0.1.0/29"),
			Region:      pulumi.String("us-east1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		primaryClusterRegionScp, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "primary_cluster_region_scp", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("mypolicy-primary-cluster"),
			Location:     pulumi.String("us-east1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("Primary cluster service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					primaryClusterConsumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		// Primary cluster
		primaryCluster, err := redis.NewCluster(ctx, "primary_cluster", &redis.ClusterArgs{
			Name:   pulumi.String("my-primary-cluster"),
			Region: pulumi.String("us-east1"),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			ShardCount:            pulumi.Int(3),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			NodeType: pulumi.String("REDIS_HIGHMEM_MEDIUM"),
			PersistenceConfig: &redis.ClusterPersistenceConfigArgs{
				Mode: pulumi.String("RDB"),
				RdbConfig: &redis.ClusterPersistenceConfigRdbConfigArgs{
					RdbSnapshotPeriod:    pulumi.String("ONE_HOUR"),
					RdbSnapshotStartTime: pulumi.String("2024-10-02T15:01:23Z"),
				},
			},
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			ReplicaCount: pulumi.Int(1),
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			primaryClusterRegionScp,
		}))
		if err != nil {
			return err
		}
		secondaryClusterConsumerSubnet, err := compute.NewSubnetwork(ctx, "secondary_cluster_consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("mysubnet-secondary-cluster"),
			IpCidrRange: pulumi.String("10.0.2.0/29"),
			Region:      pulumi.String("europe-west1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		secondaryClusterRegionScp, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "secondary_cluster_region_scp", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("mypolicy-secondary-cluster"),
			Location:     pulumi.String("europe-west1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("Secondary cluster service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					secondaryClusterConsumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		// Secondary cluster
		_, err = redis.NewCluster(ctx, "secondary_cluster", &redis.ClusterArgs{
			Name:   pulumi.String("my-secondary-cluster"),
			Region: pulumi.String("europe-west1"),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			ShardCount:            pulumi.Int(3),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			NodeType: pulumi.String("REDIS_HIGHMEM_MEDIUM"),
			PersistenceConfig: &redis.ClusterPersistenceConfigArgs{
				Mode: pulumi.String("RDB"),
				RdbConfig: &redis.ClusterPersistenceConfigRdbConfigArgs{
					RdbSnapshotPeriod:    pulumi.String("ONE_HOUR"),
					RdbSnapshotStartTime: pulumi.String("2024-10-02T15:01:23Z"),
				},
			},
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			ReplicaCount: pulumi.Int(2),
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("WEDNESDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
			CrossClusterReplicationConfig: &redis.ClusterCrossClusterReplicationConfigArgs{
				ClusterRole: pulumi.String("SECONDARY"),
				PrimaryCluster: &redis.ClusterCrossClusterReplicationConfigPrimaryClusterArgs{
					Cluster: primaryCluster.ID().ToIDOutput().ToStringOutput(),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			secondaryClusterRegionScp,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

// Primary cluster
resource "gcp_redis_cluster" "primary_cluster" {
  depends_on = [gcp_networkconnectivity_serviceconnectionpolicy.primary_cluster_region_scp]
  name       = "my-primary-cluster"
  region     = "us-east1"
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  authorization_mode      = "AUTH_MODE_DISABLED"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  shard_count             = 3
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  node_type = "REDIS_HIGHMEM_MEDIUM"
  persistence_config = {
    mode = "RDB"
    rdb_config = {
      rdb_snapshot_period     = "ONE_HOUR"
      rdb_snapshot_start_time = "2024-10-02T15:01:23Z"
    }
  }
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  replica_count = 1
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
  deletion_protection_enabled = true
}
// Secondary cluster
resource "gcp_redis_cluster" "secondary_cluster" {
  depends_on = [gcp_networkconnectivity_serviceconnectionpolicy.secondary_cluster_region_scp]
  name       = "my-secondary-cluster"
  region     = "europe-west1"
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  authorization_mode      = "AUTH_MODE_DISABLED"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  shard_count             = 3
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  node_type = "REDIS_HIGHMEM_MEDIUM"
  persistence_config = {
    mode = "RDB"
    rdb_config = {
      rdb_snapshot_period     = "ONE_HOUR"
      rdb_snapshot_start_time = "2024-10-02T15:01:23Z"
    }
  }
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  replica_count = 2
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "WEDNESDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
  deletion_protection_enabled = true
  // Cross cluster replication config
  cross_cluster_replication_config = {
    cluster_role = "SECONDARY"
    primary_cluster = {
      cluster = gcp_redis_cluster.primary_cluster.id
    }
  }
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "primary_cluster_region_scp" {
  name          = "mypolicy-primary-cluster"
  location      = "us-east1"
  service_class = "gcp-memorystore-redis"
  description   = "Primary cluster service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.primary_cluster_consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "primary_cluster_consumer_subnet" {
  name          = "mysubnet-primary-cluster"
  ip_cidr_range = "10.0.1.0/29"
  region        = "us-east1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "secondary_cluster_region_scp" {
  name          = "mypolicy-secondary-cluster"
  location      = "europe-west1"
  service_class = "gcp-memorystore-redis"
  description   = "Secondary cluster service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.secondary_cluster_consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "secondary_cluster_consumer_subnet" {
  name          = "mysubnet-secondary-cluster"
  ip_cidr_range = "10.0.2.0/29"
  region        = "europe-west1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "mynetwork"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigRdbConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.gcp.redis.inputs.ClusterCrossClusterReplicationConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterCrossClusterReplicationConfigPrimaryClusterArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("mynetwork")
            .autoCreateSubnetworks(false)
            .build());

        var primaryClusterConsumerSubnet = new Subnetwork("primaryClusterConsumerSubnet", SubnetworkArgs.builder()
            .name("mysubnet-primary-cluster")
            .ipCidrRange("10.0.1.0/29")
            .region("us-east1")
            .network(consumerNet.id())
            .build());

        var primaryClusterRegionScp = new ServiceConnectionPolicy("primaryClusterRegionScp", ServiceConnectionPolicyArgs.builder()
            .name("mypolicy-primary-cluster")
            .location("us-east1")
            .serviceClass("gcp-memorystore-redis")
            .description("Primary cluster service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(primaryClusterConsumerSubnet.id())
                .build())
            .build());

        // Primary cluster
        var primaryCluster = new Cluster("primaryCluster", ClusterArgs.builder()
            .name("my-primary-cluster")
            .region("us-east1")
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .authorizationMode("AUTH_MODE_DISABLED")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .shardCount(3)
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .nodeType("REDIS_HIGHMEM_MEDIUM")
            .persistenceConfig(ClusterPersistenceConfigArgs.builder()
                .mode("RDB")
                .rdbConfig(ClusterPersistenceConfigRdbConfigArgs.builder()
                    .rdbSnapshotPeriod("ONE_HOUR")
                    .rdbSnapshotStartTime("2024-10-02T15:01:23Z")
                    .build())
                .build())
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .replicaCount(1)
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .deletionProtectionEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(primaryClusterRegionScp)
                .build());

        var secondaryClusterConsumerSubnet = new Subnetwork("secondaryClusterConsumerSubnet", SubnetworkArgs.builder()
            .name("mysubnet-secondary-cluster")
            .ipCidrRange("10.0.2.0/29")
            .region("europe-west1")
            .network(consumerNet.id())
            .build());

        var secondaryClusterRegionScp = new ServiceConnectionPolicy("secondaryClusterRegionScp", ServiceConnectionPolicyArgs.builder()
            .name("mypolicy-secondary-cluster")
            .location("europe-west1")
            .serviceClass("gcp-memorystore-redis")
            .description("Secondary cluster service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(secondaryClusterConsumerSubnet.id())
                .build())
            .build());

        // Secondary cluster
        var secondaryCluster = new Cluster("secondaryCluster", ClusterArgs.builder()
            .name("my-secondary-cluster")
            .region("europe-west1")
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .authorizationMode("AUTH_MODE_DISABLED")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .shardCount(3)
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .nodeType("REDIS_HIGHMEM_MEDIUM")
            .persistenceConfig(ClusterPersistenceConfigArgs.builder()
                .mode("RDB")
                .rdbConfig(ClusterPersistenceConfigRdbConfigArgs.builder()
                    .rdbSnapshotPeriod("ONE_HOUR")
                    .rdbSnapshotStartTime("2024-10-02T15:01:23Z")
                    .build())
                .build())
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .replicaCount(2)
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("WEDNESDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .deletionProtectionEnabled(true)
            .crossClusterReplicationConfig(ClusterCrossClusterReplicationConfigArgs.builder()
                .clusterRole("SECONDARY")
                .primaryCluster(ClusterCrossClusterReplicationConfigPrimaryClusterArgs.builder()
                    .cluster(primaryCluster.id())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(secondaryClusterRegionScp)
                .build());

    }
}

resources:
  # Primary cluster
  primaryCluster:
    type: gcp:redis:Cluster
    name: primary_cluster
    properties:
      name: my-primary-cluster
      region: us-east1
      pscConfigs:
        - network: ${consumerNet.id}
      authorizationMode: AUTH_MODE_DISABLED
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      shardCount: 3
      redisConfigs:
        maxmemory-policy: volatile-ttl
      nodeType: REDIS_HIGHMEM_MEDIUM
      persistenceConfig:
        mode: RDB
        rdbConfig:
          rdbSnapshotPeriod: ONE_HOUR
          rdbSnapshotStartTime: 2024-10-02T15:01:23Z
      zoneDistributionConfig:
        mode: MULTI_ZONE
      replicaCount: 1
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
      deletionProtectionEnabled: true
    options:
      dependsOn:
        - ${primaryClusterRegionScp}
  # Secondary cluster
  secondaryCluster:
    type: gcp:redis:Cluster
    name: secondary_cluster
    properties:
      name: my-secondary-cluster
      region: europe-west1
      pscConfigs:
        - network: ${consumerNet.id}
      authorizationMode: AUTH_MODE_DISABLED
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      shardCount: 3
      redisConfigs:
        maxmemory-policy: volatile-ttl
      nodeType: REDIS_HIGHMEM_MEDIUM
      persistenceConfig:
        mode: RDB
        rdbConfig:
          rdbSnapshotPeriod: ONE_HOUR
          rdbSnapshotStartTime: 2024-10-02T15:01:23Z
      zoneDistributionConfig:
        mode: MULTI_ZONE
      replicaCount: 2
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: WEDNESDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
      deletionProtectionEnabled: true # Cross cluster replication config
      crossClusterReplicationConfig:
        clusterRole: SECONDARY
        primaryCluster:
          cluster: ${primaryCluster.id}
    options:
      dependsOn:
        - ${secondaryClusterRegionScp}
  primaryClusterRegionScp:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    name: primary_cluster_region_scp
    properties:
      name: mypolicy-primary-cluster
      location: us-east1
      serviceClass: gcp-memorystore-redis
      description: Primary cluster service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${primaryClusterConsumerSubnet.id}
  primaryClusterConsumerSubnet:
    type: gcp:compute:Subnetwork
    name: primary_cluster_consumer_subnet
    properties:
      name: mysubnet-primary-cluster
      ipCidrRange: 10.0.1.0/29
      region: us-east1
      network: ${consumerNet.id}
  secondaryClusterRegionScp:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    name: secondary_cluster_region_scp
    properties:
      name: mypolicy-secondary-cluster
      location: europe-west1
      serviceClass: gcp-memorystore-redis
      description: Secondary cluster service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${secondaryClusterConsumerSubnet.id}
  secondaryClusterConsumerSubnet:
    type: gcp:compute:Subnetwork
    name: secondary_cluster_consumer_subnet
    properties:
      name: mysubnet-secondary-cluster
      ipCidrRange: 10.0.2.0/29
      region: europe-west1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: mynetwork
      autoCreateSubnetworks: false

Redis Cluster Rdb

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_rdb = new gcp.redis.Cluster("cluster-rdb", {
    name: "rdb-cluster",
    shardCount: 3,
    pscConfigs: [{
        network: consumerNet.id,
    }],
    region: "us-central1",
    replicaCount: 0,
    nodeType: "REDIS_SHARED_CORE_NANO",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorizationMode: "AUTH_MODE_DISABLED",
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    deletionProtectionEnabled: true,
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
    persistenceConfig: {
        mode: "RDB",
        rdbConfig: {
            rdbSnapshotPeriod: "ONE_HOUR",
            rdbSnapshotStartTime: "2024-10-02T15:01:23Z",
        },
    },
}, {
    dependsOn: [_default],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_rdb = gcp.redis.Cluster("cluster-rdb",
    name="rdb-cluster",
    shard_count=3,
    psc_configs=[{
        "network": consumer_net.id,
    }],
    region="us-central1",
    replica_count=0,
    node_type="REDIS_SHARED_CORE_NANO",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorization_mode="AUTH_MODE_DISABLED",
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    deletion_protection_enabled=True,
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    persistence_config={
        "mode": "RDB",
        "rdb_config": {
            "rdb_snapshot_period": "ONE_HOUR",
            "rdb_snapshot_start_time": "2024-10-02T15:01:23Z",
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[default]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_rdb = new Gcp.Redis.Cluster("cluster-rdb", new()
    {
        Name = "rdb-cluster",
        ShardCount = 3,
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        Region = "us-central1",
        ReplicaCount = 0,
        NodeType = "REDIS_SHARED_CORE_NANO",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        AuthorizationMode = "AUTH_MODE_DISABLED",
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        DeletionProtectionEnabled = true,
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
        PersistenceConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigArgs
        {
            Mode = "RDB",
            RdbConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigRdbConfigArgs
            {
                RdbSnapshotPeriod = "ONE_HOUR",
                RdbSnapshotStartTime = "2024-10-02T15:01:23Z",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-rdb", &redis.ClusterArgs{
			Name:       pulumi.String("rdb-cluster"),
			ShardCount: pulumi.Int(3),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			Region:                pulumi.String("us-central1"),
			ReplicaCount:          pulumi.Int(0),
			NodeType:              pulumi.String("REDIS_SHARED_CORE_NANO"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
			PersistenceConfig: &redis.ClusterPersistenceConfigArgs{
				Mode: pulumi.String("RDB"),
				RdbConfig: &redis.ClusterPersistenceConfigRdbConfigArgs{
					RdbSnapshotPeriod:    pulumi.String("ONE_HOUR"),
					RdbSnapshotStartTime: pulumi.String("2024-10-02T15:01:23Z"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "cluster-rdb" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "rdb-cluster"
  shard_count = 3
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  region                  = "us-central1"
  replica_count           = 0
  node_type               = "REDIS_SHARED_CORE_NANO"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  authorization_mode      = "AUTH_MODE_DISABLED"
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  deletion_protection_enabled = true
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
  persistence_config = {
    mode = "RDB"
    rdb_config = {
      rdb_snapshot_period     = "ONE_HOUR"
      rdb_snapshot_start_time = "2024-10-02T15:01:23Z"
    }
  }
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigRdbConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_rdb = new Cluster("cluster-rdb", ClusterArgs.builder()
            .name("rdb-cluster")
            .shardCount(3)
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .region("us-central1")
            .replicaCount(0)
            .nodeType("REDIS_SHARED_CORE_NANO")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .authorizationMode("AUTH_MODE_DISABLED")
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .deletionProtectionEnabled(true)
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .persistenceConfig(ClusterPersistenceConfigArgs.builder()
                .mode("RDB")
                .rdbConfig(ClusterPersistenceConfigRdbConfigArgs.builder()
                    .rdbSnapshotPeriod("ONE_HOUR")
                    .rdbSnapshotStartTime("2024-10-02T15:01:23Z")
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

    }
}

resources:
  cluster-rdb:
    type: gcp:redis:Cluster
    properties:
      name: rdb-cluster
      shardCount: 3
      pscConfigs:
        - network: ${consumerNet.id}
      region: us-central1
      replicaCount: 0
      nodeType: REDIS_SHARED_CORE_NANO
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      authorizationMode: AUTH_MODE_DISABLED
      redisConfigs:
        maxmemory-policy: volatile-ttl
      deletionProtectionEnabled: true
      zoneDistributionConfig:
        mode: MULTI_ZONE
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
      persistenceConfig:
        mode: RDB
        rdbConfig:
          rdbSnapshotPeriod: ONE_HOUR
          rdbSnapshotStartTime: 2024-10-02T15:01:23Z
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false

Redis Cluster Aof

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_aof = new gcp.redis.Cluster("cluster-aof", {
    name: "aof-cluster",
    shardCount: 3,
    pscConfigs: [{
        network: consumerNet.id,
    }],
    region: "us-central1",
    replicaCount: 0,
    nodeType: "REDIS_SHARED_CORE_NANO",
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorizationMode: "AUTH_MODE_DISABLED",
    redisConfigs: {
        "maxmemory-policy": "volatile-ttl",
    },
    deletionProtectionEnabled: true,
    zoneDistributionConfig: {
        mode: "MULTI_ZONE",
    },
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "MONDAY",
            startTime: {
                hours: 1,
                minutes: 0,
                seconds: 0,
                nanos: 0,
            },
        }],
    },
    persistenceConfig: {
        mode: "AOF",
        aofConfig: {
            appendFsync: "EVERYSEC",
        },
    },
}, {
    dependsOn: [_default],
});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_aof = gcp.redis.Cluster("cluster-aof",
    name="aof-cluster",
    shard_count=3,
    psc_configs=[{
        "network": consumer_net.id,
    }],
    region="us-central1",
    replica_count=0,
    node_type="REDIS_SHARED_CORE_NANO",
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
    authorization_mode="AUTH_MODE_DISABLED",
    redis_configs={
        "maxmemory-policy": "volatile-ttl",
    },
    deletion_protection_enabled=True,
    zone_distribution_config={
        "mode": "MULTI_ZONE",
    },
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "MONDAY",
            "start_time": {
                "hours": 1,
                "minutes": 0,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    },
    persistence_config={
        "mode": "AOF",
        "aof_config": {
            "append_fsync": "EVERYSEC",
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[default]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_aof = new Gcp.Redis.Cluster("cluster-aof", new()
    {
        Name = "aof-cluster",
        ShardCount = 3,
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        Region = "us-central1",
        ReplicaCount = 0,
        NodeType = "REDIS_SHARED_CORE_NANO",
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_DISABLED",
        AuthorizationMode = "AUTH_MODE_DISABLED",
        RedisConfigs =
        {
            { "maxmemory-policy", "volatile-ttl" },
        },
        DeletionProtectionEnabled = true,
        ZoneDistributionConfig = new Gcp.Redis.Inputs.ClusterZoneDistributionConfigArgs
        {
            Mode = "MULTI_ZONE",
        },
        MaintenancePolicy = new Gcp.Redis.Inputs.ClusterMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "MONDAY",
                    StartTime = new Gcp.Redis.Inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 1,
                        Minutes = 0,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
        PersistenceConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigArgs
        {
            Mode = "AOF",
            AofConfig = new Gcp.Redis.Inputs.ClusterPersistenceConfigAofConfigArgs
            {
                AppendFsync = "EVERYSEC",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-aof", &redis.ClusterArgs{
			Name:       pulumi.String("aof-cluster"),
			ShardCount: pulumi.Int(3),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			Region:                pulumi.String("us-central1"),
			ReplicaCount:          pulumi.Int(0),
			NodeType:              pulumi.String("REDIS_SHARED_CORE_NANO"),
			TransitEncryptionMode: pulumi.String("TRANSIT_ENCRYPTION_MODE_DISABLED"),
			AuthorizationMode:     pulumi.String("AUTH_MODE_DISABLED"),
			RedisConfigs: pulumi.StringMap{
				"maxmemory-policy": pulumi.String("volatile-ttl"),
			},
			DeletionProtectionEnabled: pulumi.Bool(true),
			ZoneDistributionConfig: &redis.ClusterZoneDistributionConfigArgs{
				Mode: pulumi.String("MULTI_ZONE"),
			},
			MaintenancePolicy: &redis.ClusterMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArray{
					&redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day: pulumi.String("MONDAY"),
						StartTime: &redis.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(1),
							Minutes: pulumi.Int(0),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
			PersistenceConfig: &redis.ClusterPersistenceConfigArgs{
				Mode: pulumi.String("AOF"),
				AofConfig: &redis.ClusterPersistenceConfigAofConfigArgs{
					AppendFsync: pulumi.String("EVERYSEC"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "cluster-aof" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "aof-cluster"
  shard_count = 3
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  region                  = "us-central1"
  replica_count           = 0
  node_type               = "REDIS_SHARED_CORE_NANO"
  transit_encryption_mode = "TRANSIT_ENCRYPTION_MODE_DISABLED"
  authorization_mode      = "AUTH_MODE_DISABLED"
  redis_configs = {
    "maxmemory-policy" = "volatile-ttl"
  }
  deletion_protection_enabled = true
  zone_distribution_config = {
    mode = "MULTI_ZONE"
  }
  maintenance_policy = {
    weekly_maintenance_windows = [{
      "day" = "MONDAY"
      "startTime" = {
        "hours"   = 1
        "minutes" = 0
        "seconds" = 0
        "nanos"   = 0
      }
    }]
  }
  persistence_config = {
    mode = "AOF"
    aof_config = {
      append_fsync = "EVERYSEC"
    }
  }
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterZoneDistributionConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs;
import com.pulumi.gcp.redis.inputs.ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigArgs;
import com.pulumi.gcp.redis.inputs.ClusterPersistenceConfigAofConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_aof = new Cluster("cluster-aof", ClusterArgs.builder()
            .name("aof-cluster")
            .shardCount(3)
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .region("us-central1")
            .replicaCount(0)
            .nodeType("REDIS_SHARED_CORE_NANO")
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_DISABLED")
            .authorizationMode("AUTH_MODE_DISABLED")
            .redisConfigs(Map.of("maxmemory-policy", "volatile-ttl"))
            .deletionProtectionEnabled(true)
            .zoneDistributionConfig(ClusterZoneDistributionConfigArgs.builder()
                .mode("MULTI_ZONE")
                .build())
            .maintenancePolicy(ClusterMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(ClusterMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("MONDAY")
                    .startTime(ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(1)
                        .minutes(0)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .persistenceConfig(ClusterPersistenceConfigArgs.builder()
                .mode("AOF")
                .aofConfig(ClusterPersistenceConfigAofConfigArgs.builder()
                    .appendFsync("EVERYSEC")
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

    }
}

resources:
  cluster-aof:
    type: gcp:redis:Cluster
    properties:
      name: aof-cluster
      shardCount: 3
      pscConfigs:
        - network: ${consumerNet.id}
      region: us-central1
      replicaCount: 0
      nodeType: REDIS_SHARED_CORE_NANO
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_DISABLED
      authorizationMode: AUTH_MODE_DISABLED
      redisConfigs:
        maxmemory-policy: volatile-ttl
      deletionProtectionEnabled: true
      zoneDistributionConfig:
        mode: MULTI_ZONE
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: MONDAY
            startTime:
              hours: 1
              minutes: 0
              seconds: 0
              nanos: 0
      persistenceConfig:
        mode: AOF
        aofConfig:
          appendFsync: EVERYSEC
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false

Redis Cluster Cmek

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "my-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "my-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const _default = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "my-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    description: "my basic service connection policy",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const cluster_cmek = new gcp.redis.Cluster("cluster-cmek", {
    name: "cmek-cluster",
    shardCount: 3,
    pscConfigs: [{
        network: consumerNet.id,
    }],
    kmsKey: "my-key",
    region: "us-central1",
    deletionProtectionEnabled: true,
}, {
    dependsOn: [_default],
});
const project = gcp.organizations.getProject({});

import pulumi
import pulumi_gcp as gcp

consumer_net = gcp.compute.Network("consumer_net",
    name="my-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="my-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="my-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    description="my basic service connection policy",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
cluster_cmek = gcp.redis.Cluster("cluster-cmek",
    name="cmek-cluster",
    shard_count=3,
    psc_configs=[{
        "network": consumer_net.id,
    }],
    kms_key="my-key",
    region="us-central1",
    deletion_protection_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[default]))
project = gcp.organizations.get_project()

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "my-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "my-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var @default = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "my-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Description = "my basic service connection policy",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var cluster_cmek = new Gcp.Redis.Cluster("cluster-cmek", new()
    {
        Name = "cmek-cluster",
        ShardCount = 3,
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        KmsKey = "my-key",
        Region = "us-central1",
        DeletionProtectionEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });

    var project = Gcp.Organizations.GetProject.Invoke();

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("my-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("my-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_default, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("my-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Description:  pulumi.String("my basic service connection policy"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "cluster-cmek", &redis.ClusterArgs{
			Name:       pulumi.String("cmek-cluster"),
			ShardCount: pulumi.Int(3),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			KmsKey:                    pulumi.String("my-key"),
			Region:                    pulumi.String("us-central1"),
			DeletionProtectionEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		_, err = organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

data "gcp_organizations_getproject" "project" {
}

resource "gcp_redis_cluster" "cluster-cmek" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default]
  name        = "cmek-cluster"
  shard_count = 3
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  kms_key                     = "my-key"
  region                      = "us-central1"
  deletion_protection_enabled = true
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "my-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  description   = "my basic service connection policy"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "my-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "my-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("my-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("my-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var default_ = new ServiceConnectionPolicy("default", ServiceConnectionPolicyArgs.builder()
            .name("my-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .description("my basic service connection policy")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var cluster_cmek = new Cluster("cluster-cmek", ClusterArgs.builder()
            .name("cmek-cluster")
            .shardCount(3)
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .kmsKey("my-key")
            .region("us-central1")
            .deletionProtectionEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());

        final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
            .build());

    }
}

resources:
  cluster-cmek:
    type: gcp:redis:Cluster
    properties:
      name: cmek-cluster
      shardCount: 3
      pscConfigs:
        - network: ${consumerNet.id}
      kmsKey: my-key
      region: us-central1
      deletionProtectionEnabled: true
    options:
      dependsOn:
        - ${default}
  default:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    properties:
      name: my-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      description: my basic service connection policy
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: my-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: my-network
      autoCreateSubnetworks: false
variables:
  project:
    fn::invoke:
      function: gcp:organizations:getProject
      arguments: {}

Redis Cluster Flexible Ca

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const _default = new gcp.certificateauthority.CaPool("default", {
    name: "ca-pool",
    location: "us-central1",
    tier: "ENTERPRISE",
});
const defaultAuthority = new gcp.certificateauthority.Authority("default", {
    pool: _default.name,
    certificateAuthorityId: "ca-auth",
    location: "us-central1",
    config: {
        subjectConfig: {
            subject: {
                organization: "Google",
                commonName: "my-redis-ca",
            },
        },
        x509Config: {
            caOptions: {
                isCa: true,
            },
            keyUsage: {
                baseKeyUsage: {
                    certSign: true,
                    crlSign: true,
                },
                extendedKeyUsage: {
                    serverAuth: true,
                },
            },
        },
    },
    keySpec: {
        algorithm: "RSA_PKCS1_4096_SHA256",
    },
    ignoreActiveCertificatesOnDeletion: true,
    deletionProtection: false,
    skipGracePeriod: true,
});
const consumerNet = new gcp.compute.Network("consumer_net", {
    name: "ca-network",
    autoCreateSubnetworks: false,
});
const consumerSubnet = new gcp.compute.Subnetwork("consumer_subnet", {
    name: "ca-subnet",
    ipCidrRange: "10.0.0.248/29",
    region: "us-central1",
    network: consumerNet.id,
});
const defaultServiceConnectionPolicy = new gcp.networkconnectivity.ServiceConnectionPolicy("default", {
    name: "ca-policy",
    location: "us-central1",
    serviceClass: "gcp-memorystore-redis",
    network: consumerNet.id,
    pscConfig: {
        subnetworks: [consumerSubnet.id],
    },
});
const test_cluster = new gcp.redis.Cluster("test-cluster", {
    name: "ca-cluster",
    shardCount: 3,
    region: "us-central1",
    pscConfigs: [{
        network: consumerNet.id,
    }],
    transitEncryptionMode: "TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION",
    serverCaMode: "SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA",
    serverCaPool: _default.id,
    deletionProtectionEnabled: true,
}, {
    dependsOn: [
        defaultServiceConnectionPolicy,
        defaultAuthority,
    ],
});

import pulumi
import pulumi_gcp as gcp

default = gcp.certificateauthority.CaPool("default",
    name="ca-pool",
    location="us-central1",
    tier="ENTERPRISE")
default_authority = gcp.certificateauthority.Authority("default",
    pool=default.name,
    certificate_authority_id="ca-auth",
    location="us-central1",
    config={
        "subject_config": {
            "subject": {
                "organization": "Google",
                "common_name": "my-redis-ca",
            },
        },
        "x509_config": {
            "ca_options": {
                "is_ca": True,
            },
            "key_usage": {
                "base_key_usage": {
                    "cert_sign": True,
                    "crl_sign": True,
                },
                "extended_key_usage": {
                    "server_auth": True,
                },
            },
        },
    },
    key_spec={
        "algorithm": "RSA_PKCS1_4096_SHA256",
    },
    ignore_active_certificates_on_deletion=True,
    deletion_protection=False,
    skip_grace_period=True)
consumer_net = gcp.compute.Network("consumer_net",
    name="ca-network",
    auto_create_subnetworks=False)
consumer_subnet = gcp.compute.Subnetwork("consumer_subnet",
    name="ca-subnet",
    ip_cidr_range="10.0.0.248/29",
    region="us-central1",
    network=consumer_net.id)
default_service_connection_policy = gcp.networkconnectivity.ServiceConnectionPolicy("default",
    name="ca-policy",
    location="us-central1",
    service_class="gcp-memorystore-redis",
    network=consumer_net.id,
    psc_config={
        "subnetworks": [consumer_subnet.id],
    })
test_cluster = gcp.redis.Cluster("test-cluster",
    name="ca-cluster",
    shard_count=3,
    region="us-central1",
    psc_configs=[{
        "network": consumer_net.id,
    }],
    transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION",
    server_ca_mode="SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA",
    server_ca_pool=default.id,
    deletion_protection_enabled=True,
    opts = pulumi.ResourceOptions(depends_on=[
            default_service_connection_policy,
            default_authority,
        ]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.CertificateAuthority.CaPool("default", new()
    {
        Name = "ca-pool",
        Location = "us-central1",
        Tier = "ENTERPRISE",
    });

    var defaultAuthority = new Gcp.CertificateAuthority.Authority("default", new()
    {
        Pool = @default.Name,
        CertificateAuthorityId = "ca-auth",
        Location = "us-central1",
        Config = new Gcp.CertificateAuthority.Inputs.AuthorityConfigArgs
        {
            SubjectConfig = new Gcp.CertificateAuthority.Inputs.AuthorityConfigSubjectConfigArgs
            {
                Subject = new Gcp.CertificateAuthority.Inputs.AuthorityConfigSubjectConfigSubjectArgs
                {
                    Organization = "Google",
                    CommonName = "my-redis-ca",
                },
            },
            X509Config = new Gcp.CertificateAuthority.Inputs.AuthorityConfigX509ConfigArgs
            {
                CaOptions = new Gcp.CertificateAuthority.Inputs.AuthorityConfigX509ConfigCaOptionsArgs
                {
                    IsCa = true,
                },
                KeyUsage = new Gcp.CertificateAuthority.Inputs.AuthorityConfigX509ConfigKeyUsageArgs
                {
                    BaseKeyUsage = new Gcp.CertificateAuthority.Inputs.AuthorityConfigX509ConfigKeyUsageBaseKeyUsageArgs
                    {
                        CertSign = true,
                        CrlSign = true,
                    },
                    ExtendedKeyUsage = new Gcp.CertificateAuthority.Inputs.AuthorityConfigX509ConfigKeyUsageExtendedKeyUsageArgs
                    {
                        ServerAuth = true,
                    },
                },
            },
        },
        KeySpec = new Gcp.CertificateAuthority.Inputs.AuthorityKeySpecArgs
        {
            Algorithm = "RSA_PKCS1_4096_SHA256",
        },
        IgnoreActiveCertificatesOnDeletion = true,
        DeletionProtection = false,
        SkipGracePeriod = true,
    });

    var consumerNet = new Gcp.Compute.Network("consumer_net", new()
    {
        Name = "ca-network",
        AutoCreateSubnetworks = false,
    });

    var consumerSubnet = new Gcp.Compute.Subnetwork("consumer_subnet", new()
    {
        Name = "ca-subnet",
        IpCidrRange = "10.0.0.248/29",
        Region = "us-central1",
        Network = consumerNet.Id,
    });

    var defaultServiceConnectionPolicy = new Gcp.NetworkConnectivity.ServiceConnectionPolicy("default", new()
    {
        Name = "ca-policy",
        Location = "us-central1",
        ServiceClass = "gcp-memorystore-redis",
        Network = consumerNet.Id,
        PscConfig = new Gcp.NetworkConnectivity.Inputs.ServiceConnectionPolicyPscConfigArgs
        {
            Subnetworks = new[]
            {
                consumerSubnet.Id,
            },
        },
    });

    var test_cluster = new Gcp.Redis.Cluster("test-cluster", new()
    {
        Name = "ca-cluster",
        ShardCount = 3,
        Region = "us-central1",
        PscConfigs = new[]
        {
            new Gcp.Redis.Inputs.ClusterPscConfigArgs
            {
                Network = consumerNet.Id,
            },
        },
        TransitEncryptionMode = "TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION",
        ServerCaMode = "SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA",
        ServerCaPool = @default.Id,
        DeletionProtectionEnabled = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            defaultServiceConnectionPolicy,
            defaultAuthority,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/certificateauthority"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/redis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := certificateauthority.NewCaPool(ctx, "default", &certificateauthority.CaPoolArgs{
			Name:     pulumi.String("ca-pool"),
			Location: pulumi.String("us-central1"),
			Tier:     pulumi.String("ENTERPRISE"),
		})
		if err != nil {
			return err
		}
		defaultAuthority, err := certificateauthority.NewAuthority(ctx, "default", &certificateauthority.AuthorityArgs{
			Pool:                   _default.Name,
			CertificateAuthorityId: pulumi.String("ca-auth"),
			Location:               pulumi.String("us-central1"),
			Config: &certificateauthority.AuthorityConfigArgs{
				SubjectConfig: &certificateauthority.AuthorityConfigSubjectConfigArgs{
					Subject: &certificateauthority.AuthorityConfigSubjectConfigSubjectArgs{
						Organization: pulumi.String("Google"),
						CommonName:   pulumi.String("my-redis-ca"),
					},
				},
				X509Config: &certificateauthority.AuthorityConfigX509ConfigArgs{
					CaOptions: &certificateauthority.AuthorityConfigX509ConfigCaOptionsArgs{
						IsCa: pulumi.Bool(true),
					},
					KeyUsage: &certificateauthority.AuthorityConfigX509ConfigKeyUsageArgs{
						BaseKeyUsage: &certificateauthority.AuthorityConfigX509ConfigKeyUsageBaseKeyUsageArgs{
							CertSign: pulumi.Bool(true),
							CrlSign:  pulumi.Bool(true),
						},
						ExtendedKeyUsage: &certificateauthority.AuthorityConfigX509ConfigKeyUsageExtendedKeyUsageArgs{
							ServerAuth: pulumi.Bool(true),
						},
					},
				},
			},
			KeySpec: &certificateauthority.AuthorityKeySpecArgs{
				Algorithm: pulumi.String("RSA_PKCS1_4096_SHA256"),
			},
			IgnoreActiveCertificatesOnDeletion: pulumi.Bool(true),
			DeletionProtection:                 pulumi.Bool(false),
			SkipGracePeriod:                    pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		consumerNet, err := compute.NewNetwork(ctx, "consumer_net", &compute.NetworkArgs{
			Name:                  pulumi.String("ca-network"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		consumerSubnet, err := compute.NewSubnetwork(ctx, "consumer_subnet", &compute.SubnetworkArgs{
			Name:        pulumi.String("ca-subnet"),
			IpCidrRange: pulumi.String("10.0.0.248/29"),
			Region:      pulumi.String("us-central1"),
			Network:     consumerNet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		defaultServiceConnectionPolicy, err := networkconnectivity.NewServiceConnectionPolicy(ctx, "default", &networkconnectivity.ServiceConnectionPolicyArgs{
			Name:         pulumi.String("ca-policy"),
			Location:     pulumi.String("us-central1"),
			ServiceClass: pulumi.String("gcp-memorystore-redis"),
			Network:      consumerNet.ID().ToIDOutput().ToStringOutput(),
			PscConfig: &networkconnectivity.ServiceConnectionPolicyPscConfigArgs{
				Subnetworks: pulumi.StringArray{
					consumerSubnet.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = redis.NewCluster(ctx, "test-cluster", &redis.ClusterArgs{
			Name:       pulumi.String("ca-cluster"),
			ShardCount: pulumi.Int(3),
			Region:     pulumi.String("us-central1"),
			PscConfigs: redis.ClusterPscConfigArray{
				&redis.ClusterPscConfigArgs{
					Network: consumerNet.ID().ToIDOutput().ToStringOutput(),
				},
			},
			TransitEncryptionMode:     pulumi.String("TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION"),
			ServerCaMode:              pulumi.String("SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA"),
			ServerCaPool:              _default.ID().ToIDOutput().ToStringOutput(),
			DeletionProtectionEnabled: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			defaultServiceConnectionPolicy,
			defaultAuthority,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_redis_cluster" "test-cluster" {
  depends_on  = [gcp_networkconnectivity_serviceconnectionpolicy.default, gcp_certificateauthority_authority.default]
  name        = "ca-cluster"
  shard_count = 3
  region      = "us-central1"
  psc_configs {
    network = gcp_compute_network.consumer_net.id
  }
  transit_encryption_mode     = "TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION"
  server_ca_mode              = "SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA"
  server_ca_pool              = gcp_certificateauthority_capool.default.id
  deletion_protection_enabled = true
}
resource "gcp_certificateauthority_capool" "default" {
  name     = "ca-pool"
  location = "us-central1"
  tier     = "ENTERPRISE"
}
resource "gcp_certificateauthority_authority" "default" {
  pool                     = gcp_certificateauthority_capool.default.name
  certificate_authority_id = "ca-auth"
  location                 = "us-central1"
  config = {
    subject_config = {
      subject = {
        organization = "Google"
        common_name  = "my-redis-ca"
      }
    }
    x509_config = {
      ca_options = {
        is_ca = true
      }
      key_usage = {
        base_key_usage = {
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage = {
          server_auth = true
        }
      }
    }
  }
  key_spec = {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  ignore_active_certificates_on_deletion = true
  deletion_protection                    = false
  skip_grace_period                      = true
}
resource "gcp_networkconnectivity_serviceconnectionpolicy" "default" {
  name          = "ca-policy"
  location      = "us-central1"
  service_class = "gcp-memorystore-redis"
  network       = gcp_compute_network.consumer_net.id
  psc_config = {
    subnetworks = [gcp_compute_subnetwork.consumer_subnet.id]
  }
}
resource "gcp_compute_subnetwork" "consumer_subnet" {
  name          = "ca-subnet"
  ip_cidr_range = "10.0.0.248/29"
  region        = "us-central1"
  network       = gcp_compute_network.consumer_net.id
}
resource "gcp_compute_network" "consumer_net" {
  name                    = "ca-network"
  auto_create_subnetworks = false
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.certificateauthority.CaPool;
import com.pulumi.gcp.certificateauthority.CaPoolArgs;
import com.pulumi.gcp.certificateauthority.Authority;
import com.pulumi.gcp.certificateauthority.AuthorityArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigSubjectConfigArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigSubjectConfigSubjectArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigX509ConfigArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigX509ConfigCaOptionsArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigX509ConfigKeyUsageArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigX509ConfigKeyUsageBaseKeyUsageArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityConfigX509ConfigKeyUsageExtendedKeyUsageArgs;
import com.pulumi.gcp.certificateauthority.inputs.AuthorityKeySpecArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicy;
import com.pulumi.gcp.networkconnectivity.ServiceConnectionPolicyArgs;
import com.pulumi.gcp.networkconnectivity.inputs.ServiceConnectionPolicyPscConfigArgs;
import com.pulumi.gcp.redis.Cluster;
import com.pulumi.gcp.redis.ClusterArgs;
import com.pulumi.gcp.redis.inputs.ClusterPscConfigArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var default_ = new CaPool("default", CaPoolArgs.builder()
            .name("ca-pool")
            .location("us-central1")
            .tier("ENTERPRISE")
            .build());

        var defaultAuthority = new Authority("defaultAuthority", AuthorityArgs.builder()
            .pool(default_.name())
            .certificateAuthorityId("ca-auth")
            .location("us-central1")
            .config(AuthorityConfigArgs.builder()
                .subjectConfig(AuthorityConfigSubjectConfigArgs.builder()
                    .subject(AuthorityConfigSubjectConfigSubjectArgs.builder()
                        .organization("Google")
                        .commonName("my-redis-ca")
                        .build())
                    .build())
                .x509Config(AuthorityConfigX509ConfigArgs.builder()
                    .caOptions(AuthorityConfigX509ConfigCaOptionsArgs.builder()
                        .isCa(true)
                        .build())
                    .keyUsage(AuthorityConfigX509ConfigKeyUsageArgs.builder()
                        .baseKeyUsage(AuthorityConfigX509ConfigKeyUsageBaseKeyUsageArgs.builder()
                            .certSign(true)
                            .crlSign(true)
                            .build())
                        .extendedKeyUsage(AuthorityConfigX509ConfigKeyUsageExtendedKeyUsageArgs.builder()
                            .serverAuth(true)
                            .build())
                        .build())
                    .build())
                .build())
            .keySpec(AuthorityKeySpecArgs.builder()
                .algorithm("RSA_PKCS1_4096_SHA256")
                .build())
            .ignoreActiveCertificatesOnDeletion(true)
            .deletionProtection(false)
            .skipGracePeriod(true)
            .build());

        var consumerNet = new Network("consumerNet", NetworkArgs.builder()
            .name("ca-network")
            .autoCreateSubnetworks(false)
            .build());

        var consumerSubnet = new Subnetwork("consumerSubnet", SubnetworkArgs.builder()
            .name("ca-subnet")
            .ipCidrRange("10.0.0.248/29")
            .region("us-central1")
            .network(consumerNet.id())
            .build());

        var defaultServiceConnectionPolicy = new ServiceConnectionPolicy("defaultServiceConnectionPolicy", ServiceConnectionPolicyArgs.builder()
            .name("ca-policy")
            .location("us-central1")
            .serviceClass("gcp-memorystore-redis")
            .network(consumerNet.id())
            .pscConfig(ServiceConnectionPolicyPscConfigArgs.builder()
                .subnetworks(consumerSubnet.id())
                .build())
            .build());

        var test_cluster = new Cluster("test-cluster", ClusterArgs.builder()
            .name("ca-cluster")
            .shardCount(3)
            .region("us-central1")
            .pscConfigs(ClusterPscConfigArgs.builder()
                .network(consumerNet.id())
                .build())
            .transitEncryptionMode("TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION")
            .serverCaMode("SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA")
            .serverCaPool(default_.id())
            .deletionProtectionEnabled(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(
                    defaultServiceConnectionPolicy,
                    defaultAuthority)
                .build());

    }
}

resources:
  test-cluster:
    type: gcp:redis:Cluster
    properties:
      name: ca-cluster
      shardCount: 3
      region: us-central1
      pscConfigs:
        - network: ${consumerNet.id}
      transitEncryptionMode: TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION
      serverCaMode: SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA
      serverCaPool: ${default.id}
      deletionProtectionEnabled: true
    options:
      dependsOn:
        - ${defaultServiceConnectionPolicy}
        - ${defaultAuthority}
  default:
    type: gcp:certificateauthority:CaPool
    properties:
      name: ca-pool
      location: us-central1
      tier: ENTERPRISE
  defaultAuthority:
    type: gcp:certificateauthority:Authority
    name: default
    properties:
      pool: ${default.name}
      certificateAuthorityId: ca-auth
      location: us-central1
      config:
        subjectConfig:
          subject:
            organization: Google
            commonName: my-redis-ca
        x509Config:
          caOptions:
            isCa: true
          keyUsage:
            baseKeyUsage:
              certSign: true
              crlSign: true
            extendedKeyUsage:
              serverAuth: true
      keySpec:
        algorithm: RSA_PKCS1_4096_SHA256
      ignoreActiveCertificatesOnDeletion: true
      deletionProtection: false
      skipGracePeriod: true
  defaultServiceConnectionPolicy:
    type: gcp:networkconnectivity:ServiceConnectionPolicy
    name: default
    properties:
      name: ca-policy
      location: us-central1
      serviceClass: gcp-memorystore-redis
      network: ${consumerNet.id}
      pscConfig:
        subnetworks:
          - ${consumerSubnet.id}
  consumerSubnet:
    type: gcp:compute:Subnetwork
    name: consumer_subnet
    properties:
      name: ca-subnet
      ipCidrRange: 10.0.0.248/29
      region: us-central1
      network: ${consumerNet.id}
  consumerNet:
    type: gcp:compute:Network
    name: consumer_net
    properties:
      name: ca-network
      autoCreateSubnetworks: false

Import

Cluster can be imported using any of these accepted formats:

• projects/{{project}}/locations/{{region}}/clusters/{{name}}
• {{project}}/{{region}}/{{name}}
• {{region}}/{{name}}
• {{name}}

When using the pulumi import command, Cluster can be imported using one of the formats above. For example:

$ pulumi import gcp:redis/cluster:Cluster default projects/{{project}}/locations/{{region}}/clusters/{{name}}
$ pulumi import gcp:redis/cluster:Cluster default {{project}}/{{region}}/{{name}}
$ pulumi import gcp:redis/cluster:Cluster default {{region}}/{{name}}
$ pulumi import gcp:redis/cluster:Cluster default {{name}}

Constructors

Cluster(String name, {ClusterArgs? args, CustomResourceOptions? options})

Creates a new Cluster. name The Pulumi resource name. args Arguments used to configure this Cluster. The set of arguments for Cluster. options Resource options controlling this resource's behavior.

Cluster.reference(String urn)

Creates a typed reference to an existing Cluster resource.

Properties

aclPolicy ↔ Output<String?>

Optional. The name of the ACL policy to attach to the cluster.

late, final

authorizationMode ↔ Output<String?>

Optional. The authorization mode of the Redis cluster. If not provided, auth feature is disabled for the cluster. Default value is AUTH_MODE_DISABLED. Possible values are: AUTH_MODE_UNSPECIFIED, AUTH_MODE_IAM_AUTH, AUTH_MODE_DISABLED.

late, final

automatedBackupConfig ↔ Output<ClusterAutomatedBackupConfig?>

The automated backup config for a instance. Structure is documented below.

late, final

availableMaintenanceVersions ↔ Output<List<String>>

This field is used to determine the available maintenance versions for the self service update.

late, final

backupCollection ↔ Output<String>

The backup collection full resource name. Example: projects/{project}/locations/{location}/backupCollections/{collection}

late, final

childResources → Set<Resource>

final, inherited

completionSources ↔ Map<String, IOutputCompletionSource>

late, final, inherited

createTime ↔ Output<String>

The timestamp associated with the cluster creation request. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".

late, final

crossClusterReplicationConfig ↔ Output<ClusterCrossClusterReplicationConfig>

Cross cluster replication config Structure is documented below.

late, final

deletionPolicy ↔ Output<String>

Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.

late, final

deletionProtectionEnabled ↔ Output<bool?>

Optional. Indicates if the cluster is deletion protected or not. If the value if set to true, any delete cluster operation will fail. Default value is true.

late, final

discoveryEndpoints ↔ Output<List<ClusterDiscoveryEndpoint>>

Output only. Endpoints created on each given network, for Redis clients to connect to the cluster. Currently only one endpoint is supported. Structure is documented below.

late, final

effectiveLabels ↔ Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

late, final

effectiveMaintenanceVersion ↔ Output<String>

This field represents the actual maintenance version of the cluster.

late, final

gcsSource ↔ Output<ClusterGcsSource?>

Backups stored in Cloud Storage buckets. The Cloud Storage buckets need to be the same region as the clusters. Structure is documented below.

late, final

hashCode → int

The hash code for this object.

no setter, inherited

id ↔ Output<String>

getter/setter pair, inherited

isAclPolicyInSync ↔ Output<bool>

Optional. Whether the ACL policy is in sync with the cluster.

late, final

isCustom → bool

Returns whether this resource is provider-managed.

no setter, inherited

isProtected → bool

Returns whether this resource is protected from deletion.

no setter, inherited

isRemote → bool

Whether this resource is registered as remote.

no setter, inherited

isResourceReference → bool

Whether this instance represents a resource value returned over RPC.

final, inherited

kmsKey ↔ Output<String?>

The KMS key used to encrypt the at-rest data of the cluster.

late, final

labels ↔ Output<Map<String, String>?>

Resource labels to represent user provided metadata. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.

late, final

maintenancePolicy ↔ Output<ClusterMaintenancePolicy?>

Maintenance policy for a cluster Structure is documented below.

late, final

maintenanceSchedules ↔ Output<List<ClusterMaintenanceSchedule>>

Upcoming maintenance schedule. Structure is documented below.

late, final

maintenanceVersion ↔ Output<String?>

This field can be used to trigger self service update to indicate the desired maintenance version. The input to this field can be determined by the availableMaintenanceVersions field. Note: This field can only be specified when updating an existing cluster to a newer version. Downgrades are currently not supported!

late, final

managedBackupSource ↔ Output<ClusterManagedBackupSource?>

Backups that generated and managed by memorystore. Structure is documented below.

late, final

managedServerCas ↔ Output<List<ClusterManagedServerCa>>

Cluster's Certificate Authority. This field will only be populated if Redis Cluster's transitEncryptionMode is TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION Structure is documented below.

late, final

name ↔ Output<String>

Unique name of the resource in this scope including project and location using the form: projects/{projectId}/locations/{locationId}/clusters/{clusterId}

late, final

nodeType ↔ Output<String>

The nodeType for the Redis cluster. If not provided, REDIS_HIGHMEM_MEDIUM will be used as default Possible values are: REDIS_SHARED_CORE_NANO, REDIS_HIGHMEM_MEDIUM, REDIS_HIGHCPU_MEDIUM, REDIS_STANDARD_LARGE, REDIS_HIGHMEM_XLARGE, REDIS_HIGHMEM_2XLARGE, REDIS_STANDARD_SMALL.

late, final

persistenceConfig ↔ Output<ClusterPersistenceConfig>

Persistence config (RDB, AOF) for the cluster. Structure is documented below.

late, final

preciseSizeGb ↔ Output<double>

Output only. Redis memory precise size in GB for the entire cluster.

late, final

project ↔ Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

late, final

pscConfigs ↔ Output<List<ClusterPscConfig>?>

Required. Each PscConfig configures the consumer network where two network addresses will be designated to the cluster for client access. Currently, only one PscConfig is supported. Structure is documented below.

late, final

pscConnections ↔ Output<List<ClusterPscConnection>>

Output only. PSC connections for discovery of the cluster topology and accessing the cluster. Structure is documented below.

late, final

pscServiceAttachments ↔ Output<List<ClusterPscServiceAttachment>>

Service attachment details to configure Psc connections. Structure is documented below.

late, final

pulumiLabels ↔ Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

late, final

redisConfigs ↔ Output<Map<String, String>?>

Configure Redis Cluster behavior using a subset of native Redis configuration parameters. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/cluster/supported-instance-configurations

late, final

region ↔ Output<String>

The name of the region of the Redis cluster.

late, final

replicaCount ↔ Output<int?>

Optional. The number of replica nodes per shard.

late, final

resourceTransforms → List<ResourceTransform>

Inherited/explicit async transforms.

no setter, inherited

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

serverCaMode ↔ Output<String>

The serverCaMode for the TLS enabled Redis cluster. If not provided, SERVER_CA_MODE_GOOGLE_MANAGED_PER_INSTANCE_CA will be used as default Possible values are: SERVER_CA_MODE_GOOGLE_MANAGED_PER_INSTANCE_CA, SERVER_CA_MODE_GOOGLE_MANAGED_SHARED_CA, SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA, SERVER_CA_MODE_UNSPECIFIED.

late, final

serverCaPool ↔ Output<String?>

The resource name of the server CA pool for an instance with SERVER_CA_MODE_CUSTOMER_MANAGED_CAS_CA as the server_ca_mode. Format: projects/{project}/locations/{region}/caPools/{caPoolId}

late, final

shardCount ↔ Output<int>

Required. Number of shards for the Redis cluster.

late, final

sizeGb ↔ Output<int>

Output only. Redis memory size in GB for the entire cluster.

late, final

state ↔ Output<String>

The current state of this cluster. Can be CREATING, READY, UPDATING, DELETING and SUSPENDED

late, final

stateInfos ↔ Output<List<ClusterStateInfo>>

Output only. Additional information about the current state of the cluster. Structure is documented below.

late, final

transformations → List<ResourceTransformation>

Inherited/explicit legacy transformations.

no setter, inherited

transitEncryptionMode ↔ Output<String?>

Optional. The in-transit encryption for the Redis cluster. If not provided, encryption is disabled for the cluster. Default value is TRANSIT_ENCRYPTION_MODE_DISABLED. Possible values are: TRANSIT_ENCRYPTION_MODE_UNSPECIFIED, TRANSIT_ENCRYPTION_MODE_DISABLED, TRANSIT_ENCRYPTION_MODE_SERVER_AUTHENTICATION.

late, final

uid ↔ Output<String>

System assigned, unique identifier for the cluster.

late, final

urn ↔ Output<String>

late, final, inherited

zoneDistributionConfig ↔ Output<ClusterZoneDistributionConfig>

Immutable. Zone distribution config for Memorystore Redis cluster. Structure is documented below.

late, final

Methods

failId(Object error) → void

Completes this resource ID with an error when registration fails.

inherited

failOutputs(Object error) → void

Completes all output properties with error.

inherited

failUrn(Object error) → void

Completes this resource URN with an error when registration fails.

inherited

getProvider(String moduleMember) → ProviderResource?

Returns provider for moduleMember's package, if configured.

inherited

getResourceName() → String

Returns this resource's logical name.

inherited

getResourceType() → String

Returns this resource's Pulumi type token.

inherited

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>

Registers a dynamic output property for this resource.

inherited

resolveId(String? value, {required bool isKnown}) → void

Resolves the provider-assigned ID for this resource.

inherited

resolveOutputs(Struct outputs) → void

Resolves all output properties from a monitor response payload.

inherited

resolveUrn(String value) → void

Resolves this resource's URN once assigned by the engine.

inherited

serializeProperties(Map<String, dynamic> properties) → Future<Struct>

Serializes resource properties for RPC transmission.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Static Methods

get(String name, Input<String> id, {ClusterState? state, CustomResourceOptions? options}) → Cluster

Gets an existing Cluster resource's state with the given name and id.