pulumi-gcp-kotlin/com.pulumi.gcp.compute.kotlin/SubnetworkArgs

SubnetworkArgs

data class SubnetworkArgs(val description: Output<String>? = null, val ipCidrRange: Output<String>? = null, val ipv6AccessType: Output<String>? = null, val logConfig: Output<SubnetworkLogConfigArgs>? = null, val name: Output<String>? = null, val network: Output<String>? = null, val privateIpGoogleAccess: Output<Boolean>? = null, val privateIpv6GoogleAccess: Output<String>? = null, val project: Output<String>? = null, val purpose: Output<String>? = null, val region: Output<String>? = null, val role: Output<String>? = null, val secondaryIpRanges: Output<List<SubnetworkSecondaryIpRangeArgs>>? = null, val stackType: Output<String>? = null) : ConvertibleToJava<SubnetworkArgs>

A VPC network is a virtual version of the traditional physical networks that exist within and between physical data centers. A VPC network provides connectivity for your Compute Engine virtual machine (VM) instances, Container Engine containers, App Engine Flex services, and other network-related resources. Each GCP project contains one or more VPC networks. Each VPC network is a global entity spanning all GCP regions. This global VPC network allows VM instances and other resources to communicate with each other via internal, private IP addresses. Each VPC network is subdivided into subnets, and each subnet is contained within a single region. You can have more than one subnet in a region for a given VPC network. Each subnet has a contiguous private RFC1918 IP space. You create instances, containers, and the like in these subnets. When you create an instance, you must create it in a subnet, and the instance draws its internal IP address from that subnet. Virtual machine (VM) instances in a VPC network can communicate with instances in all other subnets of the same VPC network, regardless of region, using their RFC1918 private IP addresses. You can isolate portions of the network, even entire subnets, using firewall rules. To get more information about Subnetwork, see:

Example Usage

Subnetwork Basic

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.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.inputs.SubnetworkSecondaryIpRangeArgs;
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 custom_test = new Network("custom-test", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var network_with_private_secondary_ip_ranges = new Subnetwork("network-with-private-secondary-ip-ranges", SubnetworkArgs.builder()
            .ipCidrRange("10.2.0.0/16")
            .region("us-central1")
            .network(custom_test.id())
            .secondaryIpRanges(SubnetworkSecondaryIpRangeArgs.builder()
                .rangeName("tf-test-secondary-range-update1")
                .ipCidrRange("192.168.10.0/24")
                .build())
            .build());
    }
}
Content copied to clipboard

Subnetwork Logging Config

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.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.inputs.SubnetworkLogConfigArgs;
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 custom_test = new Network("custom-test", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var subnet_with_logging = new Subnetwork("subnet-with-logging", SubnetworkArgs.builder()
            .ipCidrRange("10.2.0.0/16")
            .region("us-central1")
            .network(custom_test.id())
            .logConfig(SubnetworkLogConfigArgs.builder()
                .aggregationInterval("INTERVAL_10_MIN")
                .flowSampling(0.5)
                .metadata("INCLUDE_ALL_METADATA")
                .build())
            .build());
    }
}
Content copied to clipboard

Subnetwork Internal L7lb

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.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
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 custom_test = new Network("custom-test", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var network_for_l7lb = new Subnetwork("network-for-l7lb", SubnetworkArgs.builder()
            .ipCidrRange("10.0.0.0/22")
            .region("us-central1")
            .purpose("REGIONAL_MANAGED_PROXY")
            .role("ACTIVE")
            .network(custom_test.id())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}
Content copied to clipboard

Subnetwork Ipv6

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.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
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 custom_test = new Network("custom-test", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .build());
        var subnetwork_ipv6 = new Subnetwork("subnetwork-ipv6", SubnetworkArgs.builder()
            .ipCidrRange("10.0.0.0/22")
            .region("us-west2")
            .stackType("IPV4_IPV6")
            .ipv6AccessType("EXTERNAL")
            .network(custom_test.id())
            .build());
    }
}
Content copied to clipboard

Subnetwork Internal Ipv6

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.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
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 custom_test = new Network("custom-test", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .enableUlaInternalIpv6(true)
            .build());
        var subnetwork_internal_ipv6 = new Subnetwork("subnetwork-internal-ipv6", SubnetworkArgs.builder()
            .ipCidrRange("10.0.0.0/22")
            .region("us-west2")
            .stackType("IPV4_IPV6")
            .ipv6AccessType("INTERNAL")
            .network(custom_test.id())
            .build());
    }
}
Content copied to clipboard

