Google Cloud Classic v8.9.3, Nov 18 24

Google Cloud Classic v8.9.3 published on Monday, Nov 18, 2024 by Pulumi

gcp.redis.Instance

Explore with Pulumi AI

Google Cloud Classic v8.9.3 published on Monday, Nov 18, 2024 by Pulumi

pulumi/pulumi-gcp

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

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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={
        "persistence_mode": "RDB",
        "rdb_snapshot_period": "TWELVE_HOURS",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/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",
}, {
    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.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]))

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/redis"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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
	})
}

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

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/kms"
	"github.com/pulumi/pulumi-gcp/sdk/v8/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,
             display_name: Optional[str] = None,
             connect_mode: Optional[str] = None,
             persistence_config: Optional[InstancePersistenceConfigArgs] = None,
             customer_managed_key: Optional[str] = None,
             alternative_location_id: Optional[str] = None,
             labels: Optional[Mapping[str, str]] = None,
             location_id: Optional[str] = None,
             maintenance_policy: Optional[InstanceMaintenancePolicyArgs] = None,
             project: Optional[str] = None,
             auth_enabled: Optional[bool] = None,
             transit_encryption_mode: Optional[str] = None,
             authorized_network: Optional[str] = None,
             maintenance_version: Optional[str] = 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,
             tier: Optional[str] = None,
             name: 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.

Constructor example

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

var exampleinstanceResourceResourceFromRedisinstance = new Gcp.Redis.Instance("exampleinstanceResourceResourceFromRedisinstance", new()
{
    MemorySizeGb = 0,
    DisplayName = "string",
    ConnectMode = "string",
    PersistenceConfig = new Gcp.Redis.Inputs.InstancePersistenceConfigArgs
    {
        PersistenceMode = "string",
        RdbNextSnapshotTime = "string",
        RdbSnapshotPeriod = "string",
        RdbSnapshotStartTime = "string",
    },
    CustomerManagedKey = "string",
    AlternativeLocationId = "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",
            },
        },
    },
    Project = "string",
    AuthEnabled = false,
    TransitEncryptionMode = "string",
    AuthorizedNetwork = "string",
    MaintenanceVersion = "string",
    ReadReplicasMode = "string",
    RedisConfigs = 
    {
        { "string", "string" },
    },
    RedisVersion = "string",
    Region = "string",
    ReplicaCount = 0,
    ReservedIpRange = "string",
    SecondaryIpRange = "string",
    Tier = "string",
    Name = "string",
});

example, err := redis.NewInstance(ctx, "exampleinstanceResourceResourceFromRedisinstance", &redis.InstanceArgs{
	MemorySizeGb: pulumi.Int(0),
	DisplayName:  pulumi.String("string"),
	ConnectMode:  pulumi.String("string"),
	PersistenceConfig: &redis.InstancePersistenceConfigArgs{
		PersistenceMode:      pulumi.String("string"),
		RdbNextSnapshotTime:  pulumi.String("string"),
		RdbSnapshotPeriod:    pulumi.String("string"),
		RdbSnapshotStartTime: pulumi.String("string"),
	},
	CustomerManagedKey:    pulumi.String("string"),
	AlternativeLocationId: 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"),
			},
		},
	},
	Project:               pulumi.String("string"),
	AuthEnabled:           pulumi.Bool(false),
	TransitEncryptionMode: pulumi.String("string"),
	AuthorizedNetwork:     pulumi.String("string"),
	MaintenanceVersion:    pulumi.String("string"),
	ReadReplicasMode:      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"),
	Name:             pulumi.String("string"),
})

var exampleinstanceResourceResourceFromRedisinstance = new Instance("exampleinstanceResourceResourceFromRedisinstance", InstanceArgs.builder()
    .memorySizeGb(0)
    .displayName("string")
    .connectMode("string")
    .persistenceConfig(InstancePersistenceConfigArgs.builder()
        .persistenceMode("string")
        .rdbNextSnapshotTime("string")
        .rdbSnapshotPeriod("string")
        .rdbSnapshotStartTime("string")
        .build())
    .customerManagedKey("string")
    .alternativeLocationId("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())
    .project("string")
    .authEnabled(false)
    .transitEncryptionMode("string")
    .authorizedNetwork("string")
    .maintenanceVersion("string")
    .readReplicasMode("string")
    .redisConfigs(Map.of("string", "string"))
    .redisVersion("string")
    .region("string")
    .replicaCount(0)
    .reservedIpRange("string")
    .secondaryIpRange("string")
    .tier("string")
    .name("string")
    .build());

exampleinstance_resource_resource_from_redisinstance = gcp.redis.Instance("exampleinstanceResourceResourceFromRedisinstance",
    memory_size_gb=0,
    display_name="string",
    connect_mode="string",
    persistence_config={
        "persistence_mode": "string",
        "rdb_next_snapshot_time": "string",
        "rdb_snapshot_period": "string",
        "rdb_snapshot_start_time": "string",
    },
    customer_managed_key="string",
    alternative_location_id="string",
    labels={
        "string": "string",
    },
    location_id="string",
    maintenance_policy={
        "create_time": "string",
        "description": "string",
        "update_time": "string",
        "weekly_maintenance_windows": [{
            "day": "string",
            "start_time": {
                "hours": 0,
                "minutes": 0,
                "nanos": 0,
                "seconds": 0,
            },
            "duration": "string",
        }],
    },
    project="string",
    auth_enabled=False,
    transit_encryption_mode="string",
    authorized_network="string",
    maintenance_version="string",
    read_replicas_mode="string",
    redis_configs={
        "string": "string",
    },
    redis_version="string",
    region="string",
    replica_count=0,
    reserved_ip_range="string",
    secondary_ip_range="string",
    tier="string",
    name="string")

const exampleinstanceResourceResourceFromRedisinstance = new gcp.redis.Instance("exampleinstanceResourceResourceFromRedisinstance", {
    memorySizeGb: 0,
    displayName: "string",
    connectMode: "string",
    persistenceConfig: {
        persistenceMode: "string",
        rdbNextSnapshotTime: "string",
        rdbSnapshotPeriod: "string",
        rdbSnapshotStartTime: "string",
    },
    customerManagedKey: "string",
    alternativeLocationId: "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",
        }],
    },
    project: "string",
    authEnabled: false,
    transitEncryptionMode: "string",
    authorizedNetwork: "string",
    maintenanceVersion: "string",
    readReplicasMode: "string",
    redisConfigs: {
        string: "string",
    },
    redisVersion: "string",
    region: "string",
    replicaCount: 0,
    reservedIpRange: "string",
    secondaryIpRange: "string",
    tier: "string",
    name: "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
    maintenanceVersion: string
    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

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

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.

