pulumi-gcp-kotlin/com.pulumi.gcp.redis.kotlin/Instance

Instance

class Instance : KotlinCustomResource

A Google Cloud Redis instance. To get more information about Instance, see:

API documentation
How-to Guides

Official Documentation

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)

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

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={
        "weekly_maintenance_windows": [{
            "day": "TUESDAY",
            "start_time": {
                "hours": 0,
                "minutes": 30,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    })

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

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={
        "persistence_mode": "RDB",
        "rdb_snapshot_period": "TWELVE_HOURS",
    })

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

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&#46;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",
}, {
    dependsOn: [privateServiceConnection],
});

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&#46;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",
    opts = pulumi.ResourceOptions(depends_on=[private_service_connection]))

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",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            privateServiceConnection,
        },
    });
});

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
		}
		privateServiceConnection, 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"),
		}, pulumi.DependsOn([]pulumi.Resource{
			privateServiceConnection,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.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 com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        // 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(), CustomResourceOptions.builder()
                .dependsOn(privateServiceConnection)
                .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
    options:
      dependson:
        - ${privateServiceConnection}

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

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

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)

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

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

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

Properties

alternativeLocationId

val alternativeLocationId: Output<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

val authEnabled: Output<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

val authorizedNetwork: Output<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.

authString

val authString: Output<String>

AUTH String set on the instance. This field will only be populated if auth_enabled is true.

connectMode

val connectMode: Output<String>?

The connection mode of the Redis instance. Default value is DIRECT_PEERING. Possible values are: DIRECT_PEERING, PRIVATE_SERVICE_ACCESS.

createTime

val createTime: Output<String>

(Output) The time when the certificate was created.

currentLocationId

val currentLocationId: Output<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

val customerManagedKey: Output<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

val displayName: Output<String>?

An arbitrary and optional user-provided name for the instance.

effectiveLabels

val effectiveLabels: Output<Map<String, String>>

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

host

val host: Output<String>

Hostname or IP address of the exposed Redis endpoint used by clients to connect to the service.

val id: Output<String>

labels

val labels: Output<Map<String, String>>?

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

locationId

val locationId: Output<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

val maintenancePolicy: Output<InstanceMaintenancePolicy>?

Maintenance policy for an instance. Structure is documented below.

maintenanceSchedules

val maintenanceSchedules: Output<List<InstanceMaintenanceSchedule>>

Upcoming maintenance schedule. Structure is documented below.

maintenanceVersion

val maintenanceVersion: Output<String>

The self service update maintenance version.

memorySizeGb

val memorySizeGb: Output<Int>

Redis memory size in GiB.

name

val name: Output<String>

The ID of the instance or a fully qualified identifier for the instance.

nodes

val nodes: Output<List<InstanceNode>>

Output only. Info per node. Structure is documented below.

persistenceConfig

val persistenceConfig: Output<InstancePersistenceConfig>

Persistence configuration for an instance. Structure is documented below.

persistenceIamIdentity

val persistenceIamIdentity: Output<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

val port: Output<Int>

The port number of the exposed Redis endpoint.

project

val project: Output<String>

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

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiLabels

val pulumiLabels: Output<Map<String, String>>

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

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

readEndpoint

val readEndpoint: Output<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

val readEndpointPort: Output<Int>

Output only. The port number of the exposed readonly redis endpoint. Standard tier only. Write requests should target 'port'.

readReplicasMode

val readReplicasMode: Output<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.

redisConfigs

val redisConfigs: Output<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

val redisVersion: Output<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

val region: Output<String>

The name of the Redis region of the instance.

replicaCount

val replicaCount: Output<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

val reservedIpRange: Output<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

val secondaryIpRange: Output<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

val serverCaCerts: Output<List<InstanceServerCaCert>>

List of server CA certificates for the instance. Structure is documented below.

tier

val tier: Output<String>?

The service tier of the instance. Must be one of these values:

transitEncryptionMode

val transitEncryptionMode: Output<String>?

The TLS mode of the Redis instance, If not provided, TLS is disabled for the instance.

urn

val urn: Output<String>