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

InstanceArgs

data class InstanceArgs(val capacityGib: Output<String>? = null, val deploymentType: Output<String>? = null, val description: Output<String>? = null, val directoryStripeLevel: Output<String>? = null, val fileStripeLevel: 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>

A Parallelstore Instance.

Example Usage

Parallelstore Instance Basic Beta

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,
    fileStripeLevel: "FILE_STRIPE_LEVEL_MIN",
    directoryStripeLevel: "DIRECTORY_STRIPE_LEVEL_MIN",
    deploymentType: "SCRATCH",
    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,
    file_stripe_level="FILE_STRIPE_LEVEL_MIN",
    directory_stripe_level="DIRECTORY_STRIPE_LEVEL_MIN",
    deployment_type="SCRATCH",
    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,
        FileStripeLevel = "FILE_STRIPE_LEVEL_MIN",
        DirectoryStripeLevel = "DIRECTORY_STRIPE_LEVEL_MIN",
        DeploymentType = "SCRATCH",
        Labels =
        {
            { "test", "value" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parallelstore"
	"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 {
		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
		_default, 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,
			FileStripeLevel:      pulumi.String("FILE_STRIPE_LEVEL_MIN"),
			DirectoryStripeLevel: pulumi.String("DIRECTORY_STRIPE_LEVEL_MIN"),
			DeploymentType:       pulumi.String("SCRATCH"),
			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())
            .fileStripeLevel("FILE_STRIPE_LEVEL_MIN")
            .directoryStripeLevel("DIRECTORY_STRIPE_LEVEL_MIN")
            .deploymentType("SCRATCH")
            .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}
      fileStripeLevel: FILE_STRIPE_LEVEL_MIN
      directoryStripeLevel: DIRECTORY_STRIPE_LEVEL_MIN
      deploymentType: SCRATCH
      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

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,
    fileStripeLevel: "FILE_STRIPE_LEVEL_MIN",
    directoryStripeLevel: "DIRECTORY_STRIPE_LEVEL_MIN",
    deploymentType: "SCRATCH",
    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,
    file_stripe_level="FILE_STRIPE_LEVEL_MIN",
    directory_stripe_level="DIRECTORY_STRIPE_LEVEL_MIN",
    deployment_type="SCRATCH",
    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,
        FileStripeLevel = "FILE_STRIPE_LEVEL_MIN",
        DirectoryStripeLevel = "DIRECTORY_STRIPE_LEVEL_MIN",
        DeploymentType = "SCRATCH",
        Labels =
        {
            { "test", "value" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @default,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/parallelstore"
	"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 {
		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
		_default, 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,
			FileStripeLevel:      pulumi.String("FILE_STRIPE_LEVEL_MIN"),
			DirectoryStripeLevel: pulumi.String("DIRECTORY_STRIPE_LEVEL_MIN"),
			DeploymentType:       pulumi.String("SCRATCH"),
			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())
            .fileStripeLevel("FILE_STRIPE_LEVEL_MIN")
            .directoryStripeLevel("DIRECTORY_STRIPE_LEVEL_MIN")
            .deploymentType("SCRATCH")
            .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}
      fileStripeLevel: FILE_STRIPE_LEVEL_MIN
      directoryStripeLevel: DIRECTORY_STRIPE_LEVEL_MIN
      deploymentType: SCRATCH
      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, deploymentType: Output<String>? = null, description: Output<String>? = null, directoryStripeLevel: Output<String>? = null, fileStripeLevel: 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

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

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

Parallelstore Instance deployment type. Possible values: DEPLOYMENT_TYPE_UNSPECIFIED SCRATCH PERSISTENT

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

The description of the instance. 2048 characters or less.

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

Stripe level for directories. MIN when directory has a small number of files. MAX when directory has a large number of files. Possible values: DIRECTORY_STRIPE_LEVEL_UNSPECIFIED DIRECTORY_STRIPE_LEVEL_MIN DIRECTORY_STRIPE_LEVEL_BALANCED DIRECTORY_STRIPE_LEVEL_MAX

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

Stripe level for files. MIN better suited for small size files. MAX higher throughput performance for larger files. Possible values: FILE_STRIPE_LEVEL_UNSPECIFIED FILE_STRIPE_LEVEL_MIN FILE_STRIPE_LEVEL_BALANCED FILE_STRIPE_LEVEL_MAX

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