StoragePoolArgs

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)

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 main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/netapp"
	"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 {
		// 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
		_default, 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
	})
}

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}

$ 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}}