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

InstanceArgs

data class InstanceArgs(val capacityGib: Output<String>? = null, val description: Output<String>? = null, val instanceId: Output<String>? = null, val labels: Output<Map<String, String>>? = null, val location: Output<String>? = null, val network: Output<String>? = null, val project: Output<String>? = null, val reservedIpRange: Output<String>? = null) : ConvertibleToJava<InstanceArgs>

Example Usage

Parallelstore Instance Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const network = new gcp.compute.Network("network", {
    name: "network",
    autoCreateSubnetworks: true,
    mtu: 8896,
});
// Create an IP address
const privateIpAlloc = new gcp.compute.GlobalAddress("private_ip_alloc", {
    name: "address",
    purpose: "VPC_PEERING",
    addressType: "INTERNAL",
    prefixLength: 24,
    network: network.id,
});
// Create a private connection
const _default = new gcp.servicenetworking.Connection("default", {
    network: network.id,
    service: "servicenetworking.googleapis.com",
    reservedPeeringRanges: [privateIpAlloc&#46;name],
});
const instance = new gcp.parallelstore.Instance("instance", {
    instanceId: "instance",
    location: "us-central1-a",
    description: "test instance",
    capacityGib: "12000",
    network: network.name,
    labels: {
        test: "value",
    },
}, {
    dependsOn: [_default],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
network = gcp.compute.Network("network",
    name="network",
    auto_create_subnetworks=True,
    mtu=8896)
# Create an IP address
private_ip_alloc = gcp.compute.GlobalAddress("private_ip_alloc",
    name="address",
    purpose="VPC_PEERING",
    address_type="INTERNAL",
    prefix_length=24,
    network=network.id)
# Create a private connection
default = gcp.servicenetworking.Connection("default",
    network=network.id,
    service="servicenetworking.googleapis.com",
    reserved_peering_ranges=[private_ip_alloc&#46;name])
instance = gcp.parallelstore.Instance("instance",
    instance_id="instance",
    location="us-central1-a",
    description="test instance",
    capacity_gib="12000",
    network=network.name,
    labels={
        "test": "value",
    },
    opts=pulumi.ResourceOptions(depends_on=[default]))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var network = new Gcp.Compute.Network("network", new()
    {
        Name = "network",
        AutoCreateSubnetworks = true,
        Mtu = 8896,
    });
    // Create an IP address
    var privateIpAlloc = new Gcp.Compute.GlobalAddress("private_ip_alloc", new()
    {
        Name = "address",
        Purpose = "VPC_PEERING",
        AddressType = "INTERNAL",
        PrefixLength = 24,
        Network = network.Id,
    });
    // Create a private connection
    var @default = new Gcp.ServiceNetworking.Connection("default", new()
    {
        Network = network.Id,
        Service = "servicenetworking.googleapis.com",
        ReservedPeeringRanges = new[]
        {
            privateIpAlloc.Name,
        },
    });
    var instance = new Gcp.ParallelStore.Instance("instance", new()
    {
        InstanceId = "instance",
        Location = "us-central1-a",
        Description = "test instance",
        CapacityGib = "12000",
        Network = network.Name,
        Labels =
        {
            { "test", "value" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/parallelstore"
	"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 {
		network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
			Name:                  pulumi.String("network"),
			AutoCreateSubnetworks: pulumi.Bool(true),
			Mtu:                   pulumi.Int(8896),
		})
		if err != nil {
			return err
		}
		// Create an IP address
		privateIpAlloc, err := compute.NewGlobalAddress(ctx, "private_ip_alloc", &compute.GlobalAddressArgs{
			Name:         pulumi.String("address"),
			Purpose:      pulumi.String("VPC_PEERING"),
			AddressType:  pulumi.String("INTERNAL"),
			PrefixLength: pulumi.Int(24),
			Network:      network.ID(),
		})
		if err != nil {
			return err
		}
		// Create a private connection
		_, err = servicenetworking.NewConnection(ctx, "default", &servicenetworking.ConnectionArgs{
			Network: network.ID(),
			Service: pulumi.String("servicenetworking.googleapis.com"),
			ReservedPeeringRanges: pulumi.StringArray{
				privateIpAlloc.Name,
			},
		})
		if err != nil {
			return err
		}
		_, err = parallelstore.NewInstance(ctx, "instance", &parallelstore.InstanceArgs{
			InstanceId:  pulumi.String("instance"),
			Location:    pulumi.String("us-central1-a"),
			Description: pulumi.String("test instance"),
			CapacityGib: pulumi.String("12000"),
			Network:     network.Name,
			Labels: pulumi.StringMap{
				"test": pulumi.String("value"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			_default,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.parallelstore.Instance;
import com.pulumi.gcp.parallelstore.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) {
        var network = new Network("network", NetworkArgs.builder()
            .name("network")
            .autoCreateSubnetworks(true)
            .mtu(8896)
            .build());
        // Create an IP address
        var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
            .name("address")
            .purpose("VPC_PEERING")
            .addressType("INTERNAL")
            .prefixLength(24)
            .network(network.id())
            .build());
        // Create a private connection
        var default_ = new Connection("default", ConnectionArgs.builder()
            .network(network.id())
            .service("servicenetworking.googleapis.com")
            .reservedPeeringRanges(privateIpAlloc.name())
            .build());
        var instance = new Instance("instance", InstanceArgs.builder()
            .instanceId("instance")
            .location("us-central1-a")
            .description("test instance")
            .capacityGib(12000)
            .network(network.name())
            .labels(Map.of("test", "value"))
            .build(), CustomResourceOptions.builder()
                .dependsOn(default_)
                .build());
    }
}
Content copied to clipboard
resources:
  instance:
    type: gcp:parallelstore:Instance
    properties:
      instanceId: instance
      location: us-central1-a
      description: test instance
      capacityGib: 12000
      network: ${network.name}
      labels:
        test: value
    options:
      dependson:
        - ${default}
  network:
    type: gcp:compute:Network
    properties:
      name: network
      autoCreateSubnetworks: true
      mtu: 8896
  # Create an IP address
  privateIpAlloc:
    type: gcp:compute:GlobalAddress
    name: private_ip_alloc
    properties:
      name: address
      purpose: VPC_PEERING
      addressType: INTERNAL
      prefixLength: 24
      network: ${network.id}
  # Create a private connection
  default:
    type: gcp:servicenetworking:Connection
    properties:
      network: ${network.id}
      service: servicenetworking.googleapis.com
      reservedPeeringRanges:
        - ${privateIpAlloc.name}
Content copied to clipboard

Import

Instance can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/instances/{{instance_id}}

  • {{project}}/{{location}}/{{instance_id}}

  • {{location}}/{{instance_id}} When using the pulumi import command, Instance can be imported using one of the formats above. For example:

$ pulumi import gcp:parallelstore/instance:Instance default projects/{{project}}/locations/{{location}}/instances/{{instance_id}}
Content copied to clipboard
$ pulumi import gcp:parallelstore/instance:Instance default {{project}}/{{location}}/{{instance_id}}
Content copied to clipboard
$ pulumi import gcp:parallelstore/instance:Instance default {{location}}/{{instance_id}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(capacityGib: Output<String>? = null, description: Output<String>? = null, instanceId: Output<String>? = null, labels: Output<Map<String, String>>? = null, location: Output<String>? = null, network: Output<String>? = null, project: Output<String>? = null, reservedIpRange: Output<String>? = null)

Properties

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

Immutable. Storage capacity of Parallelstore instance in Gibibytes (GiB).

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

The description of the instance. 2048 characters or less.

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

The logical name of the Parallelstore instance in the user project with the following restrictions:

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

Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer's organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.).

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

Part of parent. See documentation of projectsId.

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

Immutable. The name of the Google Compute Engine VPC network to which the instance is connected.

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

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

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

Immutable. Contains the id of the allocated IP address range associated with the private service access connection for example, "test-default" associated with IP range 10.0.0.0/29. If no range id is provided all ranges will be considered.

Functions

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