Docs Packages
  1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. netapp
  5. StoragePool
Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi
pulumi/pulumi-gcp

gcp.netapp.StoragePool

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi
pulumi/pulumi-gcp

    Storage pools act as containers for volumes. All volumes in a storage pool share the following information:

    • Location
    • Service level
    • Virtual Private Cloud (VPC) network
    • Active Directory policy
    • LDAP use for NFS volumes, if applicable
    • Customer-managed encryption key (CMEK) policy

    The capacity of the pool can be split up and assigned to volumes within the pool. Storage pools are a billable component of NetApp Volumes. Billing is based on the location, service level, and capacity allocated to a pool independent of consumption at the volume level.

    To get more information about storagePool, see:

    Example Usage

    Storage Pool Create

    import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

// Create a network or use datasource to reference existing network
const peeringNetwork = new gcp.compute.Network("peering_network", {name: "test-network"});
// Reserve a CIDR for NetApp Volumes to use
// When using shared-VPCs, this resource needs to be created in host project
const privateIpAlloc = new gcp.compute.GlobalAddress("private_ip_alloc", {
    name: "test-address",
    purpose: "VPC_PEERING",
    addressType: "INTERNAL",
    prefixLength: 16,
    network: peeringNetwork.id,
});
// Create a Private Service Access connection
// When using shared-VPCs, this resource needs to be created in host project
const _default = new gcp.servicenetworking.Connection("default", {
    network: peeringNetwork.id,
    service: "netapp.servicenetworking.goog",
    reservedPeeringRanges: [privateIpAlloc.name],
});
// Modify the PSA Connection to allow import/export of custom routes
// When using shared-VPCs, this resource needs to be created in host project
const routeUpdates = new gcp.compute.NetworkPeeringRoutesConfig("route_updates", {
    peering: _default.peering,
    network: peeringNetwork.name,
    importCustomRoutes: true,
    exportCustomRoutes: true,
});
// Create a storage pool
// Create this resource in the project which is expected to own the volumes
const testPool = new gcp.netapp.StoragePool("test_pool", {
    name: "test-pool",
    location: "us-central1",
    serviceLevel: "PREMIUM",
    capacityGib: "2048",
    network: peeringNetwork.id,
});

    import pulumi
import pulumi_gcp as gcp

# Create a network or use datasource to reference existing network
peering_network = gcp.compute.Network("peering_network", name="test-network")
# Reserve a CIDR for NetApp Volumes to use
# When using shared-VPCs, this resource needs to be created in host project
private_ip_alloc = gcp.compute.GlobalAddress("private_ip_alloc",
    name="test-address",
    purpose="VPC_PEERING",
    address_type="INTERNAL",
    prefix_length=16,
    network=peering_network.id)
# Create a Private Service Access connection
# When using shared-VPCs, this resource needs to be created in host project
default = gcp.servicenetworking.Connection("default",
    network=peering_network.id,
    service="netapp.servicenetworking.goog",
    reserved_peering_ranges=[private_ip_alloc.name])
# Modify the PSA Connection to allow import/export of custom routes
# When using shared-VPCs, this resource needs to be created in host project
route_updates = gcp.compute.NetworkPeeringRoutesConfig("route_updates",
    peering=default.peering,
    network=peering_network.name,
    import_custom_routes=True,
    export_custom_routes=True)