Import

Subnetwork can be imported using any of these accepted formats

$ pulumi import gcp:compute/subnetwork:Subnetwork default projects/{{project}}/regions/{{region}}/subnetworks/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/subnetwork:Subnetwork default {{project}}/{{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/subnetwork:Subnetwork default {{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/subnetwork:Subnetwork default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
fun SubnetworkArgs(description: Output<String>? = null, ipCidrRange: Output<String>? = null, ipv6AccessType: Output<String>? = null, logConfig: Output<SubnetworkLogConfigArgs>? = null, name: Output<String>? = null, network: Output<String>? = null, privateIpGoogleAccess: Output<Boolean>? = null, privateIpv6GoogleAccess: Output<String>? = null, project: Output<String>? = null, purpose: Output<String>? = null, region: Output<String>? = null, role: Output<String>? = null, secondaryIpRanges: Output<List<SubnetworkSecondaryIpRangeArgs>>? = null, stackType: Output<String>? = null)

Functions

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

Properties

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

An optional description of this resource. Provide this property when you create the resource. This field can be set only at resource creation time.

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

The range of internal addresses that are owned by this subnetwork. Provide this property when you create the subnetwork. For example, 10.0.0.0/8 or 192.168.0.0/16. Ranges must be unique and non-overlapping within a network. Only IPv4 is supported.

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

The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation or the first time the subnet is updated into IPV4_IPV6 dual stack. If the ipv6_type is EXTERNAL then this subnet cannot enable direct path. Possible values are: EXTERNAL, INTERNAL.

Link copied to clipboard
val logConfig: Output<SubnetworkLogConfigArgs>? = null

This field denotes the VPC flow logging options for this subnetwork. If logging is enabled, logs are exported to Cloud Logging. Flow logging isn't supported if the subnet purpose field is set to subnetwork is REGIONAL_MANAGED_PROXY or GLOBAL_MANAGED_PROXY. Structure is documented below.

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

The name of the resource, provided by the client when initially creating the resource. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.

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

The network this subnet belongs to. Only networks that are in the distributed mode can have subnetworks.

Link copied to clipboard
val privateIpGoogleAccess: Output<Boolean>? = null

When enabled, VMs in this subnetwork without external IP addresses can access Google APIs and services by using Private Google Access.

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

The private IPv6 google access type for the VMs in this subnet.

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 purpose: Output<String>? = null

The purpose of the resource. This field can be either PRIVATE_RFC_1918, REGIONAL_MANAGED_PROXY, GLOBAL_MANAGED_PROXY, or PRIVATE_SERVICE_CONNECT. A subnet with purpose set to REGIONAL_MANAGED_PROXY is a user-created subnetwork that is reserved for regional Envoy-based load balancers. A subnetwork in a given region with purpose set to GLOBAL_MANAGED_PROXY is a proxy-only subnet and is shared between all the cross-regional Envoy-based load balancers. A subnetwork with purpose set to PRIVATE_SERVICE_CONNECT reserves the subnet for hosting a Private Service Connect published service. Note that REGIONAL_MANAGED_PROXY is the preferred setting for all regional Envoy load balancers. If unspecified, the purpose defaults to PRIVATE_RFC_1918.

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

The GCP region for this subnetwork.

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

The role of subnetwork. Currently, this field is only used when purpose is REGIONAL_MANAGED_PROXY. The value can be set to ACTIVE or BACKUP. An ACTIVE subnetwork is one that is currently being used for Envoy-based load balancers in a region. A BACKUP subnetwork is one that is ready to be promoted to ACTIVE or is currently draining. Possible values are: ACTIVE, BACKUP.

Link copied to clipboard
val secondaryIpRanges: Output<List<SubnetworkSecondaryIpRangeArgs>>? = null

An array of configurations for secondary IP ranges for VM instances contained in this subnetwork. The primary IP of such VM must belong to the primary ipCidrRange of the subnetwork. The alias IPs may belong to either primary or secondary ranges. Structure is documented below.

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

The stack type for this subnet to identify whether the IPv6 feature is enabled or not. If not specified IPV4_ONLY will be used. Possible values are: IPV4_ONLY, IPV4_IPV6.