InstanceArgs

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
// Memcache 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 memcacheNetwork = new gcp.compute.Network("memcache_network", {name: "test-network"});
const serviceRange = new gcp.compute.GlobalAddress("service_range", {
    name: "address",
    purpose: "VPC_PEERING",
    addressType: "INTERNAL",
    prefixLength: 16,
    network: memcacheNetwork.id,
});
const privateServiceConnection = new gcp.servicenetworking.Connection("private_service_connection", {
    network: memcacheNetwork.id,
    service: "servicenetworking.googleapis.com",
    reservedPeeringRanges: [serviceRange.name],
});
const instance = new gcp.memcache.Instance("instance", {
    name: "test-instance",
    authorizedNetwork: privateServiceConnection.network,
    labels: {
        env: "test",
    },
    nodeConfig: {
        cpuCount: 1,
        memorySizeMb: 1024,
    },
    nodeCount: 1,
    memcacheVersion: "MEMCACHE_1_5",
    maintenancePolicy: {
        weeklyMaintenanceWindows: [{
            day: "SATURDAY",
            duration: "14400s",
            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
# Memcache 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"
memcache_network = gcp.compute.Network("memcache_network", name="test-network")
service_range = gcp.compute.GlobalAddress("service_range",
    name="address",
    purpose="VPC_PEERING",
    address_type="INTERNAL",
    prefix_length=16,
    network=memcache_network.id)
private_service_connection = gcp.servicenetworking.Connection("private_service_connection",
    network=memcache_network.id,
    service="servicenetworking.googleapis.com",
    reserved_peering_ranges=[service_range.name])
instance = gcp.memcache.Instance("instance",
    name="test-instance",
    authorized_network=private_service_connection.network,
    labels={
        "env": "test",
    },
    node_config={
        "cpu_count": 1,
        "memory_size_mb": 1024,
    },
    node_count=1,
    memcache_version="MEMCACHE_1_5",
    maintenance_policy={
        "weekly_maintenance_windows": [{
            "day": "SATURDAY",
            "duration": "14400s",
            "start_time": {
                "hours": 0,
                "minutes": 30,
                "seconds": 0,
                "nanos": 0,
            },
        }],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    // This example assumes this network already exists.
    // The API creates a tenant network per network authorized for a
    // Memcache 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 memcacheNetwork = new Gcp.Compute.Network("memcache_network", new()
    {
        Name = "test-network",
    });
    var serviceRange = new Gcp.Compute.GlobalAddress("service_range", new()
    {
        Name = "address",
        Purpose = "VPC_PEERING",
        AddressType = "INTERNAL",
        PrefixLength = 16,
        Network = memcacheNetwork.Id,
    });
    var privateServiceConnection = new Gcp.ServiceNetworking.Connection("private_service_connection", new()
    {
        Network = memcacheNetwork.Id,
        Service = "servicenetworking.googleapis.com",
        ReservedPeeringRanges = new[]
        {
            serviceRange.Name,
        },
    });
    var instance = new Gcp.Memcache.Instance("instance", new()
    {
        Name = "test-instance",
        AuthorizedNetwork = privateServiceConnection.Network,
        Labels =
        {
            { "env", "test" },
        },
        NodeConfig = new Gcp.Memcache.Inputs.InstanceNodeConfigArgs
        {
            CpuCount = 1,
            MemorySizeMb = 1024,
        },
        NodeCount = 1,
        MemcacheVersion = "MEMCACHE_1_5",
        MaintenancePolicy = new Gcp.Memcache.Inputs.InstanceMaintenancePolicyArgs
        {
            WeeklyMaintenanceWindows = new[]
            {
                new Gcp.Memcache.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs
                {
                    Day = "SATURDAY",
                    Duration = "14400s",
                    StartTime = new Gcp.Memcache.Inputs.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs
                    {
                        Hours = 0,
                        Minutes = 30,
                        Seconds = 0,
                        Nanos = 0,
                    },
                },
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/memcache"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/servicenetworking"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// This example assumes this network already exists.
		// The API creates a tenant network per network authorized for a
		// Memcache 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"
		memcacheNetwork, err := compute.NewNetwork(ctx, "memcache_network", &compute.NetworkArgs{
			Name: pulumi.String("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:      memcacheNetwork.ID(),
		})
		if err != nil {
			return err
		}
		privateServiceConnection, err := servicenetworking.NewConnection(ctx, "private_service_connection", &servicenetworking.ConnectionArgs{
			Network: memcacheNetwork.ID(),
			Service: pulumi.String("servicenetworking.googleapis.com"),
			ReservedPeeringRanges: pulumi.StringArray{
				serviceRange.Name,
			},
		})
		if err != nil {
			return err
		}
		_, err = memcache.NewInstance(ctx, "instance", &memcache.InstanceArgs{
			Name:              pulumi.String("test-instance"),
			AuthorizedNetwork: privateServiceConnection.Network,
			Labels: pulumi.StringMap{
				"env": pulumi.String("test"),
			},
			NodeConfig: &memcache.InstanceNodeConfigArgs{
				CpuCount:     pulumi.Int(1),
				MemorySizeMb: pulumi.Int(1024),
			},
			NodeCount:       pulumi.Int(1),
			MemcacheVersion: pulumi.String("MEMCACHE_1_5"),
			MaintenancePolicy: &memcache.InstanceMaintenancePolicyArgs{
				WeeklyMaintenanceWindows: memcache.InstanceMaintenancePolicyWeeklyMaintenanceWindowArray{
					&memcache.InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs{
						Day:      pulumi.String("SATURDAY"),
						Duration: pulumi.String("14400s"),
						StartTime: &memcache.InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs{
							Hours:   pulumi.Int(0),
							Minutes: pulumi.Int(30),
							Seconds: pulumi.Int(0),
							Nanos:   pulumi.Int(0),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.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.memcache.Instance;
import com.pulumi.gcp.memcache.InstanceArgs;
import com.pulumi.gcp.memcache.inputs.InstanceNodeConfigArgs;
import com.pulumi.gcp.memcache.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
        // Memcache 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 memcacheNetwork = new Network("memcacheNetwork", NetworkArgs.builder()
            .name("test-network")
            .build());
        var serviceRange = new GlobalAddress("serviceRange", GlobalAddressArgs.builder()
            .name("address")
            .purpose("VPC_PEERING")
            .addressType("INTERNAL")
            .prefixLength(16)
            .network(memcacheNetwork.id())
            .build());
        var privateServiceConnection = new Connection("privateServiceConnection", ConnectionArgs.builder()
            .network(memcacheNetwork.id())
            .service("servicenetworking.googleapis.com")
            .reservedPeeringRanges(serviceRange.name())
            .build());
        var instance = new Instance("instance", InstanceArgs.builder()
            .name("test-instance")
            .authorizedNetwork(privateServiceConnection.network())
            .labels(Map.of("env", "test"))
            .nodeConfig(InstanceNodeConfigArgs.builder()
                .cpuCount(1)
                .memorySizeMb(1024)
                .build())
            .nodeCount(1)
            .memcacheVersion("MEMCACHE_1_5")
            .maintenancePolicy(InstanceMaintenancePolicyArgs.builder()
                .weeklyMaintenanceWindows(InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs.builder()
                    .day("SATURDAY")
                    .duration("14400s")
                    .startTime(InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgs.builder()
                        .hours(0)
                        .minutes(30)
                        .seconds(0)
                        .nanos(0)
                        .build())
                    .build())
                .build())
            .build());
    }
}

resources:
  # This example assumes this network already exists.
  # // The API creates a tenant network per network authorized for a
  # // Memcache 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"
  memcacheNetwork:
    type: gcp:compute:Network
    name: memcache_network
    properties:
      name: test-network
  serviceRange:
    type: gcp:compute:GlobalAddress
    name: service_range
    properties:
      name: address
      purpose: VPC_PEERING
      addressType: INTERNAL
      prefixLength: 16
      network: ${memcacheNetwork.id}
  privateServiceConnection:
    type: gcp:servicenetworking:Connection
    name: private_service_connection
    properties:
      network: ${memcacheNetwork.id}
      service: servicenetworking.googleapis.com
      reservedPeeringRanges:
        - ${serviceRange.name}
  instance:
    type: gcp:memcache:Instance
    properties:
      name: test-instance
      authorizedNetwork: ${privateServiceConnection.network}
      labels:
        env: test
      nodeConfig:
        cpuCount: 1
        memorySizeMb: 1024
      nodeCount: 1
      memcacheVersion: MEMCACHE_1_5
      maintenancePolicy:
        weeklyMaintenanceWindows:
          - day: SATURDAY
            duration: 14400s
            startTime:
              hours: 0
              minutes: 30
              seconds: 0
              nanos: 0

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

$ pulumi import gcp:memcache/instance:Instance default {{project}}/{{region}}/{{name}}

$ pulumi import gcp:memcache/instance:Instance default {{region}}/{{name}}

$ pulumi import gcp:memcache/instance:Instance default {{name}}