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

InstanceArgs

data class InstanceArgs(val alternativeLocationId: Output<String>? = null, val authEnabled: Output<Boolean>? = null, val authorizedNetwork: Output<String>? = null, val connectMode: Output<String>? = null, val customerManagedKey: Output<String>? = null, val displayName: Output<String>? = null, val labels: Output<Map<String, String>>? = null, val locationId: Output<String>? = null, val maintenancePolicy: Output<InstanceMaintenancePolicyArgs>? = null, val memorySizeGb: Output<Int>? = null, val name: Output<String>? = null, val persistenceConfig: Output<InstancePersistenceConfigArgs>? = null, val project: Output<String>? = null, val readReplicasMode: Output<String>? = null, val redisConfigs: Output<Map<String, String>>? = null, val redisVersion: Output<String>? = null, val region: Output<String>? = null, val replicaCount: Output<Int>? = null, val reservedIpRange: Output<String>? = null, val secondaryIpRange: Output<String>? = null, val tier: Output<String>? = null, val transitEncryptionMode: Output<String>? = null) : ConvertibleToJava<InstanceArgs>

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

Example Usage

Redis Instance Basic

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()
            .memorySizeGb(1)
            .build());
    }
}
Content copied to clipboard

Redis Instance Full

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) {
        final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("redis-test-network")
            .build());
        var cache = new Instance("cache", InstanceArgs.builder()
            .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());
    }
}
Content copied to clipboard

Redis Instance Full With Persistence Config

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()
            .alternativeLocationId("us-central1-f")
            .locationId("us-central1-a")
            .memorySizeGb(1)
            .persistenceConfig(InstancePersistenceConfigArgs.builder()
                .persistenceMode("RDB")
                .rdbSnapshotPeriod("TWELVE_HOURS")
                .build())
            .tier("STANDARD_HA")
            .build());
    }
}
Content copied to clipboard

Redis Instance Private Service

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.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) {
        final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("redis-test-network")
            .build());
        var serviceRange = new GlobalAddress("serviceRange", GlobalAddressArgs.builder()
            .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()
            .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());
    }
}
Content copied to clipboard

Redis Instance Mrr

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) {
        final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("redis-test-network")
            .build());
        var cache = new Instance("cache", InstanceArgs.builder()
            .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());
    }
}
Content copied to clipboard

Redis Instance Cmek

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()
            .location("us-central1")
            .build());
        var redisKey = new CryptoKey("redisKey", CryptoKeyArgs.builder()
            .keyRing(redisKeyring.id())
            .build());
        final var redis-network = ComputeFunctions.getNetwork(GetNetworkArgs.builder()
            .name("redis-test-network")
            .build());
        var cache = new Instance("cache", InstanceArgs.builder()
            .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());
    }
}
Content copied to clipboard

Import

Instance can be imported using any of these accepted formats

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

Constructors

Link copied to clipboard
constructor(alternativeLocationId: Output<String>? = null, authEnabled: Output<Boolean>? = null, authorizedNetwork: Output<String>? = null, connectMode: Output<String>? = null, customerManagedKey: Output<String>? = null, displayName: Output<String>? = null, labels: Output<Map<String, String>>? = null, locationId: Output<String>? = null, maintenancePolicy: Output<InstanceMaintenancePolicyArgs>? = null, memorySizeGb: Output<Int>? = null, name: Output<String>? = null, persistenceConfig: Output<InstancePersistenceConfigArgs>? = null, project: Output<String>? = null, readReplicasMode: Output<String>? = null, redisConfigs: Output<Map<String, String>>? = null, redisVersion: Output<String>? = null, region: Output<String>? = null, replicaCount: Output<Int>? = null, reservedIpRange: Output<String>? = null, secondaryIpRange: Output<String>? = null, tier: Output<String>? = null, transitEncryptionMode: Output<String>? = null)

Properties

Link copied to clipboard
val alternativeLocationId: Output<String>? = null

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.

Link copied to clipboard
val authEnabled: Output<Boolean>? = null

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.

Link copied to clipboard
val authorizedNetwork: Output<String>? = null

The full name of the Google Compute Engine network to which the instance is connected. If left unspecified, the default network will be used.

Link copied to clipboard
val connectMode: Output<String>? = null

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

Link copied to clipboard
val customerManagedKey: Output<String>? = null

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.

Link copied to clipboard
val displayName: Output<String>? = null

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

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

Resource labels to represent user provided metadata.

Link copied to clipboard
val locationId: Output<String>? = null

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.

Link copied to clipboard
val maintenancePolicy: Output<InstanceMaintenancePolicyArgs>? = null

Maintenance policy for an instance. Structure is documented below.

Link copied to clipboard
val memorySizeGb: Output<Int>? = null

Redis memory size in GiB.

Link copied to clipboard
val name: Output<String>? = null

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

Link copied to clipboard
val persistenceConfig: Output<InstancePersistenceConfigArgs>? = null

Persistence configuration for an instance. Structure is documented below.

Link copied to clipboard
val project: Output<String>? = null

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

Link copied to clipboard
val readReplicasMode: Output<String>? = null

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.

Link copied to clipboard
val redisConfigs: Output<Map<String, String>>? = null

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

Link copied to clipboard
val redisVersion: Output<String>? = null

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.

Link copied to clipboard
val region: Output<String>? = null

The name of the Redis region of the instance.

Link copied to clipboard
val replicaCount: Output<Int>? = null

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.

Link copied to clipboard
val reservedIpRange: Output<String>? = null

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.

Link copied to clipboard
val secondaryIpRange: Output<String>? = null

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".

Link copied to clipboard
val tier: Output<String>? = null

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

Link copied to clipboard
val transitEncryptionMode: Output<String>? = null

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

Functions

Link copied to clipboard
open override fun toJava(): InstanceArgs