MaintenanceVersion string

The self service update maintenance version.

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

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

LocationId string

MaintenancePolicy InstanceMaintenancePolicyArgs

Maintenance policy for an instance. Structure is documented below.

MaintenanceVersion string

The self service update maintenance version.

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

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

ReservedIpRange string

SecondaryIpRange string

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

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>

locationId String

maintenancePolicy InstanceMaintenancePolicy

Maintenance policy for an instance. Structure is documented below.

maintenanceVersion String

The self service update maintenance version.

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>

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

reservedIpRange String

secondaryIpRange String

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

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}

locationId string

maintenancePolicy InstanceMaintenancePolicy

Maintenance policy for an instance. Structure is documented below.

maintenanceVersion string

The self service update maintenance version.

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}

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

reservedIpRange string

secondaryIpRange string

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

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]

location_id str

maintenance_policy InstanceMaintenancePolicyArgs

Maintenance policy for an instance. Structure is documented below.

maintenance_version str

The self service update maintenance version.

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

reserved_ip_range str

secondary_ip_range str

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

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>

locationId String

maintenancePolicy Property Map

Maintenance policy for an instance. Structure is documented below.

maintenanceVersion String

The self service update maintenance version.

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>

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

reservedIpRange String

secondaryIpRange String

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,
        maintenance_version: Optional[str] = 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

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>

LocationId string

MaintenancePolicy InstanceMaintenancePolicy

Maintenance policy for an instance. Structure is documented below.

MaintenanceSchedules List<InstanceMaintenanceSchedule>

Upcoming maintenance schedule. Structure is documented below.

MaintenanceVersion string

The self service update maintenance version.

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>

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

ReservedIpRange string

SecondaryIpRange string

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

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

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

LocationId string

MaintenancePolicy InstanceMaintenancePolicyArgs

Maintenance policy for an instance. Structure is documented below.

MaintenanceSchedules []InstanceMaintenanceScheduleArgs

Upcoming maintenance schedule. Structure is documented below.

MaintenanceVersion string

The self service update maintenance version.

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

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

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

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

ReservedIpRange string

SecondaryIpRange string

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

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

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>

locationId String

maintenancePolicy InstanceMaintenancePolicy

Maintenance policy for an instance. Structure is documented below.

maintenanceSchedules List<InstanceMaintenanceSchedule>

Upcoming maintenance schedule. Structure is documented below.

maintenanceVersion String

The self service update maintenance version.

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

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

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>

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

reservedIpRange String

secondaryIpRange String

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

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

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}

locationId string

maintenancePolicy InstanceMaintenancePolicy

Maintenance policy for an instance. Structure is documented below.

maintenanceSchedules InstanceMaintenanceSchedule[]

Upcoming maintenance schedule. Structure is documented below.

maintenanceVersion string

The self service update maintenance version.

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

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

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}

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

reservedIpRange string

secondaryIpRange string

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

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

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]

location_id str

maintenance_policy InstanceMaintenancePolicyArgs

Maintenance policy for an instance. Structure is documented below.

maintenance_schedules Sequence[InstanceMaintenanceScheduleArgs]

Upcoming maintenance schedule. Structure is documented below.

maintenance_version str

The self service update maintenance version.

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

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

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

reserved_ip_range str

secondary_ip_range str

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

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

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>

locationId String

maintenancePolicy Property Map

Maintenance policy for an instance. Structure is documented below.

maintenanceSchedules List<Property Map>

Upcoming maintenance schedule. Structure is documented below.

maintenanceVersion String

The self service update maintenance version.

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

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

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>

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

reservedIpRange String

secondaryIpRange String

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

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

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

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

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

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

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

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

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

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

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.

Google Cloud Classic v8.9.3 published on Monday, Nov 18, 2024 by Pulumi

pulumi/pulumi-gcp

gcp.redis.Instance

On this page

On this page

Example Usage

Redis Instance Basic

Redis Instance Full

Redis Instance Full With Persistence Config

Redis Instance Private Service

Redis Instance Mrr

Redis Instance Cmek

Create Instance Resource

Constructor syntax

Parameters

Constructor example

Instance Resource Properties

Inputs

Outputs

Look up Existing Instance Resource

Supporting Types

InstanceMaintenancePolicy, InstanceMaintenancePolicyArgs

InstanceMaintenancePolicyWeeklyMaintenanceWindow, InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs

InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTime, InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs

InstanceMaintenanceSchedule, InstanceMaintenanceScheduleArgs

InstanceNode, InstanceNodeArgs

InstancePersistenceConfig, InstancePersistenceConfigArgs

InstanceServerCaCert, InstanceServerCaCertArgs

Import

Package Details

On this page

On this page