# Create a storage pool
# Create this resource in the project which is expected to own the volumes
test_pool = gcp.netapp.StoragePool("test_pool",
    name="test-pool",
    location="us-central1",
    service_level="PREMIUM",
    capacity_gib="2048",
    network=peering_network.id)

    package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/netapp"
	"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 {
		// Create a network or use datasource to reference existing network
		peeringNetwork, err := compute.NewNetwork(ctx, "peering_network", &compute.NetworkArgs{
			Name: pulumi.String("test-network"),
		})
		if err != nil {
			return err
		}
		// Reserve a CIDR for NetApp Volumes to use
		// When using shared-VPCs, this resource needs to be created in host project
		privateIpAlloc, err := compute.NewGlobalAddress(ctx, "private_ip_alloc", &compute.GlobalAddressArgs{
			Name:         pulumi.String("test-address"),
			Purpose:      pulumi.String("VPC_PEERING"),
			AddressType:  pulumi.String("INTERNAL"),
			PrefixLength: pulumi.Int(16),
			Network:      peeringNetwork.ID(),
		})
		if err != nil {
			return err
		}
		// Create a Private Service Access connection
		// When using shared-VPCs, this resource needs to be created in host project
		_, err = servicenetworking.NewConnection(ctx, "default", &servicenetworking.ConnectionArgs{
			Network: peeringNetwork.ID(),
			Service: pulumi.String("netapp.servicenetworking.goog"),
			ReservedPeeringRanges: pulumi.StringArray{
				privateIpAlloc.Name,
			},
		})
		if err != nil {
			return err
		}
		// Modify the PSA Connection to allow import/export of custom routes
		// When using shared-VPCs, this resource needs to be created in host project
		_, err = compute.NewNetworkPeeringRoutesConfig(ctx, "route_updates", &compute.NetworkPeeringRoutesConfigArgs{
			Peering:            _default.Peering,
			Network:            peeringNetwork.Name,
			ImportCustomRoutes: pulumi.Bool(true),
			ExportCustomRoutes: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Create a storage pool
		// Create this resource in the project which is expected to own the volumes
		_, err = netapp.NewStoragePool(ctx, "test_pool", &netapp.StoragePoolArgs{
			Name:         pulumi.String("test-pool"),
			Location:     pulumi.String("us-central1"),
			ServiceLevel: pulumi.String("PREMIUM"),
			CapacityGib:  pulumi.String("2048"),
			Network:      peeringNetwork.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(() => 
{
    // Create a network or use datasource to reference existing network
    var peeringNetwork = new Gcp.Compute.Network("peering_network", new()
    {
        Name = "test-network",
    });

    // Reserve a CIDR for NetApp Volumes to use
    // When using shared-VPCs, this resource needs to be created in host project
    var privateIpAlloc = new Gcp.Compute.GlobalAddress("private_ip_alloc", new()
    {
        Name = "test-address",
        Purpose = "VPC_PEERING",
        AddressType = "INTERNAL",
        PrefixLength = 16,
        Network = peeringNetwork.Id,
    });

    // Create a Private Service Access connection
    // When using shared-VPCs, this resource needs to be created in host project
    var @default = new Gcp.ServiceNetworking.Connection("default", new()
    {
        Network = peeringNetwork.Id,
        Service = "netapp.servicenetworking.goog",
        ReservedPeeringRanges = new[]
        {
            privateIpAlloc.Name,
        },
    });

    // Modify the PSA Connection to allow import/export of custom routes
    // When using shared-VPCs, this resource needs to be created in host project
    var routeUpdates = new Gcp.Compute.NetworkPeeringRoutesConfig("route_updates", new()
    {
        Peering = @default.Peering,
        Network = peeringNetwork.Name,
        ImportCustomRoutes = true,
        ExportCustomRoutes = true,
    });

    // Create a storage pool
    // Create this resource in the project which is expected to own the volumes
    var testPool = new Gcp.Netapp.StoragePool("test_pool", new()
    {
        Name = "test-pool",
        Location = "us-central1",
        ServiceLevel = "PREMIUM",
        CapacityGib = "2048",
        Network = peeringNetwork.Id,
    });

});

    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.compute.NetworkPeeringRoutesConfig;
import com.pulumi.gcp.compute.NetworkPeeringRoutesConfigArgs;
import com.pulumi.gcp.netapp.StoragePool;
import com.pulumi.gcp.netapp.StoragePoolArgs;
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) {
        // Create a network or use datasource to reference existing network
        var peeringNetwork = new Network("peeringNetwork", NetworkArgs.builder()
            .name("test-network")
            .build());

        // Reserve a CIDR for NetApp Volumes to use
        // When using shared-VPCs, this resource needs to be created in host project
        var privateIpAlloc = new GlobalAddress("privateIpAlloc", GlobalAddressArgs.builder()
            .name("test-address")
            .purpose("VPC_PEERING")
            .addressType("INTERNAL")
            .prefixLength(16)
            .network(peeringNetwork.id())
            .build());

        // Create a Private Service Access connection
        // When using shared-VPCs, this resource needs to be created in host project
        var default_ = new Connection("default", ConnectionArgs.builder()
            .network(peeringNetwork.id())
            .service("netapp.servicenetworking.goog")
            .reservedPeeringRanges(privateIpAlloc.name())
            .build());

        // Modify the PSA Connection to allow import/export of custom routes
        // When using shared-VPCs, this resource needs to be created in host project
        var routeUpdates = new NetworkPeeringRoutesConfig("routeUpdates", NetworkPeeringRoutesConfigArgs.builder()
            .peering(default_.peering())
            .network(peeringNetwork.name())
            .importCustomRoutes(true)
            .exportCustomRoutes(true)
            .build());

        // Create a storage pool
        // Create this resource in the project which is expected to own the volumes
        var testPool = new StoragePool("testPool", StoragePoolArgs.builder()
            .name("test-pool")
            .location("us-central1")
            .serviceLevel("PREMIUM")
            .capacityGib("2048")
            .network(peeringNetwork.id())
            .build());

    }
}

    resources:
  # Create a network or use datasource to reference existing network
  peeringNetwork:
    type: gcp:compute:Network
    name: peering_network
    properties:
      name: test-network
  # Reserve a CIDR for NetApp Volumes to use
  # When using shared-VPCs, this resource needs to be created in host project
  privateIpAlloc:
    type: gcp:compute:GlobalAddress
    name: private_ip_alloc
    properties:
      name: test-address
      purpose: VPC_PEERING
      addressType: INTERNAL
      prefixLength: 16
      network: ${peeringNetwork.id}
  # Create a Private Service Access connection
  # When using shared-VPCs, this resource needs to be created in host project
  default:
    type: gcp:servicenetworking:Connection
    properties:
      network: ${peeringNetwork.id}
      service: netapp.servicenetworking.goog
      reservedPeeringRanges:
        - ${privateIpAlloc.name}
  # Modify the PSA Connection to allow import/export of custom routes
  # When using shared-VPCs, this resource needs to be created in host project
  routeUpdates:
    type: gcp:compute:NetworkPeeringRoutesConfig
    name: route_updates
    properties:
      peering: ${default.peering}
      network: ${peeringNetwork.name}
      importCustomRoutes: true
      exportCustomRoutes: true
  # Create a storage pool
  # Create this resource in the project which is expected to own the volumes
  testPool:
    type: gcp:netapp:StoragePool
    name: test_pool
    properties:
      name: test-pool
      location: us-central1
      serviceLevel: PREMIUM
      capacityGib: '2048'
      network: ${peeringNetwork.id}

    Create StoragePool Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new StoragePool(name: string, args: StoragePoolArgs, opts?: CustomResourceOptions);
    @overload
def StoragePool(resource_name: str,
                args: StoragePoolArgs,
                opts: Optional[ResourceOptions] = None)

@overload
def StoragePool(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                capacity_gib: Optional[str] = None,
                location: Optional[str] = None,
                network: Optional[str] = None,
                service_level: Optional[str] = None,
                active_directory: Optional[str] = None,
                description: Optional[str] = None,
                kms_config: Optional[str] = None,
                labels: Optional[Mapping[str, str]] = None,
                ldap_enabled: Optional[bool] = None,
                name: Optional[str] = None,
                project: Optional[str] = None)
    func NewStoragePool(ctx *Context, name string, args StoragePoolArgs, opts ...ResourceOption) (*StoragePool, error)
    public StoragePool(string name, StoragePoolArgs args, CustomResourceOptions? opts = null)
    public StoragePool(String name, StoragePoolArgs args)
public StoragePool(String name, StoragePoolArgs args, CustomResourceOptions options)

    type: gcp:netapp:StoragePool
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 StoragePoolArgs
    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 StoragePoolArgs
    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 StoragePoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args StoragePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args StoragePoolArgs
    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 storagePoolResource = new Gcp.Netapp.StoragePool("storagePoolResource", new()
{
    CapacityGib = "string",
    Location = "string",
    Network = "string",
    ServiceLevel = "string",
    ActiveDirectory = "string",
    Description = "string",
    KmsConfig = "string",
    Labels = 
    {
        { "string", "string" },
    },
    LdapEnabled = false,
    Name = "string",
    Project = "string",
});

    example, err := netapp.NewStoragePool(ctx, "storagePoolResource", &netapp.StoragePoolArgs{
	CapacityGib:     pulumi.String("string"),
	Location:        pulumi.String("string"),
	Network:         pulumi.String("string"),
	ServiceLevel:    pulumi.String("string"),
	ActiveDirectory: pulumi.String("string"),
	Description:     pulumi.String("string"),
	KmsConfig:       pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	LdapEnabled: pulumi.Bool(false),
	Name:        pulumi.String("string"),
	Project:     pulumi.String("string"),
})

    var storagePoolResource = new StoragePool("storagePoolResource", StoragePoolArgs.builder()
    .capacityGib("string")
    .location("string")
    .network("string")
    .serviceLevel("string")
    .activeDirectory("string")
    .description("string")
    .kmsConfig("string")
    .labels(Map.of("string", "string"))
    .ldapEnabled(false)
    .name("string")
    .project("string")
    .build());

    storage_pool_resource = gcp.netapp.StoragePool("storagePoolResource",
    capacity_gib="string",
    location="string",
    network="string",
    service_level="string",
    active_directory="string",
    description="string",
    kms_config="string",
    labels={
        "string": "string",
    },
    ldap_enabled=False,
    name="string",
    project="string")

    const storagePoolResource = new gcp.netapp.StoragePool("storagePoolResource", {
    capacityGib: "string",
    location: "string",
    network: "string",
    serviceLevel: "string",
    activeDirectory: "string",
    description: "string",
    kmsConfig: "string",
    labels: {
        string: "string",
    },
    ldapEnabled: false,
    name: "string",
    project: "string",
});

    type: gcp:netapp:StoragePool
properties:
    activeDirectory: string
    capacityGib: string
    description: string
    kmsConfig: string
    labels:
        string: string
    ldapEnabled: false
    location: string
    name: string
    network: string
    project: string
    serviceLevel: string

    StoragePool Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The StoragePool resource accepts the following input properties:

    CapacityGib string
    Capacity of the storage pool (in GiB).
    Location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    Network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    ServiceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    ActiveDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    Description string
    An optional description of this resource.
    KmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    Labels Dictionary<string, string>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    LdapEnabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    Name string
    The resource name of the storage pool. Needs to be unique per location.

    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    CapacityGib string
    Capacity of the storage pool (in GiB).
    Location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    Network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    ServiceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    ActiveDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    Description string
    An optional description of this resource.
    KmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    Labels map[string]string

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    LdapEnabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    Name string
    The resource name of the storage pool. Needs to be unique per location.

    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    capacityGib String
    Capacity of the storage pool (in GiB).
    location String
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    network String
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    serviceLevel String
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    activeDirectory String
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    description String
    An optional description of this resource.
    kmsConfig String
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Map<String,String>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled Boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    name String
    The resource name of the storage pool. Needs to be unique per location.

    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    capacityGib string
    Capacity of the storage pool (in GiB).
    location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    serviceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    activeDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    description string
    An optional description of this resource.
    kmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels {[key: string]: string}

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    name string
    The resource name of the storage pool. Needs to be unique per location.

    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    capacity_gib str
    Capacity of the storage pool (in GiB).
    location str
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    network str
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    service_level str
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    active_directory str
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    description str
    An optional description of this resource.
    kms_config str
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Mapping[str, str]

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldap_enabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    name str
    The resource name of the storage pool. Needs to be unique per location.

    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    capacityGib String
    Capacity of the storage pool (in GiB).
    location String
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    network String
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    serviceLevel String
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    activeDirectory String
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    description String
    An optional description of this resource.
    kmsConfig String
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Map<String>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled Boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    name String
    The resource name of the storage pool. Needs to be unique per location.

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

    Outputs

    All input properties are implicitly available as output properties. Additionally, the StoragePool resource produces the following output properties:

    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.
    EncryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    Id string
    The provider-assigned unique ID for this managed resource.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    VolumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    VolumeCount int
    Number of volume in the storage pool.
    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.
    EncryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    Id string
    The provider-assigned unique ID for this managed resource.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    VolumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    VolumeCount int
    Number of volume in the storage pool.
    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.
    encryptionType String
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    id String
    The provider-assigned unique ID for this managed resource.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    volumeCapacityGib String
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount Integer
    Number of volume in the storage pool.
    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.
    encryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    id string
    The provider-assigned unique ID for this managed resource.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    volumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount number
    Number of volume in the storage pool.
    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.
    encryption_type str
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    id str
    The provider-assigned unique ID for this managed resource.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    volume_capacity_gib str
    Size allocated to volumes in the storage pool (in GiB).
    volume_count int
    Number of volume in the storage pool.
    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.
    encryptionType String
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    id String
    The provider-assigned unique ID for this managed resource.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    volumeCapacityGib String
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount Number
    Number of volume in the storage pool.

    Look up Existing StoragePool Resource

    Get an existing StoragePool 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?: StoragePoolState, opts?: CustomResourceOptions): StoragePool
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        active_directory: Optional[str] = None,
        capacity_gib: Optional[str] = None,
        description: Optional[str] = None,
        effective_labels: Optional[Mapping[str, str]] = None,
        encryption_type: Optional[str] = None,
        kms_config: Optional[str] = None,
        labels: Optional[Mapping[str, str]] = None,
        ldap_enabled: Optional[bool] = None,
        location: Optional[str] = None,
        name: Optional[str] = None,
        network: Optional[str] = None,
        project: Optional[str] = None,
        pulumi_labels: Optional[Mapping[str, str]] = None,
        service_level: Optional[str] = None,
        volume_capacity_gib: Optional[str] = None,
        volume_count: Optional[int] = None) -> StoragePool
    func GetStoragePool(ctx *Context, name string, id IDInput, state *StoragePoolState, opts ...ResourceOption) (*StoragePool, error)
    public static StoragePool Get(string name, Input<string> id, StoragePoolState? state, CustomResourceOptions? opts = null)
    public static StoragePool get(String name, Output<String> id, StoragePoolState 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:
    ActiveDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    CapacityGib string
    Capacity of the storage pool (in GiB).
    Description string
    An optional description of this resource.
    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.
    EncryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    KmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    Labels Dictionary<string, string>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    LdapEnabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    Location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    Name string
    The resource name of the storage pool. Needs to be unique per location.

    Network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    ServiceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    VolumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    VolumeCount int
    Number of volume in the storage pool.
    ActiveDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    CapacityGib string
    Capacity of the storage pool (in GiB).
    Description string
    An optional description of this resource.
    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.
    EncryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    KmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    Labels map[string]string

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    LdapEnabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    Location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    Name string
    The resource name of the storage pool. Needs to be unique per location.

    Network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    ServiceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    VolumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    VolumeCount int
    Number of volume in the storage pool.
    activeDirectory String
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    capacityGib String
    Capacity of the storage pool (in GiB).
    description String
    An optional description of this resource.
    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.
    encryptionType String
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    kmsConfig String
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Map<String,String>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled Boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    location String
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    name String
    The resource name of the storage pool. Needs to be unique per location.

    network String
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    serviceLevel String
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    volumeCapacityGib String
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount Integer
    Number of volume in the storage pool.
    activeDirectory string
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    capacityGib string
    Capacity of the storage pool (in GiB).
    description string
    An optional description of this resource.
    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.
    encryptionType string
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    kmsConfig string
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels {[key: string]: string}

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    location string
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    name string
    The resource name of the storage pool. Needs to be unique per location.

    network string
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    serviceLevel string
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    volumeCapacityGib string
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount number
    Number of volume in the storage pool.
    active_directory str
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    capacity_gib str
    Capacity of the storage pool (in GiB).
    description str
    An optional description of this resource.
    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.
    encryption_type str
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    kms_config str
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Mapping[str, str]

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldap_enabled bool
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    location str
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    name str
    The resource name of the storage pool. Needs to be unique per location.

    network str
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    service_level str
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    volume_capacity_gib str
    Size allocated to volumes in the storage pool (in GiB).
    volume_count int
    Number of volume in the storage pool.
    activeDirectory String
    Specifies the Active Directory policy to be used. Format: projects/{{project}}/locations/{{location}}/activeDirectories/{{name}}. The policy needs to be in the same location as the storage pool.
    capacityGib String
    Capacity of the storage pool (in GiB).
    description String
    An optional description of this resource.
    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.
    encryptionType String
    Reports if volumes in the pool are encrypted using a Google-managed encryption key or CMEK.
    kmsConfig String
    Specifies the CMEK policy to be used for volume encryption. Format: projects/{{project}}/locations/{{location}}/kmsConfigs/{{name}}. The policy needs to be in the same location as the storage pool.
    labels Map<String>

    Labels as key value pairs. Example: { "owner": "Bob", "department": "finance", "purpose": "testing" }.

    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.

    ldapEnabled Boolean
    When enabled, the volumes uses Active Directory as LDAP name service for UID/GID lookups. Required to enable extended group support for NFSv3, using security identifiers for NFSv4.1 or principal names for kerberized NFSv4.1.
    location String
    Name of the location. Usually a region name, expect for some FLEX service level pools which require a zone name.
    name String
    The resource name of the storage pool. Needs to be unique per location.

    network String
    VPC network name with format: projects/{{project}}/global/networks/{{network}}
    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.
    serviceLevel String
    Service level of the storage pool. Possible values are: PREMIUM, EXTREME, STANDARD, FLEX.
    volumeCapacityGib String
    Size allocated to volumes in the storage pool (in GiB).
    volumeCount Number
    Number of volume in the storage pool.

    Import

    storagePool can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/storagePools/{{name}}

    • {{project}}/{{location}}/{{name}}

    • {{location}}/{{name}}

    When using the pulumi import command, storagePool can be imported using one of the formats above. For example:

    $ pulumi import gcp:netapp/storagePool:StoragePool default projects/{{project}}/locations/{{location}}/storagePools/{{name}}

    $ pulumi import gcp:netapp/storagePool:StoragePool default {{project}}/{{location}}/{{name}}

    $ pulumi import gcp:netapp/storagePool:StoragePool default {{location}}/{{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.
    gcp logo
    Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi
    pulumi/pulumi-gcp