1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. redis
  5. Instance
Google Cloud Classic v7.23.0 published on Wednesday, May 15, 2024 by Pulumi

gcp.redis.Instance

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.23.0 published on Wednesday, May 15, 2024 by Pulumi

    A Google Cloud Redis instance.

    To get more information about Instance, see:

    Example Usage

    Redis Instance Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const cache = new gcp.redis.Instance("cache", {
        name: "memory-cache",
        memorySizeGb: 1,
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    cache = gcp.redis.Instance("cache",
        name="memory-cache",
        memory_size_gb=1)
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := redis.NewInstance(ctx, "cache", &redis.InstanceArgs{
    			Name:         pulumi.String("memory-cache"),
    			MemorySizeGb: pulumi.Int(1),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var cache = new Gcp.Redis.Instance("cache", new()
        {
            Name = "memory-cache",
            MemorySizeGb = 1,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var cache = new Instance("cache", InstanceArgs.builder()        
                .name("memory-cache")
                .memorySizeGb(1)
                .build());
    
        }
    }
    
    resources:
      cache:
        type: gcp:redis:Instance
        properties:
          name: memory-cache
          memorySizeGb: 1
    

    Redis Instance Full

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    // This example assumes this network already exists.
    // The API creates a tenant network per network authorized for a
    // Redis instance and that network is not deleted when the user-created
    // network (authorized_network) is deleted, so this prevents issues
    // with tenant network quota.
    // If this network hasn't been created and you are using this example in your
    // config, add an additional network resource or change
    // this from "data"to "resource"
    const redis-network = gcp.compute.getNetwork({
        name: "redis-test-network",
    });
    const cache = new gcp.redis.Instance("cache", {
        name: "ha-memory-cache",
        tier: "STANDARD_HA",
        memorySizeGb: 1,
        locationId: "us-central1-a",
        alternativeLocationId: "us-central1-f",
        authorizedNetwork: redis_network.then(redis_network => redis_network.id),
        redisVersion: "REDIS_4_0",
        displayName: "Test Instance",
        reservedIpRange: "192.168.0.0/29",
        labels: {
            my_key: "my_val",
            other_key: "other_val",
        },
        maintenancePolicy: {
            weeklyMaintenanceWindows: [{
                day: "TUESDAY",
                startTime: {
                    hours: 0,
                    minutes: 30,
                    seconds: 0,
                    nanos: 0,
                },
            }],
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    # This example assumes this network already exists.
    # The API creates a tenant network per network authorized for a
    # Redis instance and that network is not deleted when the user-created
    # network (authorized_network) is deleted, so this prevents issues
    # with tenant network quota.
    # If this network hasn't been created and you are using this example in your
    # config, add an additional network resource or change
    # this from "data"to "resource"
    redis_network = gcp.compute.get_network(name="redis-test-network")
    cache = gcp.redis.Instance("cache",
        name="ha-memory-cache",
        tier="STANDARD_HA",
        memory_size_gb=1,
        location_id="us-central1-a",
        alternative_location_id="us-central1-f",
        authorized_network=redis_network.id,
        redis_version="REDIS_4_0",
        display_name="Test Instance",
        reserved_ip_range="192.168.0.0/29",
        labels={
            "my_key": "my_val",
            "other_key": "other_val",
        },
        maintenance_policy=gcp.redis.InstanceMaintenancePolicyArgs(
            weekly_maintenance_windows=[gcp.redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs(
                day="TUESDAY",
                start_time=gcp.redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs(
                    hours=0,
                    minutes=30,
                    seconds=0,
                    nanos=0,
                ),
            )],
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// This example assumes this network already exists.
    		// The API creates a tenant network per network authorized for a
    		// Redis instance and that network is not deleted when the user-created
    		// network (authorized_network) is deleted, so this prevents issues
    		// with tenant network quota.
    		// If this network hasn't been created and you are using this example in your
    		// config, add an additional network resource or change
    		// this from "data"to "resource"
    		redis_network, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
    			Name: "redis-test-network",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = redis.NewInstance(ctx, "cache", &redis.InstanceArgs{
    			Name:                  pulumi.String("ha-memory-cache"),
    			Tier:                  pulumi.String("STANDARD_HA"),
    			MemorySizeGb:          pulumi.Int(1),
    			LocationId:            pulumi.String("us-central1-a"),
    			AlternativeLocationId: pulumi.String("us-central1-f"),
    			AuthorizedNetwork:     pulumi.String(redis_network.Id),
    			RedisVersion:          pulumi.String("REDIS_4_0"),
    			DisplayName:           pulumi.String("Test Instance"),
    			ReservedIpRange:       pulumi.String("192.168.0.0/29"),
    			Labels: pulumi.StringMap{
    				"my_key":    pulumi.String("my_val"),
    				"other_key": pulumi.String("other_val"),
    			},
    			MaintenancePolicy: &redis.InstanceMaintenancePolicyArgs{
    				WeeklyMaintenanceWindows: redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArray{
    					&redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs{
    						Day: pulumi.String("TUESDAY"),
    						StartTime: &redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
    							Hours:   pulumi.Int(0),
    							Minutes: pulumi.Int(30),
    							Seconds: pulumi.Int(0),
    							Nanos:   pulumi.Int(0),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        // This example assumes this network already exists.
        // The API creates a tenant network per network authorized for a
        // Redis instance and that network is not deleted when the user-created
        // network (authorized_network) is deleted, so this prevents issues
        // with tenant network quota.
        // If this network hasn't been created and you are using this example in your
        // config, add an additional network resource or change
        // this from "data"to "resource"
        var redis_network = Gcp.Compute.GetNetwork.Invoke(new()
        {
            Name = "redis-test-network",
        });
    
        var cache = new Gcp.Redis.Instance("cache", new()
        {
            Name = "ha-memory-cache",
            Tier = "STANDARD_HA",
            MemorySizeGb = 1,
            LocationId = "us-central1-a",
            AlternativeLocationId = "us-central1-f",
            AuthorizedNetwork = redis_network.Apply(redis_network => redis_network.Apply(getNetworkResult => getNetworkResult.Id)),
            RedisVersion = "REDIS_4_0",
            DisplayName = "Test Instance",
            ReservedIpRange = "192.168.0.0/29",
            Labels = 
            {
                { "my_key", "my_val" },
                { "other_key", "other_val" },
            },
            MaintenancePolicy = new Gcp.Redis.Inputs.InstanceMaintenancePolicyArgs
            {
                WeeklyMaintenanceWindows = new[]
                {
                    new Gcp.Redis.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs
                    {
                        Day = "TUESDAY",
                        StartTime = new Gcp.Redis.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                        {
                            Hours = 0,
                            Minutes = 30,
                            Seconds = 0,
                            Nanos = 0,
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.compute.ComputeFunctions;
    import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import com.pulumi.gcp.redis.inputs.InstanceMaintenancePolicyArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            // This example assumes this network already exists.
            // The API creates a tenant network per network authorized for a
            // Redis instance and that network is not deleted when the user-created
            // network (authorized_network) is deleted, so this prevents issues
            // with tenant network quota.
            // If this network hasn't been created and you are using this example in your
            // config, add an additional network resource or change
            // this from "data"to "resource"
            final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
                .name("redis-test-network")
                .build());
    
            var cache = new Instance("cache", InstanceArgs.builder()        
                .name("ha-memory-cache")
                .tier("STANDARD_HA")
                .memorySizeGb(1)
                .locationId("us-central1-a")
                .alternativeLocationId("us-central1-f")
                .authorizedNetwork(redis_network.id())
                .redisVersion("REDIS_4_0")
                .displayName("Test Instance")
                .reservedIpRange("192.168.0.0/29")
                .labels(Map.ofEntries(
                    Map.entry("my_key", "my_val"),
                    Map.entry("other_key", "other_val")
                ))
                .maintenancePolicy(InstanceMaintenancePolicyArgs.builder()
                    .weeklyMaintenanceWindows(InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                        .day("TUESDAY")
                        .startTime(InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                            .hours(0)
                            .minutes(30)
                            .seconds(0)
                            .nanos(0)
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      cache:
        type: gcp:redis:Instance
        properties:
          name: ha-memory-cache
          tier: STANDARD_HA
          memorySizeGb: 1
          locationId: us-central1-a
          alternativeLocationId: us-central1-f
          authorizedNetwork: ${["redis-network"].id}
          redisVersion: REDIS_4_0
          displayName: Test Instance
          reservedIpRange: 192.168.0.0/29
          labels:
            my_key: my_val
            other_key: other_val
          maintenancePolicy:
            weeklyMaintenanceWindows:
              - day: TUESDAY
                startTime:
                  hours: 0
                  minutes: 30
                  seconds: 0
                  nanos: 0
    variables:
      # This example assumes this network already exists.
      # // The API creates a tenant network per network authorized for a
      # // Redis instance and that network is not deleted when the user-created
      # // network (authorized_network) is deleted, so this prevents issues
      # // with tenant network quota.
      # // If this network hasn't been created and you are using this example in your
      # // config, add an additional network resource or change
      # // this from "data"to "resource"
      redis-network:
        fn::invoke:
          Function: gcp:compute:getNetwork
          Arguments:
            name: redis-test-network
    

    Redis Instance Full With Persistence Config

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const cache_persis = new gcp.redis.Instance("cache-persis", {
        name: "ha-memory-cache-persis",
        tier: "STANDARD_HA",
        memorySizeGb: 1,
        locationId: "us-central1-a",
        alternativeLocationId: "us-central1-f",
        persistenceConfig: {
            persistenceMode: "RDB",
            rdbSnapshotPeriod: "TWELVE_HOURS",
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    cache_persis = gcp.redis.Instance("cache-persis",
        name="ha-memory-cache-persis",
        tier="STANDARD_HA",
        memory_size_gb=1,
        location_id="us-central1-a",
        alternative_location_id="us-central1-f",
        persistence_config=gcp.redis.InstancePersistenceConfigArgs(
            persistence_mode="RDB",
            rdb_snapshot_period="TWELVE_HOURS",
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := redis.NewInstance(ctx, "cache-persis", &redis.InstanceArgs{
    			Name:                  pulumi.String("ha-memory-cache-persis"),
    			Tier:                  pulumi.String("STANDARD_HA"),
    			MemorySizeGb:          pulumi.Int(1),
    			LocationId:            pulumi.String("us-central1-a"),
    			AlternativeLocationId: pulumi.String("us-central1-f"),
    			PersistenceConfig: &redis.InstancePersistenceConfigArgs{
    				PersistenceMode:   pulumi.String("RDB"),
    				RdbSnapshotPeriod: pulumi.String("TWELVE_HOURS"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var cache_persis = new Gcp.Redis.Instance("cache-persis", new()
        {
            Name = "ha-memory-cache-persis",
            Tier = "STANDARD_HA",
            MemorySizeGb = 1,
            LocationId = "us-central1-a",
            AlternativeLocationId = "us-central1-f",
            PersistenceConfig = new Gcp.Redis.Inputs.InstancePersistenceConfigArgs
            {
                PersistenceMode = "RDB",
                RdbSnapshotPeriod = "TWELVE_HOURS",
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import com.pulumi.gcp.redis.inputs.InstancePersistenceConfigArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var cache_persis = new Instance("cache-persis", InstanceArgs.builder()        
                .name("ha-memory-cache-persis")
                .tier("STANDARD_HA")
                .memorySizeGb(1)
                .locationId("us-central1-a")
                .alternativeLocationId("us-central1-f")
                .persistenceConfig(InstancePersistenceConfigArgs.builder()
                    .persistenceMode("RDB")
                    .rdbSnapshotPeriod("TWELVE_HOURS")
                    .build())
                .build());
    
        }
    }
    
    resources:
      cache-persis:
        type: gcp:redis:Instance
        properties:
          name: ha-memory-cache-persis
          tier: STANDARD_HA
          memorySizeGb: 1
          locationId: us-central1-a
          alternativeLocationId: us-central1-f
          persistenceConfig:
            persistenceMode: RDB
            rdbSnapshotPeriod: TWELVE_HOURS
    

    Redis Instance Private Service

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    // This example assumes this network already exists.
    // The API creates a tenant network per network authorized for a
    // Redis instance and that network is not deleted when the user-created
    // network (authorized_network) is deleted, so this prevents issues
    // with tenant network quota.
    // If this network hasn't been created and you are using this example in your
    // config, add an additional network resource or change
    // this from "data"to "resource"
    const redis_network = new gcp.compute.Network("redis-network", {name: "redis-test-network"});
    const serviceRange = new gcp.compute.GlobalAddress("service_range", {
        name: "address",
        purpose: "VPC_PEERING",
        addressType: "INTERNAL",
        prefixLength: 16,
        network: redis_network.id,
    });
    const privateServiceConnection = new gcp.servicenetworking.Connection("private_service_connection", {
        network: redis_network.id,
        service: "servicenetworking.googleapis.com",
        reservedPeeringRanges: [serviceRange.name],
    });
    const cache = new gcp.redis.Instance("cache", {
        name: "private-cache",
        tier: "STANDARD_HA",
        memorySizeGb: 1,
        locationId: "us-central1-a",
        alternativeLocationId: "us-central1-f",
        authorizedNetwork: redis_network.id,
        connectMode: "PRIVATE_SERVICE_ACCESS",
        redisVersion: "REDIS_4_0",
        displayName: "Test Instance",
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    # This example assumes this network already exists.
    # The API creates a tenant network per network authorized for a
    # Redis instance and that network is not deleted when the user-created
    # network (authorized_network) is deleted, so this prevents issues
    # with tenant network quota.
    # If this network hasn't been created and you are using this example in your
    # config, add an additional network resource or change
    # this from "data"to "resource"
    redis_network = gcp.compute.Network("redis-network", name="redis-test-network")
    service_range = gcp.compute.GlobalAddress("service_range",
        name="address",
        purpose="VPC_PEERING",
        address_type="INTERNAL",
        prefix_length=16,
        network=redis_network.id)
    private_service_connection = gcp.servicenetworking.Connection("private_service_connection",
        network=redis_network.id,
        service="servicenetworking.googleapis.com",
        reserved_peering_ranges=[service_range.name])
    cache = gcp.redis.Instance("cache",
        name="private-cache",
        tier="STANDARD_HA",
        memory_size_gb=1,
        location_id="us-central1-a",
        alternative_location_id="us-central1-f",
        authorized_network=redis_network.id,
        connect_mode="PRIVATE_SERVICE_ACCESS",
        redis_version="REDIS_4_0",
        display_name="Test Instance")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/servicenetworking"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// This example assumes this network already exists.
    		// The API creates a tenant network per network authorized for a
    		// Redis instance and that network is not deleted when the user-created
    		// network (authorized_network) is deleted, so this prevents issues
    		// with tenant network quota.
    		// If this network hasn't been created and you are using this example in your
    		// config, add an additional network resource or change
    		// this from "data"to "resource"
    		_, err := compute.NewNetwork(ctx, "redis-network", &compute.NetworkArgs{
    			Name: pulumi.String("redis-test-network"),
    		})
    		if err != nil {
    			return err
    		}
    		serviceRange, err := compute.NewGlobalAddress(ctx, "service_range", &compute.GlobalAddressArgs{
    			Name:         pulumi.String("address"),
    			Purpose:      pulumi.String("VPC_PEERING"),
    			AddressType:  pulumi.String("INTERNAL"),
    			PrefixLength: pulumi.Int(16),
    			Network:      redis_network.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = servicenetworking.NewConnection(ctx, "private_service_connection", &servicenetworking.ConnectionArgs{
    			Network: redis_network.ID(),
    			Service: pulumi.String("servicenetworking.googleapis.com"),
    			ReservedPeeringRanges: pulumi.StringArray{
    				serviceRange.Name,
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = redis.NewInstance(ctx, "cache", &redis.InstanceArgs{
    			Name:                  pulumi.String("private-cache"),
    			Tier:                  pulumi.String("STANDARD_HA"),
    			MemorySizeGb:          pulumi.Int(1),
    			LocationId:            pulumi.String("us-central1-a"),
    			AlternativeLocationId: pulumi.String("us-central1-f"),
    			AuthorizedNetwork:     redis_network.ID(),
    			ConnectMode:           pulumi.String("PRIVATE_SERVICE_ACCESS"),
    			RedisVersion:          pulumi.String("REDIS_4_0"),
    			DisplayName:           pulumi.String("Test Instance"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        // This example assumes this network already exists.
        // The API creates a tenant network per network authorized for a
        // Redis instance and that network is not deleted when the user-created
        // network (authorized_network) is deleted, so this prevents issues
        // with tenant network quota.
        // If this network hasn't been created and you are using this example in your
        // config, add an additional network resource or change
        // this from "data"to "resource"
        var redis_network = new Gcp.Compute.Network("redis-network", new()
        {
            Name = "redis-test-network",
        });
    
        var serviceRange = new Gcp.Compute.GlobalAddress("service_range", new()
        {
            Name = "address",
            Purpose = "VPC_PEERING",
            AddressType = "INTERNAL",
            PrefixLength = 16,
            Network = redis_network.Id,
        });
    
        var privateServiceConnection = new Gcp.ServiceNetworking.Connection("private_service_connection", new()
        {
            Network = redis_network.Id,
            Service = "servicenetworking.googleapis.com",
            ReservedPeeringRanges = new[]
            {
                serviceRange.Name,
            },
        });
    
        var cache = new Gcp.Redis.Instance("cache", new()
        {
            Name = "private-cache",
            Tier = "STANDARD_HA",
            MemorySizeGb = 1,
            LocationId = "us-central1-a",
            AlternativeLocationId = "us-central1-f",
            AuthorizedNetwork = redis_network.Id,
            ConnectMode = "PRIVATE_SERVICE_ACCESS",
            RedisVersion = "REDIS_4_0",
            DisplayName = "Test Instance",
        });
    
    });
    
    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.GlobalAddress;
    import com.pulumi.gcp.compute.GlobalAddressArgs;
    import com.pulumi.gcp.servicenetworking.Connection;
    import com.pulumi.gcp.servicenetworking.ConnectionArgs;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            // This example assumes this network already exists.
            // The API creates a tenant network per network authorized for a
            // Redis instance and that network is not deleted when the user-created
            // network (authorized_network) is deleted, so this prevents issues
            // with tenant network quota.
            // If this network hasn't been created and you are using this example in your
            // config, add an additional network resource or change
            // this from "data"to "resource"
            var redis_network = new Network("redis-network", NetworkArgs.builder()        
                .name("redis-test-network")
                .build());
    
            var serviceRange = new GlobalAddress("serviceRange", GlobalAddressArgs.builder()        
                .name("address")
                .purpose("VPC_PEERING")
                .addressType("INTERNAL")
                .prefixLength(16)
                .network(redis_network.id())
                .build());
    
            var privateServiceConnection = new Connection("privateServiceConnection", ConnectionArgs.builder()        
                .network(redis_network.id())
                .service("servicenetworking.googleapis.com")
                .reservedPeeringRanges(serviceRange.name())
                .build());
    
            var cache = new Instance("cache", InstanceArgs.builder()        
                .name("private-cache")
                .tier("STANDARD_HA")
                .memorySizeGb(1)
                .locationId("us-central1-a")
                .alternativeLocationId("us-central1-f")
                .authorizedNetwork(redis_network.id())
                .connectMode("PRIVATE_SERVICE_ACCESS")
                .redisVersion("REDIS_4_0")
                .displayName("Test Instance")
                .build());
    
        }
    }
    
    resources:
      # This example assumes this network already exists.
      # // The API creates a tenant network per network authorized for a
      # // Redis instance and that network is not deleted when the user-created
      # // network (authorized_network) is deleted, so this prevents issues
      # // with tenant network quota.
      # // If this network hasn't been created and you are using this example in your
      # // config, add an additional network resource or change
      # // this from "data"to "resource"
      redis-network:
        type: gcp:compute:Network
        properties:
          name: redis-test-network
      serviceRange:
        type: gcp:compute:GlobalAddress
        name: service_range
        properties:
          name: address
          purpose: VPC_PEERING
          addressType: INTERNAL
          prefixLength: 16
          network: ${["redis-network"].id}
      privateServiceConnection:
        type: gcp:servicenetworking:Connection
        name: private_service_connection
        properties:
          network: ${["redis-network"].id}
          service: servicenetworking.googleapis.com
          reservedPeeringRanges:
            - ${serviceRange.name}
      cache:
        type: gcp:redis:Instance
        properties:
          name: private-cache
          tier: STANDARD_HA
          memorySizeGb: 1
          locationId: us-central1-a
          alternativeLocationId: us-central1-f
          authorizedNetwork: ${["redis-network"].id}
          connectMode: PRIVATE_SERVICE_ACCESS
          redisVersion: REDIS_4_0
          displayName: Test Instance
    

    Redis Instance Mrr

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    // This example assumes this network already exists.
    // The API creates a tenant network per network authorized for a
    // Redis instance and that network is not deleted when the user-created
    // network (authorized_network) is deleted, so this prevents issues
    // with tenant network quota.
    // If this network hasn't been created and you are using this example in your
    // config, add an additional network resource or change
    // this from "data"to "resource"
    const redis-network = gcp.compute.getNetwork({
        name: "redis-test-network",
    });
    const cache = new gcp.redis.Instance("cache", {
        name: "mrr-memory-cache",
        tier: "STANDARD_HA",
        memorySizeGb: 5,
        locationId: "us-central1-a",
        alternativeLocationId: "us-central1-f",
        authorizedNetwork: redis_network.then(redis_network => redis_network.id),
        redisVersion: "REDIS_6_X",
        displayName: "Terraform Test Instance",
        reservedIpRange: "192.168.0.0/28",
        replicaCount: 5,
        readReplicasMode: "READ_REPLICAS_ENABLED",
        labels: {
            my_key: "my_val",
            other_key: "other_val",
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    # This example assumes this network already exists.
    # The API creates a tenant network per network authorized for a
    # Redis instance and that network is not deleted when the user-created
    # network (authorized_network) is deleted, so this prevents issues
    # with tenant network quota.
    # If this network hasn't been created and you are using this example in your
    # config, add an additional network resource or change
    # this from "data"to "resource"
    redis_network = gcp.compute.get_network(name="redis-test-network")
    cache = gcp.redis.Instance("cache",
        name="mrr-memory-cache",
        tier="STANDARD_HA",
        memory_size_gb=5,
        location_id="us-central1-a",
        alternative_location_id="us-central1-f",
        authorized_network=redis_network.id,
        redis_version="REDIS_6_X",
        display_name="Terraform Test Instance",
        reserved_ip_range="192.168.0.0/28",
        replica_count=5,
        read_replicas_mode="READ_REPLICAS_ENABLED",
        labels={
            "my_key": "my_val",
            "other_key": "other_val",
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// This example assumes this network already exists.
    		// The API creates a tenant network per network authorized for a
    		// Redis instance and that network is not deleted when the user-created
    		// network (authorized_network) is deleted, so this prevents issues
    		// with tenant network quota.
    		// If this network hasn't been created and you are using this example in your
    		// config, add an additional network resource or change
    		// this from "data"to "resource"
    		redis_network, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
    			Name: "redis-test-network",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = redis.NewInstance(ctx, "cache", &redis.InstanceArgs{
    			Name:                  pulumi.String("mrr-memory-cache"),
    			Tier:                  pulumi.String("STANDARD_HA"),
    			MemorySizeGb:          pulumi.Int(5),
    			LocationId:            pulumi.String("us-central1-a"),
    			AlternativeLocationId: pulumi.String("us-central1-f"),
    			AuthorizedNetwork:     pulumi.String(redis_network.Id),
    			RedisVersion:          pulumi.String("REDIS_6_X"),
    			DisplayName:           pulumi.String("Terraform Test Instance"),
    			ReservedIpRange:       pulumi.String("192.168.0.0/28"),
    			ReplicaCount:          pulumi.Int(5),
    			ReadReplicasMode:      pulumi.String("READ_REPLICAS_ENABLED"),
    			Labels: pulumi.StringMap{
    				"my_key":    pulumi.String("my_val"),
    				"other_key": pulumi.String("other_val"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        // This example assumes this network already exists.
        // The API creates a tenant network per network authorized for a
        // Redis instance and that network is not deleted when the user-created
        // network (authorized_network) is deleted, so this prevents issues
        // with tenant network quota.
        // If this network hasn't been created and you are using this example in your
        // config, add an additional network resource or change
        // this from "data"to "resource"
        var redis_network = Gcp.Compute.GetNetwork.Invoke(new()
        {
            Name = "redis-test-network",
        });
    
        var cache = new Gcp.Redis.Instance("cache", new()
        {
            Name = "mrr-memory-cache",
            Tier = "STANDARD_HA",
            MemorySizeGb = 5,
            LocationId = "us-central1-a",
            AlternativeLocationId = "us-central1-f",
            AuthorizedNetwork = redis_network.Apply(redis_network => redis_network.Apply(getNetworkResult => getNetworkResult.Id)),
            RedisVersion = "REDIS_6_X",
            DisplayName = "Terraform Test Instance",
            ReservedIpRange = "192.168.0.0/28",
            ReplicaCount = 5,
            ReadReplicasMode = "READ_REPLICAS_ENABLED",
            Labels = 
            {
                { "my_key", "my_val" },
                { "other_key", "other_val" },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.compute.ComputeFunctions;
    import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            // This example assumes this network already exists.
            // The API creates a tenant network per network authorized for a
            // Redis instance and that network is not deleted when the user-created
            // network (authorized_network) is deleted, so this prevents issues
            // with tenant network quota.
            // If this network hasn't been created and you are using this example in your
            // config, add an additional network resource or change
            // this from "data"to "resource"
            final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
                .name("redis-test-network")
                .build());
    
            var cache = new Instance("cache", InstanceArgs.builder()        
                .name("mrr-memory-cache")
                .tier("STANDARD_HA")
                .memorySizeGb(5)
                .locationId("us-central1-a")
                .alternativeLocationId("us-central1-f")
                .authorizedNetwork(redis_network.id())
                .redisVersion("REDIS_6_X")
                .displayName("Terraform Test Instance")
                .reservedIpRange("192.168.0.0/28")
                .replicaCount(5)
                .readReplicasMode("READ_REPLICAS_ENABLED")
                .labels(Map.ofEntries(
                    Map.entry("my_key", "my_val"),
                    Map.entry("other_key", "other_val")
                ))
                .build());
    
        }
    }
    
    resources:
      cache:
        type: gcp:redis:Instance
        properties:
          name: mrr-memory-cache
          tier: STANDARD_HA
          memorySizeGb: 5
          locationId: us-central1-a
          alternativeLocationId: us-central1-f
          authorizedNetwork: ${["redis-network"].id}
          redisVersion: REDIS_6_X
          displayName: Terraform Test Instance
          reservedIpRange: 192.168.0.0/28
          replicaCount: 5
          readReplicasMode: READ_REPLICAS_ENABLED
          labels:
            my_key: my_val
            other_key: other_val
    variables:
      # This example assumes this network already exists.
      # // The API creates a tenant network per network authorized for a
      # // Redis instance and that network is not deleted when the user-created
      # // network (authorized_network) is deleted, so this prevents issues
      # // with tenant network quota.
      # // If this network hasn't been created and you are using this example in your
      # // config, add an additional network resource or change
      # // this from "data"to "resource"
      redis-network:
        fn::invoke:
          Function: gcp:compute:getNetwork
          Arguments:
            name: redis-test-network
    

    Redis Instance Cmek

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const redisKeyring = new gcp.kms.KeyRing("redis_keyring", {
        name: "redis-keyring",
        location: "us-central1",
    });
    const redisKey = new gcp.kms.CryptoKey("redis_key", {
        name: "redis-key",
        keyRing: redisKeyring.id,
    });
    // This example assumes this network already exists.
    // The API creates a tenant network per network authorized for a
    // Redis instance and that network is not deleted when the user-created
    // network (authorized_network) is deleted, so this prevents issues
    // with tenant network quota.
    // If this network hasn't been created and you are using this example in your
    // config, add an additional network resource or change
    // this from "data"to "resource"
    const redis-network = gcp.compute.getNetwork({
        name: "redis-test-network",
    });
    const cache = new gcp.redis.Instance("cache", {
        name: "cmek-memory-cache",
        tier: "STANDARD_HA",
        memorySizeGb: 1,
        locationId: "us-central1-a",
        alternativeLocationId: "us-central1-f",
        authorizedNetwork: redis_network.then(redis_network => redis_network.id),
        redisVersion: "REDIS_6_X",
        displayName: "Terraform Test Instance",
        reservedIpRange: "192.168.0.0/29",
        labels: {
            my_key: "my_val",
            other_key: "other_val",
        },
        customerManagedKey: redisKey.id,
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    redis_keyring = gcp.kms.KeyRing("redis_keyring",
        name="redis-keyring",
        location="us-central1")
    redis_key = gcp.kms.CryptoKey("redis_key",
        name="redis-key",
        key_ring=redis_keyring.id)
    # This example assumes this network already exists.
    # The API creates a tenant network per network authorized for a
    # Redis instance and that network is not deleted when the user-created
    # network (authorized_network) is deleted, so this prevents issues
    # with tenant network quota.
    # If this network hasn't been created and you are using this example in your
    # config, add an additional network resource or change
    # this from "data"to "resource"
    redis_network = gcp.compute.get_network(name="redis-test-network")
    cache = gcp.redis.Instance("cache",
        name="cmek-memory-cache",
        tier="STANDARD_HA",
        memory_size_gb=1,
        location_id="us-central1-a",
        alternative_location_id="us-central1-f",
        authorized_network=redis_network.id,
        redis_version="REDIS_6_X",
        display_name="Terraform Test Instance",
        reserved_ip_range="192.168.0.0/29",
        labels={
            "my_key": "my_val",
            "other_key": "other_val",
        },
        customer_managed_key=redis_key.id)
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/kms"
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/redis"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		redisKeyring, err := kms.NewKeyRing(ctx, "redis_keyring", &kms.KeyRingArgs{
    			Name:     pulumi.String("redis-keyring"),
    			Location: pulumi.String("us-central1"),
    		})
    		if err != nil {
    			return err
    		}
    		redisKey, err := kms.NewCryptoKey(ctx, "redis_key", &kms.CryptoKeyArgs{
    			Name:    pulumi.String("redis-key"),
    			KeyRing: redisKeyring.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		// This example assumes this network already exists.
    		// The API creates a tenant network per network authorized for a
    		// Redis instance and that network is not deleted when the user-created
    		// network (authorized_network) is deleted, so this prevents issues
    		// with tenant network quota.
    		// If this network hasn't been created and you are using this example in your
    		// config, add an additional network resource or change
    		// this from "data"to "resource"
    		redis_network, err := compute.LookupNetwork(ctx, &compute.LookupNetworkArgs{
    			Name: "redis-test-network",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = redis.NewInstance(ctx, "cache", &redis.InstanceArgs{
    			Name:                  pulumi.String("cmek-memory-cache"),
    			Tier:                  pulumi.String("STANDARD_HA"),
    			MemorySizeGb:          pulumi.Int(1),
    			LocationId:            pulumi.String("us-central1-a"),
    			AlternativeLocationId: pulumi.String("us-central1-f"),
    			AuthorizedNetwork:     pulumi.String(redis_network.Id),
    			RedisVersion:          pulumi.String("REDIS_6_X"),
    			DisplayName:           pulumi.String("Terraform Test Instance"),
    			ReservedIpRange:       pulumi.String("192.168.0.0/29"),
    			Labels: pulumi.StringMap{
    				"my_key":    pulumi.String("my_val"),
    				"other_key": pulumi.String("other_val"),
    			},
    			CustomerManagedKey: redisKey.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var redisKeyring = new Gcp.Kms.KeyRing("redis_keyring", new()
        {
            Name = "redis-keyring",
            Location = "us-central1",
        });
    
        var redisKey = new Gcp.Kms.CryptoKey("redis_key", new()
        {
            Name = "redis-key",
            KeyRing = redisKeyring.Id,
        });
    
        // This example assumes this network already exists.
        // The API creates a tenant network per network authorized for a
        // Redis instance and that network is not deleted when the user-created
        // network (authorized_network) is deleted, so this prevents issues
        // with tenant network quota.
        // If this network hasn't been created and you are using this example in your
        // config, add an additional network resource or change
        // this from "data"to "resource"
        var redis_network = Gcp.Compute.GetNetwork.Invoke(new()
        {
            Name = "redis-test-network",
        });
    
        var cache = new Gcp.Redis.Instance("cache", new()
        {
            Name = "cmek-memory-cache",
            Tier = "STANDARD_HA",
            MemorySizeGb = 1,
            LocationId = "us-central1-a",
            AlternativeLocationId = "us-central1-f",
            AuthorizedNetwork = redis_network.Apply(redis_network => redis_network.Apply(getNetworkResult => getNetworkResult.Id)),
            RedisVersion = "REDIS_6_X",
            DisplayName = "Terraform Test Instance",
            ReservedIpRange = "192.168.0.0/29",
            Labels = 
            {
                { "my_key", "my_val" },
                { "other_key", "other_val" },
            },
            CustomerManagedKey = redisKey.Id,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.kms.KeyRing;
    import com.pulumi.gcp.kms.KeyRingArgs;
    import com.pulumi.gcp.kms.CryptoKey;
    import com.pulumi.gcp.kms.CryptoKeyArgs;
    import com.pulumi.gcp.compute.ComputeFunctions;
    import com.pulumi.gcp.compute.inputs.GetNetworkArgs;
    import com.pulumi.gcp.redis.Instance;
    import com.pulumi.gcp.redis.InstanceArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var redisKeyring = new KeyRing("redisKeyring", KeyRingArgs.builder()        
                .name("redis-keyring")
                .location("us-central1")
                .build());
    
            var redisKey = new CryptoKey("redisKey", CryptoKeyArgs.builder()        
                .name("redis-key")
                .keyRing(redisKeyring.id())
                .build());
    
            // This example assumes this network already exists.
            // The API creates a tenant network per network authorized for a
            // Redis instance and that network is not deleted when the user-created
            // network (authorized_network) is deleted, so this prevents issues
            // with tenant network quota.
            // If this network hasn't been created and you are using this example in your
            // config, add an additional network resource or change
            // this from "data"to "resource"
            final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
                .name("redis-test-network")
                .build());
    
            var cache = new Instance("cache", InstanceArgs.builder()        
                .name("cmek-memory-cache")
                .tier("STANDARD_HA")
                .memorySizeGb(1)
                .locationId("us-central1-a")
                .alternativeLocationId("us-central1-f")
                .authorizedNetwork(redis_network.id())
                .redisVersion("REDIS_6_X")
                .displayName("Terraform Test Instance")
                .reservedIpRange("192.168.0.0/29")
                .labels(Map.ofEntries(
                    Map.entry("my_key", "my_val"),
                    Map.entry("other_key", "other_val")
                ))
                .customerManagedKey(redisKey.id())
                .build());
    
        }
    }
    
    resources:
      cache:
        type: gcp:redis:Instance
        properties:
          name: cmek-memory-cache
          tier: STANDARD_HA
          memorySizeGb: 1
          locationId: us-central1-a
          alternativeLocationId: us-central1-f
          authorizedNetwork: ${["redis-network"].id}
          redisVersion: REDIS_6_X
          displayName: Terraform Test Instance
          reservedIpRange: 192.168.0.0/29
          labels:
            my_key: my_val
            other_key: other_val
          customerManagedKey: ${redisKey.id}
      redisKeyring:
        type: gcp:kms:KeyRing
        name: redis_keyring
        properties:
          name: redis-keyring
          location: us-central1
      redisKey:
        type: gcp:kms:CryptoKey
        name: redis_key
        properties:
          name: redis-key
          keyRing: ${redisKeyring.id}
    variables:
      # This example assumes this network already exists.
      # // The API creates a tenant network per network authorized for a
      # // Redis instance and that network is not deleted when the user-created
      # // network (authorized_network) is deleted, so this prevents issues
      # // with tenant network quota.
      # // If this network hasn't been created and you are using this example in your
      # // config, add an additional network resource or change
      # // this from "data"to "resource"
      redis-network:
        fn::invoke:
          Function: gcp:compute:getNetwork
          Arguments:
            name: redis-test-network
    

    Create Instance Resource

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

    Constructor syntax

    new Instance(name: string, args: InstanceArgs, opts?: CustomResourceOptions);
    @overload
    def Instance(resource_name: str,
                 args: InstanceArgs,
                 opts: Optional[ResourceOptions] = None)
    
    @overload
    def Instance(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 memory_size_gb: Optional[int] = None,
                 name: Optional[str] = None,
                 display_name: Optional[str] = None,
                 persistence_config: Optional[InstancePersistenceConfigArgs] = None,
                 read_replicas_mode: Optional[str] = None,
                 project: Optional[str] = None,
                 labels: Optional[Mapping[str, str]] = None,
                 location_id: Optional[str] = None,
                 maintenance_policy: Optional[InstanceMaintenancePolicyArgs] = None,
                 auth_enabled: Optional[bool] = None,
                 alternative_location_id: Optional[str] = None,
                 connect_mode: Optional[str] = None,
                 authorized_network: Optional[str] = None,
                 customer_managed_key: Optional[str] = None,
                 redis_configs: Optional[Mapping[str, str]] = None,
                 redis_version: Optional[str] = None,
                 region: Optional[str] = None,
                 replica_count: Optional[int] = None,
                 reserved_ip_range: Optional[str] = None,
                 secondary_ip_range: Optional[str] = None,
                 tier: Optional[str] = None,
                 transit_encryption_mode: Optional[str] = None)
    func NewInstance(ctx *Context, name string, args InstanceArgs, opts ...ResourceOption) (*Instance, error)
    public Instance(string name, InstanceArgs args, CustomResourceOptions? opts = null)
    public Instance(String name, InstanceArgs args)
    public Instance(String name, InstanceArgs args, CustomResourceOptions options)
    
    type: gcp:redis:Instance
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args InstanceArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args InstanceArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args InstanceArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args InstanceArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args InstanceArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

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

    var exampleinstanceResourceResourceFromRedisinstance = new Gcp.Redis.Instance("exampleinstanceResourceResourceFromRedisinstance", new()
    {
        MemorySizeGb = 0,
        Name = "string",
        DisplayName = "string",
        PersistenceConfig = new Gcp.Redis.Inputs.InstancePersistenceConfigArgs
        {
            PersistenceMode = "string",
            RdbNextSnapshotTime = "string",
            RdbSnapshotPeriod = "string",
            RdbSnapshotStartTime = "string",
        },
        ReadReplicasMode = "string",
        Project = "string",
        Labels = 
        {
            { "string", "string" },
        },
        LocationId = "string",
        MaintenancePolicy = new Gcp.Redis.Inputs.InstanceMaintenancePolicyArgs
        {
            CreateTime = "string",
            Description = "string",
            UpdateTime = "string",
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Redis.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "string",
                    StartTime = new Gcp.Redis.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 0,
                        Minutes = 0,
                        Nanos = 0,
                        Seconds = 0,
                    },
                    Duration = "string",
                },
            },
        },
        AuthEnabled = false,
        AlternativeLocationId = "string",
        ConnectMode = "string",
        AuthorizedNetwork = "string",
        CustomerManagedKey = "string",
        RedisConfigs = 
        {
            { "string", "string" },
        },
        RedisVersion = "string",
        Region = "string",
        ReplicaCount = 0,
        ReservedIpRange = "string",
        SecondaryIpRange = "string",
        Tier = "string",
        TransitEncryptionMode = "string",
    });
    
    example, err := redis.NewInstance(ctx, "exampleinstanceResourceResourceFromRedisinstance", &redis.InstanceArgs{
    	MemorySizeGb: pulumi.Int(0),
    	Name:         pulumi.String("string"),
    	DisplayName:  pulumi.String("string"),
    	PersistenceConfig: &redis.InstancePersistenceConfigArgs{
    		PersistenceMode:      pulumi.String("string"),
    		RdbNextSnapshotTime:  pulumi.String("string"),
    		RdbSnapshotPeriod:    pulumi.String("string"),
    		RdbSnapshotStartTime: pulumi.String("string"),
    	},
    	ReadReplicasMode: pulumi.String("string"),
    	Project:          pulumi.String("string"),
    	Labels: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	LocationId: pulumi.String("string"),
    	MaintenancePolicy: &redis.InstanceMaintenancePolicyArgs{
    		CreateTime:  pulumi.String("string"),
    		Description: pulumi.String("string"),
    		UpdateTime:  pulumi.String("string"),
    		WeeklyMaintenanceWindows: redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArray{
    			&redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs{
    				Day: pulumi.String("string"),
    				StartTime: &redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
    					Hours:   pulumi.Int(0),
    					Minutes: pulumi.Int(0),
    					Nanos:   pulumi.Int(0),
    					Seconds: pulumi.Int(0),
    				},
    				Duration: pulumi.String("string"),
    			},
    		},
    	},
    	AuthEnabled:           pulumi.Bool(false),
    	AlternativeLocationId: pulumi.String("string"),
    	ConnectMode:           pulumi.String("string"),
    	AuthorizedNetwork:     pulumi.String("string"),
    	CustomerManagedKey:    pulumi.String("string"),
    	RedisConfigs: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	RedisVersion:          pulumi.String("string"),
    	Region:                pulumi.String("string"),
    	ReplicaCount:          pulumi.Int(0),
    	ReservedIpRange:       pulumi.String("string"),
    	SecondaryIpRange:      pulumi.String("string"),
    	Tier:                  pulumi.String("string"),
    	TransitEncryptionMode: pulumi.String("string"),
    })
    
    var exampleinstanceResourceResourceFromRedisinstance = new Instance("exampleinstanceResourceResourceFromRedisinstance", InstanceArgs.builder()        
        .memorySizeGb(0)
        .name("string")
        .displayName("string")
        .persistenceConfig(InstancePersistenceConfigArgs.builder()
            .persistenceMode("string")
            .rdbNextSnapshotTime("string")
            .rdbSnapshotPeriod("string")
            .rdbSnapshotStartTime("string")
            .build())
        .readReplicasMode("string")
        .project("string")
        .labels(Map.of("string", "string"))
        .locationId("string")
        .maintenancePolicy(InstanceMaintenancePolicyArgs.builder()
            .createTime("string")
            .description("string")
            .updateTime("string")
            .weeklyMaintenanceWindows(InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                .day("string")
                .startTime(InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                    .hours(0)
                    .minutes(0)
                    .nanos(0)
                    .seconds(0)
                    .build())
                .duration("string")
                .build())
            .build())
        .authEnabled(false)
        .alternativeLocationId("string")
        .connectMode("string")
        .authorizedNetwork("string")
        .customerManagedKey("string")
        .redisConfigs(Map.of("string", "string"))
        .redisVersion("string")
        .region("string")
        .replicaCount(0)
        .reservedIpRange("string")
        .secondaryIpRange("string")
        .tier("string")
        .transitEncryptionMode("string")
        .build());
    
    exampleinstance_resource_resource_from_redisinstance = gcp.redis.Instance("exampleinstanceResourceResourceFromRedisinstance",
        memory_size_gb=0,
        name="string",
        display_name="string",
        persistence_config=gcp.redis.InstancePersistenceConfigArgs(
            persistence_mode="string",
            rdb_next_snapshot_time="string",
            rdb_snapshot_period="string",
            rdb_snapshot_start_time="string",
        ),
        read_replicas_mode="string",
        project="string",
        labels={
            "string": "string",
        },
        location_id="string",
        maintenance_policy=gcp.redis.InstanceMaintenancePolicyArgs(
            create_time="string",
            description="string",
            update_time="string",
            weekly_maintenance_windows=[gcp.redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs(
                day="string",
                start_time=gcp.redis.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs(
                    hours=0,
                    minutes=0,
                    nanos=0,
                    seconds=0,
                ),
                duration="string",
            )],
        ),
        auth_enabled=False,
        alternative_location_id="string",
        connect_mode="string",
        authorized_network="string",
        customer_managed_key="string",
        redis_configs={
            "string": "string",
        },
        redis_version="string",
        region="string",
        replica_count=0,
        reserved_ip_range="string",
        secondary_ip_range="string",
        tier="string",
        transit_encryption_mode="string")
    
    const exampleinstanceResourceResourceFromRedisinstance = new gcp.redis.Instance("exampleinstanceResourceResourceFromRedisinstance", {
        memorySizeGb: 0,
        name: "string",
        displayName: "string",
        persistenceConfig: {
            persistenceMode: "string",
            rdbNextSnapshotTime: "string",
            rdbSnapshotPeriod: "string",
            rdbSnapshotStartTime: "string",
        },
        readReplicasMode: "string",
        project: "string",
        labels: {
            string: "string",
        },
        locationId: "string",
        maintenancePolicy: {
            createTime: "string",
            description: "string",
            updateTime: "string",
            weeklyMaintenanceWindows: [{
                day: "string",
                startTime: {
                    hours: 0,
                    minutes: 0,
                    nanos: 0,
                    seconds: 0,
                },
                duration: "string",
            }],
        },
        authEnabled: false,
        alternativeLocationId: "string",
        connectMode: "string",
        authorizedNetwork: "string",
        customerManagedKey: "string",
        redisConfigs: {
            string: "string",
        },
        redisVersion: "string",
        region: "string",
        replicaCount: 0,
        reservedIpRange: "string",
        secondaryIpRange: "string",
        tier: "string",
        transitEncryptionMode: "string",
    });
    
    type: gcp:redis:Instance
    properties:
        alternativeLocationId: string
        authEnabled: false
        authorizedNetwork: string
        connectMode: string
        customerManagedKey: string
        displayName: string
        labels:
            string: string
        locationId: string
        maintenancePolicy:
            createTime: string
            description: string
            updateTime: string
            weeklyMaintenanceWindows:
                - day: string
                  duration: string
                  startTime:
                    hours: 0
                    minutes: 0
                    nanos: 0
                    seconds: 0
        memorySizeGb: 0
        name: string
        persistenceConfig:
            persistenceMode: string
            rdbNextSnapshotTime: string
            rdbSnapshotPeriod: string
            rdbSnapshotStartTime: string
        project: string
        readReplicasMode: string
        redisConfigs:
            string: string
        redisVersion: string
        region: string
        replicaCount: 0
        reservedIpRange: string
        secondaryIpRange: string
        tier: string
        transitEncryptionMode: string
    

    Instance Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The Instance resource accepts the following input properties:

    MemorySizeGb int
    Redis memory size in GiB.


    AlternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    AuthEnabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    AuthorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    ConnectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    CustomerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    DisplayName string
    An arbitrary and optional user-provided name for the instance.
    Labels Dictionary<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 effective_labels for all of the labels present on the resource.
    LocationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    MaintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    Name string
    The ID of the instance or a fully qualified identifier for the instance.
    PersistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    ReadReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    RedisConfigs Dictionary<string, string>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    RedisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    Region string
    The name of the Redis region of the instance.
    ReplicaCount int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    ReservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    SecondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    Tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    TransitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    MemorySizeGb int
    Redis memory size in GiB.


    AlternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    AuthEnabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    AuthorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    ConnectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    CustomerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    DisplayName string
    An arbitrary and optional user-provided name for the instance.
    Labels 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 effective_labels for all of the labels present on the resource.
    LocationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    MaintenancePolicy InstanceMaintenancePolicyArgs
    Maintenance policy for an instance. Structure is documented below.
    Name string
    The ID of the instance or a fully qualified identifier for the instance.
    PersistenceConfig InstancePersistenceConfigArgs
    Persistence configuration for an instance. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    ReadReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    RedisConfigs map[string]string
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    RedisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    Region string
    The name of the Redis region of the instance.
    ReplicaCount int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    ReservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    SecondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    Tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    TransitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    memorySizeGb Integer
    Redis memory size in GiB.


    alternativeLocationId String
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled Boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authorizedNetwork String
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode String
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    customerManagedKey String
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName String
    An arbitrary and optional user-provided name for the instance.
    labels 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 effective_labels for all of the labels present on the resource.
    locationId String
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    name String
    The ID of the instance or a fully qualified identifier for the instance.
    persistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    readReplicasMode String
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs Map<String,String>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion String
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region String
    The name of the Redis region of the instance.
    replicaCount Integer
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange String
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange String
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    tier String
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode String
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    memorySizeGb number
    Redis memory size in GiB.


    alternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    customerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName string
    An arbitrary and optional user-provided name for the instance.
    labels {[key: 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 effective_labels for all of the labels present on the resource.
    locationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    name string
    The ID of the instance or a fully qualified identifier for the instance.
    persistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    readReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs {[key: string]: string}
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region string
    The name of the Redis region of the instance.
    replicaCount number
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    memory_size_gb int
    Redis memory size in GiB.


    alternative_location_id str
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    auth_enabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authorized_network str
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connect_mode str
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    customer_managed_key str
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    display_name str
    An arbitrary and optional user-provided name for the instance.
    labels Mapping[str, str]
    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 effective_labels for all of the labels present on the resource.
    location_id str
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenance_policy InstanceMaintenancePolicyArgs
    Maintenance policy for an instance. Structure is documented below.
    name str
    The ID of the instance or a fully qualified identifier for the instance.
    persistence_config InstancePersistenceConfigArgs
    Persistence configuration for an instance. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    read_replicas_mode str
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redis_configs Mapping[str, str]
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redis_version str
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region str
    The name of the Redis region of the instance.
    replica_count int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reserved_ip_range str
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondary_ip_range str
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    tier str
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transit_encryption_mode str
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    memorySizeGb Number
    Redis memory size in GiB.


    alternativeLocationId String
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled Boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authorizedNetwork String
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode String
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    customerManagedKey String
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName String
    An arbitrary and optional user-provided name for the instance.
    labels Map<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 effective_labels for all of the labels present on the resource.
    locationId String
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy Property Map
    Maintenance policy for an instance. Structure is documented below.
    name String
    The ID of the instance or a fully qualified identifier for the instance.
    persistenceConfig Property Map
    Persistence configuration for an instance. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    readReplicasMode String
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs Map<String>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion String
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region String
    The name of the Redis region of the instance.
    replicaCount Number
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange String
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange String
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    tier String
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode String
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Instance resource produces the following output properties:

    AuthString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    CreateTime string
    (Output) The time when the certificate was created.
    CurrentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    Id string
    The provider-assigned unique ID for this managed resource.
    MaintenanceSchedules List<InstanceMaintenanceSchedule>
    Upcoming maintenance schedule. Structure is documented below.
    Nodes List<InstanceNode>
    Output only. Info per node. Structure is documented below.
    PersistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    Port int
    The port number of the exposed Redis endpoint.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    ReadEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    ReadEndpointPort int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    ServerCaCerts List<InstanceServerCaCert>
    List of server CA certificates for the instance. Structure is documented below.
    AuthString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    CreateTime string
    (Output) The time when the certificate was created.
    CurrentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    EffectiveLabels 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.
    Host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    Id string
    The provider-assigned unique ID for this managed resource.
    MaintenanceSchedules []InstanceMaintenanceSchedule
    Upcoming maintenance schedule. Structure is documented below.
    Nodes []InstanceNode
    Output only. Info per node. Structure is documented below.
    PersistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    Port int
    The port number of the exposed Redis endpoint.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    ReadEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    ReadEndpointPort int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    ServerCaCerts []InstanceServerCaCert
    List of server CA certificates for the instance. Structure is documented below.
    authString String
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    createTime String
    (Output) The time when the certificate was created.
    currentLocationId String
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    effectiveLabels 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.
    host String
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    id String
    The provider-assigned unique ID for this managed resource.
    maintenanceSchedules List<InstanceMaintenanceSchedule>
    Upcoming maintenance schedule. Structure is documented below.
    nodes List<InstanceNode>
    Output only. Info per node. Structure is documented below.
    persistenceIamIdentity String
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port Integer
    The port number of the exposed Redis endpoint.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint String
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort Integer
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    serverCaCerts List<InstanceServerCaCert>
    List of server CA certificates for the instance. Structure is documented below.
    authString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    createTime string
    (Output) The time when the certificate was created.
    currentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    id string
    The provider-assigned unique ID for this managed resource.
    maintenanceSchedules InstanceMaintenanceSchedule[]
    Upcoming maintenance schedule. Structure is documented below.
    nodes InstanceNode[]
    Output only. Info per node. Structure is documented below.
    persistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port number
    The port number of the exposed Redis endpoint.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort number
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    serverCaCerts InstanceServerCaCert[]
    List of server CA certificates for the instance. Structure is documented below.
    auth_string str
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    create_time str
    (Output) The time when the certificate was created.
    current_location_id str
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host str
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    id str
    The provider-assigned unique ID for this managed resource.
    maintenance_schedules Sequence[InstanceMaintenanceSchedule]
    Upcoming maintenance schedule. Structure is documented below.
    nodes Sequence[InstanceNode]
    Output only. Info per node. Structure is documented below.
    persistence_iam_identity str
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port int
    The port number of the exposed Redis endpoint.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    read_endpoint str
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    read_endpoint_port int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    server_ca_certs Sequence[InstanceServerCaCert]
    List of server CA certificates for the instance. Structure is documented below.
    authString String
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    createTime String
    (Output) The time when the certificate was created.
    currentLocationId String
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host String
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    id String
    The provider-assigned unique ID for this managed resource.
    maintenanceSchedules List<Property Map>
    Upcoming maintenance schedule. Structure is documented below.
    nodes List<Property Map>
    Output only. Info per node. Structure is documented below.
    persistenceIamIdentity String
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port Number
    The port number of the exposed Redis endpoint.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint String
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort Number
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    serverCaCerts List<Property Map>
    List of server CA certificates for the instance. Structure is documented below.

    Look up Existing Instance Resource

    Get an existing Instance resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: InstanceState, opts?: CustomResourceOptions): Instance
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            alternative_location_id: Optional[str] = None,
            auth_enabled: Optional[bool] = None,
            auth_string: Optional[str] = None,
            authorized_network: Optional[str] = None,
            connect_mode: Optional[str] = None,
            create_time: Optional[str] = None,
            current_location_id: Optional[str] = None,
            customer_managed_key: Optional[str] = None,
            display_name: Optional[str] = None,
            effective_labels: Optional[Mapping[str, str]] = None,
            host: Optional[str] = None,
            labels: Optional[Mapping[str, str]] = None,
            location_id: Optional[str] = None,
            maintenance_policy: Optional[InstanceMaintenancePolicyArgs] = None,
            maintenance_schedules: Optional[Sequence[InstanceMaintenanceScheduleArgs]] = None,
            memory_size_gb: Optional[int] = None,
            name: Optional[str] = None,
            nodes: Optional[Sequence[InstanceNodeArgs]] = None,
            persistence_config: Optional[InstancePersistenceConfigArgs] = None,
            persistence_iam_identity: Optional[str] = None,
            port: Optional[int] = None,
            project: Optional[str] = None,
            pulumi_labels: Optional[Mapping[str, str]] = None,
            read_endpoint: Optional[str] = None,
            read_endpoint_port: Optional[int] = None,
            read_replicas_mode: Optional[str] = None,
            redis_configs: Optional[Mapping[str, str]] = None,
            redis_version: Optional[str] = None,
            region: Optional[str] = None,
            replica_count: Optional[int] = None,
            reserved_ip_range: Optional[str] = None,
            secondary_ip_range: Optional[str] = None,
            server_ca_certs: Optional[Sequence[InstanceServerCaCertArgs]] = None,
            tier: Optional[str] = None,
            transit_encryption_mode: Optional[str] = None) -> Instance
    func GetInstance(ctx *Context, name string, id IDInput, state *InstanceState, opts ...ResourceOption) (*Instance, error)
    public static Instance Get(string name, Input<string> id, InstanceState? state, CustomResourceOptions? opts = null)
    public static Instance get(String name, Output<String> id, InstanceState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AlternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    AuthEnabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    AuthString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    AuthorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    ConnectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    CreateTime string
    (Output) The time when the certificate was created.
    CurrentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    CustomerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    DisplayName string
    An arbitrary and optional user-provided name for the instance.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    Labels Dictionary<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 effective_labels for all of the labels present on the resource.
    LocationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    MaintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    MaintenanceSchedules List<InstanceMaintenanceSchedule>
    Upcoming maintenance schedule. Structure is documented below.
    MemorySizeGb int
    Redis memory size in GiB.


    Name string
    The ID of the instance or a fully qualified identifier for the instance.
    Nodes List<InstanceNode>
    Output only. Info per node. Structure is documented below.
    PersistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    PersistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    Port int
    The port number of the exposed Redis endpoint.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    ReadEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    ReadEndpointPort int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    ReadReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    RedisConfigs Dictionary<string, string>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    RedisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    Region string
    The name of the Redis region of the instance.
    ReplicaCount int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    ReservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    SecondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    ServerCaCerts List<InstanceServerCaCert>
    List of server CA certificates for the instance. Structure is documented below.
    Tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    TransitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    AlternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    AuthEnabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    AuthString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    AuthorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    ConnectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    CreateTime string
    (Output) The time when the certificate was created.
    CurrentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    CustomerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    DisplayName string
    An arbitrary and optional user-provided name for the instance.
    EffectiveLabels 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.
    Host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    Labels 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 effective_labels for all of the labels present on the resource.
    LocationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    MaintenancePolicy InstanceMaintenancePolicyArgs
    Maintenance policy for an instance. Structure is documented below.
    MaintenanceSchedules []InstanceMaintenanceScheduleArgs
    Upcoming maintenance schedule. Structure is documented below.
    MemorySizeGb int
    Redis memory size in GiB.


    Name string
    The ID of the instance or a fully qualified identifier for the instance.
    Nodes []InstanceNodeArgs
    Output only. Info per node. Structure is documented below.
    PersistenceConfig InstancePersistenceConfigArgs
    Persistence configuration for an instance. Structure is documented below.
    PersistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    Port int
    The port number of the exposed Redis endpoint.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    ReadEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    ReadEndpointPort int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    ReadReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    RedisConfigs map[string]string
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    RedisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    Region string
    The name of the Redis region of the instance.
    ReplicaCount int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    ReservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    SecondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    ServerCaCerts []InstanceServerCaCertArgs
    List of server CA certificates for the instance. Structure is documented below.
    Tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    TransitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    alternativeLocationId String
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled Boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authString String
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    authorizedNetwork String
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode String
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    createTime String
    (Output) The time when the certificate was created.
    currentLocationId String
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    customerManagedKey String
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName String
    An arbitrary and optional user-provided name for the instance.
    effectiveLabels 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.
    host String
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    labels 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 effective_labels for all of the labels present on the resource.
    locationId String
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    maintenanceSchedules List<InstanceMaintenanceSchedule>
    Upcoming maintenance schedule. Structure is documented below.
    memorySizeGb Integer
    Redis memory size in GiB.


    name String
    The ID of the instance or a fully qualified identifier for the instance.
    nodes List<InstanceNode>
    Output only. Info per node. Structure is documented below.
    persistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    persistenceIamIdentity String
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port Integer
    The port number of the exposed Redis endpoint.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint String
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort Integer
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    readReplicasMode String
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs Map<String,String>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion String
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region String
    The name of the Redis region of the instance.
    replicaCount Integer
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange String
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange String
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    serverCaCerts List<InstanceServerCaCert>
    List of server CA certificates for the instance. Structure is documented below.
    tier String
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode String
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    alternativeLocationId string
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authString string
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    authorizedNetwork string
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode string
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    createTime string
    (Output) The time when the certificate was created.
    currentLocationId string
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    customerManagedKey string
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName string
    An arbitrary and optional user-provided name for the instance.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host string
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    labels {[key: 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 effective_labels for all of the labels present on the resource.
    locationId string
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy InstanceMaintenancePolicy
    Maintenance policy for an instance. Structure is documented below.
    maintenanceSchedules InstanceMaintenanceSchedule[]
    Upcoming maintenance schedule. Structure is documented below.
    memorySizeGb number
    Redis memory size in GiB.


    name string
    The ID of the instance or a fully qualified identifier for the instance.
    nodes InstanceNode[]
    Output only. Info per node. Structure is documented below.
    persistenceConfig InstancePersistenceConfig
    Persistence configuration for an instance. Structure is documented below.
    persistenceIamIdentity string
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port number
    The port number of the exposed Redis endpoint.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint string
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort number
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    readReplicasMode string
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs {[key: string]: string}
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion string
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region string
    The name of the Redis region of the instance.
    replicaCount number
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange string
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange string
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    serverCaCerts InstanceServerCaCert[]
    List of server CA certificates for the instance. Structure is documented below.
    tier string
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode string
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    alternative_location_id str
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    auth_enabled bool
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    auth_string str
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    authorized_network str
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connect_mode str
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    create_time str
    (Output) The time when the certificate was created.
    current_location_id str
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    customer_managed_key str
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    display_name str
    An arbitrary and optional user-provided name for the instance.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host str
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    labels Mapping[str, str]
    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 effective_labels for all of the labels present on the resource.
    location_id str
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenance_policy InstanceMaintenancePolicyArgs
    Maintenance policy for an instance. Structure is documented below.
    maintenance_schedules Sequence[InstanceMaintenanceScheduleArgs]
    Upcoming maintenance schedule. Structure is documented below.
    memory_size_gb int
    Redis memory size in GiB.


    name str
    The ID of the instance or a fully qualified identifier for the instance.
    nodes Sequence[InstanceNodeArgs]
    Output only. Info per node. Structure is documented below.
    persistence_config InstancePersistenceConfigArgs
    Persistence configuration for an instance. Structure is documented below.
    persistence_iam_identity str
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port int
    The port number of the exposed Redis endpoint.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    read_endpoint str
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    read_endpoint_port int
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    read_replicas_mode str
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redis_configs Mapping[str, str]
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redis_version str
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region str
    The name of the Redis region of the instance.
    replica_count int
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reserved_ip_range str
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondary_ip_range str
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    server_ca_certs Sequence[InstanceServerCaCertArgs]
    List of server CA certificates for the instance. Structure is documented below.
    tier str
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transit_encryption_mode str
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.
    alternativeLocationId String
    Only applicable to STANDARD_HA tier which protects the instance against zonal failures by provisioning it across two zones. If provided, it must be a different zone from the one provided in [locationId].
    authEnabled Boolean
    Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If set to "true" AUTH is enabled on the instance. Default value is "false" meaning AUTH is disabled.
    authString String
    AUTH String set on the instance. This field will only be populated if auth_enabled is true.
    authorizedNetwork String
    The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.
    connectMode String
    The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.
    createTime String
    (Output) The time when the certificate was created.
    currentLocationId String
    The current zone where the Redis endpoint is placed. For Basic Tier instances, this will always be the same as the [locationId] provided by the user at creation time. For Standard Tier instances, this can be either [locationId] or [alternativeLocationId] and can change after a failover event.
    customerManagedKey String
    Optional. The KMS key reference that you want to use to encrypt the data at rest for this Redis instance. If this is provided, CMEK is enabled.
    displayName String
    An arbitrary and optional user-provided name for the instance.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    host String
    Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.
    labels Map<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 effective_labels for all of the labels present on the resource.
    locationId String
    The zone where the instance will be provisioned. If not provided, the service will choose a zone for the instance. For STANDARD_HA tier, instances will be created across two zones for protection against zonal failures. If [alternativeLocationId] is also provided, it must be different from [locationId].
    maintenancePolicy Property Map
    Maintenance policy for an instance. Structure is documented below.
    maintenanceSchedules List<Property Map>
    Upcoming maintenance schedule. Structure is documented below.
    memorySizeGb Number
    Redis memory size in GiB.


    name String
    The ID of the instance or a fully qualified identifier for the instance.
    nodes List<Property Map>
    Output only. Info per node. Structure is documented below.
    persistenceConfig Property Map
    Persistence configuration for an instance. Structure is documented below.
    persistenceIamIdentity String
    Output only. Cloud IAM identity used by import / export operations to transfer data to/from Cloud Storage. Format is "serviceAccount:". The value may change over time for a given instance so should be checked before each import/export operation.
    port Number
    The port number of the exposed Redis endpoint.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    readEndpoint String
    Output only. Hostname or IP address of the exposed readonly Redis endpoint. Standard tier only. Targets all healthy replica nodes in instance. Replication is asynchronous and replica nodes will exhibit some lag behind the primary. Write requests must target 'host'.
    readEndpointPort Number
    Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.
    readReplicasMode String
    Optional. Read replica mode. Can only be specified when trying to create the instance. If not set, Memorystore Redis backend will default to READ_REPLICAS_DISABLED.

    • READ_REPLICAS_DISABLED: If disabled, read endpoint will not be provided and the instance cannot scale up or down the number of replicas.
    • READ_REPLICAS_ENABLED: If enabled, read endpoint will be provided and the instance can scale up and down the number of replicas. Possible values are: READ_REPLICAS_DISABLED, READ_REPLICAS_ENABLED.
    redisConfigs Map<String>
    Redis configuration parameters, according to http://redis.io/topics/config. Please check Memorystore documentation for the list of supported parameters: https://cloud.google.com/memorystore/docs/redis/reference/rest/v1/projects.locations.instances#Instance.FIELDS.redis_configs
    redisVersion String
    The version of Redis software. If not provided, latest supported version will be used. Please check the API documentation linked at the top for the latest valid values.
    region String
    The name of the Redis region of the instance.
    replicaCount Number
    Optional. The number of replica nodes. The valid range for the Standard Tier with read replicas enabled is [1-5] and defaults to 2. If read replicas are not enabled for a Standard Tier instance, the only valid value is 1 and the default is 1. The valid value for basic tier is 0 and the default is also 0.
    reservedIpRange String
    The CIDR range of internal addresses that are reserved for this instance. If not provided, the service will choose an unused /29 block, for example, 10.0.0.0/29 or 192.168.0.0/29. Ranges must be unique and non-overlapping with existing subnets in an authorized network.
    secondaryIpRange String
    Optional. Additional IP range for node placement. Required when enabling read replicas on an existing instance. For DIRECT_PEERING mode value must be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode value must be the name of an allocated address range associated with the private service access connection, or "auto".
    serverCaCerts List<Property Map>
    List of server CA certificates for the instance. Structure is documented below.
    tier String
    The service tier of the instance. Must be one of these values:

    • BASIC: standalone instance
    • STANDARD_HA: highly available primary/replica instances Default value is BASIC. Possible values are: BASIC, STANDARD_HA.
    transitEncryptionMode String
    The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

    • SERVER_AUTHENTICATION: Client to Server traffic encryption enabled with server authentication Default value is DISABLED. Possible values are: SERVER_AUTHENTICATION, DISABLED.

    Supporting Types

    InstanceMaintenancePolicy, InstanceMaintenancePolicyArgs

    CreateTime string
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    Description string
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    UpdateTime string
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    WeeklyMaintenanceWindows List<InstanceMaintenancePolicyWeeklyMaintenanceWindow>
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.
    CreateTime string
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    Description string
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    UpdateTime string
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    WeeklyMaintenanceWindows []InstanceMaintenancePolicyWeeklyMaintenanceWindow
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.
    createTime String
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    description String
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    updateTime String
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    weeklyMaintenanceWindows List<InstanceMaintenancePolicyWeeklyMaintenanceWindow>
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.
    createTime string
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    description string
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    updateTime string
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    weeklyMaintenanceWindows InstanceMaintenancePolicyWeeklyMaintenanceWindow[]
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.
    create_time str
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    description str
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    update_time str
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    weekly_maintenance_windows Sequence[InstanceMaintenancePolicyWeeklyMaintenanceWindow]
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.
    createTime String
    (Output) Output only. The time when the policy was created. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    description String
    Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.
    updateTime String
    (Output) Output only. The time when the policy was last updated. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    weeklyMaintenanceWindows List<Property Map>
    Optional. Maintenance window that is applied to resources covered by this policy. Minimum 1. For the current version, the maximum number of weekly_window is expected to be one. Structure is documented below.

    InstanceMaintenancePolicyWeeklyMaintenanceWindow, InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs

    Day string
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    StartTime InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime
    Required. Start time of the window in UTC time. Structure is documented below.
    Duration string
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
    Day string
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    StartTime InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime
    Required. Start time of the window in UTC time. Structure is documented below.
    Duration string
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
    day String
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    startTime InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime
    Required. Start time of the window in UTC time. Structure is documented below.
    duration String
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
    day string
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    startTime InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime
    Required. Start time of the window in UTC time. Structure is documented below.
    duration string
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
    day str
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    start_time InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime
    Required. Start time of the window in UTC time. Structure is documented below.
    duration str
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
    day String
    Required. The day of week that maintenance updates occur.

    • DAY_OF_WEEK_UNSPECIFIED: The day of the week is unspecified.
    • MONDAY: Monday
    • TUESDAY: Tuesday
    • WEDNESDAY: Wednesday
    • THURSDAY: Thursday
    • FRIDAY: Friday
    • SATURDAY: Saturday
    • SUNDAY: Sunday Possible values are: DAY_OF_WEEK_UNSPECIFIED, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY.
    startTime Property Map
    Required. Start time of the window in UTC time. Structure is documented below.
    duration String
    (Output) Output only. Duration of the maintenance window. The current window is fixed at 1 hour. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

    InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime, InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs

    Hours int
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    Minutes int
    Minutes of hour of day. Must be from 0 to 59.
    Nanos int
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    Seconds int
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    Hours int
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    Minutes int
    Minutes of hour of day. Must be from 0 to 59.
    Nanos int
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    Seconds int
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    hours Integer
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    minutes Integer
    Minutes of hour of day. Must be from 0 to 59.
    nanos Integer
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    seconds Integer
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    hours number
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    minutes number
    Minutes of hour of day. Must be from 0 to 59.
    nanos number
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    seconds number
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    hours int
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    minutes int
    Minutes of hour of day. Must be from 0 to 59.
    nanos int
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    seconds int
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.
    hours Number
    Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
    minutes Number
    Minutes of hour of day. Must be from 0 to 59.
    nanos Number
    Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
    seconds Number
    Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.

    InstanceMaintenanceSchedule, InstanceMaintenanceScheduleArgs

    EndTime string
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    ScheduleDeadlineTime string
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    StartTime string
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    EndTime string
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    ScheduleDeadlineTime string
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    StartTime string
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    endTime String
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    scheduleDeadlineTime String
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    startTime String
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    endTime string
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    scheduleDeadlineTime string
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    startTime string
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    end_time str
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    schedule_deadline_time str
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    start_time str
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    endTime String
    (Output) Output only. The end time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    scheduleDeadlineTime String
    (Output) Output only. The deadline that the maintenance schedule start time can not go beyond, including reschedule. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
    startTime String
    (Output) Output only. The start time of any upcoming scheduled maintenance for this instance. A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.

    InstanceNode, InstanceNodeArgs

    Id string
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    Zone string
    (Output) Location of the node.
    Id string
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    Zone string
    (Output) Location of the node.
    id String
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    zone String
    (Output) Location of the node.
    id string
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    zone string
    (Output) Location of the node.
    id str
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    zone str
    (Output) Location of the node.
    id String
    (Output) Node identifying string. e.g. 'node-0', 'node-1'
    zone String
    (Output) Location of the node.

    InstancePersistenceConfig, InstancePersistenceConfigArgs

    PersistenceMode string
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    RdbNextSnapshotTime string
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    RdbSnapshotPeriod string
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    RdbSnapshotStartTime string
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".
    PersistenceMode string
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    RdbNextSnapshotTime string
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    RdbSnapshotPeriod string
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    RdbSnapshotStartTime string
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".
    persistenceMode String
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    rdbNextSnapshotTime String
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    rdbSnapshotPeriod String
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    rdbSnapshotStartTime String
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".
    persistenceMode string
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    rdbNextSnapshotTime string
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    rdbSnapshotPeriod string
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    rdbSnapshotStartTime string
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".
    persistence_mode str
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    rdb_next_snapshot_time str
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    rdb_snapshot_period str
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    rdb_snapshot_start_time str
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".
    persistenceMode String
    Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.

    • DISABLED: Persistence is disabled for the instance, and any existing snapshots are deleted.
    • RDB: RDB based Persistence is enabled. Possible values are: DISABLED, RDB.
    rdbNextSnapshotTime String
    (Output) Output only. The next time that a snapshot attempt is scheduled to occur. 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".
    rdbSnapshotPeriod String
    Optional. Available snapshot periods for scheduling.

    • ONE_HOUR: Snapshot every 1 hour.
    • SIX_HOURS: Snapshot every 6 hours.
    • TWELVE_HOURS: Snapshot every 12 hours.
    • TWENTY_FOUR_HOURS: Snapshot every 24 hours. Possible values are: ONE_HOUR, SIX_HOURS, TWELVE_HOURS, TWENTY_FOUR_HOURS.
    rdbSnapshotStartTime String
    Optional. Date and time that the first snapshot was/will be attempted, and to which future snapshots will be aligned. If not provided, the current time will be used. 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".

    InstanceServerCaCert, InstanceServerCaCertArgs

    Cert string
    (Output) The certificate data in PEM format.
    CreateTime string
    (Output) The time when the certificate was created.
    ExpireTime string
    (Output) The time when the certificate expires.
    SerialNumber string
    (Output) Serial number, as extracted from the certificate.
    Sha1Fingerprint string
    (Output) Sha1 Fingerprint of the certificate.
    Cert string
    (Output) The certificate data in PEM format.
    CreateTime string
    (Output) The time when the certificate was created.
    ExpireTime string
    (Output) The time when the certificate expires.
    SerialNumber string
    (Output) Serial number, as extracted from the certificate.
    Sha1Fingerprint string
    (Output) Sha1 Fingerprint of the certificate.
    cert String
    (Output) The certificate data in PEM format.
    createTime String
    (Output) The time when the certificate was created.
    expireTime String
    (Output) The time when the certificate expires.
    serialNumber String
    (Output) Serial number, as extracted from the certificate.
    sha1Fingerprint String
    (Output) Sha1 Fingerprint of the certificate.
    cert string
    (Output) The certificate data in PEM format.
    createTime string
    (Output) The time when the certificate was created.
    expireTime string
    (Output) The time when the certificate expires.
    serialNumber string
    (Output) Serial number, as extracted from the certificate.
    sha1Fingerprint string
    (Output) Sha1 Fingerprint of the certificate.
    cert str
    (Output) The certificate data in PEM format.
    create_time str
    (Output) The time when the certificate was created.
    expire_time str
    (Output) The time when the certificate expires.
    serial_number str
    (Output) Serial number, as extracted from the certificate.
    sha1_fingerprint str
    (Output) Sha1 Fingerprint of the certificate.
    cert String
    (Output) The certificate data in PEM format.
    createTime String
    (Output) The time when the certificate was created.
    expireTime String
    (Output) The time when the certificate expires.
    serialNumber String
    (Output) Serial number, as extracted from the certificate.
    sha1Fingerprint String
    (Output) Sha1 Fingerprint of the certificate.

    Import

    Instance can be imported using any of these accepted formats:

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

    • {{project}}/{{region}}/{{name}}

    • {{region}}/{{name}}

    • {{name}}

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

    $ pulumi import gcp:redis/instance:Instance default projects/{{project}}/locations/{{region}}/instances/{{name}}
    
    $ pulumi import gcp:redis/instance:Instance default {{project}}/{{region}}/{{name}}
    
    $ pulumi import gcp:redis/instance:Instance default {{region}}/{{name}}
    
    $ pulumi import gcp:redis/instance:Instance default {{name}}
    

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

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Google Cloud Classic v7.23.0 published on Wednesday, May 15, 2024 by Pulumi