Network class

Manages a VPC network or legacy network resource on GCP.

To get more information about Network, see:

Example Usage

Network Basic

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {name: "vpc-network"});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network", name="vpc-network")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Name = "vpc-network",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Name: pulumi.String("vpc-network"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  name = "vpc-network"
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .name("vpc-network")
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      name: vpc-network

Network Custom Mtu

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    project: "my-project-name",
    name: "vpc-network",
    autoCreateSubnetworks: true,
    mtu: 1460,
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    project="my-project-name",
    name="vpc-network",
    auto_create_subnetworks=True,
    mtu=1460)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Project = "my-project-name",
        Name = "vpc-network",
        AutoCreateSubnetworks = true,
        Mtu = 1460,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Project:               pulumi.String("my-project-name"),
			Name:                  pulumi.String("vpc-network"),
			AutoCreateSubnetworks: pulumi.Bool(true),
			Mtu:                   pulumi.Int(1460),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  project                 = "my-project-name"
  name                    = "vpc-network"
  auto_create_subnetworks = true
  mtu                     = 1460
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .project("my-project-name")
            .name("vpc-network")
            .autoCreateSubnetworks(true)
            .mtu(1460)
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      project: my-project-name
      name: vpc-network
      autoCreateSubnetworks: true
      mtu: 1460

Network Custom Firewall Enforcement Order

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    project: "my-project-name",
    name: "vpc-network",
    autoCreateSubnetworks: true,
    networkFirewallPolicyEnforcementOrder: "BEFORE_CLASSIC_FIREWALL",
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    project="my-project-name",
    name="vpc-network",
    auto_create_subnetworks=True,
    network_firewall_policy_enforcement_order="BEFORE_CLASSIC_FIREWALL")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Project = "my-project-name",
        Name = "vpc-network",
        AutoCreateSubnetworks = true,
        NetworkFirewallPolicyEnforcementOrder = "BEFORE_CLASSIC_FIREWALL",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Project:                               pulumi.String("my-project-name"),
			Name:                                  pulumi.String("vpc-network"),
			AutoCreateSubnetworks:                 pulumi.Bool(true),
			NetworkFirewallPolicyEnforcementOrder: pulumi.String("BEFORE_CLASSIC_FIREWALL"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  project                                   = "my-project-name"
  name                                      = "vpc-network"
  auto_create_subnetworks                   = true
  network_firewall_policy_enforcement_order = "BEFORE_CLASSIC_FIREWALL"
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .project("my-project-name")
            .name("vpc-network")
            .autoCreateSubnetworks(true)
            .networkFirewallPolicyEnforcementOrder("BEFORE_CLASSIC_FIREWALL")
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      project: my-project-name
      name: vpc-network
      autoCreateSubnetworks: true
      networkFirewallPolicyEnforcementOrder: BEFORE_CLASSIC_FIREWALL

Network Bgp Best Path Selection Mode

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    project: "my-project-name",
    name: "vpc-network",
    routingMode: "GLOBAL",
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    project="my-project-name",
    name="vpc-network",
    routing_mode="GLOBAL")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Project = "my-project-name",
        Name = "vpc-network",
        RoutingMode = "GLOBAL",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Project:     pulumi.String("my-project-name"),
			Name:        pulumi.String("vpc-network"),
			RoutingMode: pulumi.String("GLOBAL"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  project      = "my-project-name"
  name         = "vpc-network"
  routing_mode = "GLOBAL"
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .project("my-project-name")
            .name("vpc-network")
            .routingMode("GLOBAL")
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      project: my-project-name
      name: vpc-network
      routingMode: GLOBAL

Network Bgp Best Path Selection Mode Standard

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    project: "my-project-name",
    name: "vpc-network",
    routingMode: "GLOBAL",
    bgpBestPathSelectionMode: "STANDARD",
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    project="my-project-name",
    name="vpc-network",
    routing_mode="GLOBAL",
    bgp_best_path_selection_mode="STANDARD")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Project = "my-project-name",
        Name = "vpc-network",
        RoutingMode = "GLOBAL",
        BgpBestPathSelectionMode = "STANDARD",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Project:                  pulumi.String("my-project-name"),
			Name:                     pulumi.String("vpc-network"),
			RoutingMode:              pulumi.String("GLOBAL"),
			BgpBestPathSelectionMode: pulumi.String("STANDARD"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  project                      = "my-project-name"
  name                         = "vpc-network"
  routing_mode                 = "GLOBAL"
  bgp_best_path_selection_mode = "STANDARD"
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .project("my-project-name")
            .name("vpc-network")
            .routingMode("GLOBAL")
            .bgpBestPathSelectionMode("STANDARD")
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      project: my-project-name
      name: vpc-network
      routingMode: GLOBAL
      bgpBestPathSelectionMode: STANDARD

Network Bgp Best Path Selection Mode Standard Custom Fields

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    project: "my-project-name",
    name: "vpc-network",
    routingMode: "GLOBAL",
    bgpBestPathSelectionMode: "STANDARD",
    bgpAlwaysCompareMed: true,
    bgpInterRegionCost: "ADD_COST_TO_MED",
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    project="my-project-name",
    name="vpc-network",
    routing_mode="GLOBAL",
    bgp_best_path_selection_mode="STANDARD",
    bgp_always_compare_med=True,
    bgp_inter_region_cost="ADD_COST_TO_MED")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Project = "my-project-name",
        Name = "vpc-network",
        RoutingMode = "GLOBAL",
        BgpBestPathSelectionMode = "STANDARD",
        BgpAlwaysCompareMed = true,
        BgpInterRegionCost = "ADD_COST_TO_MED",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Project:                  pulumi.String("my-project-name"),
			Name:                     pulumi.String("vpc-network"),
			RoutingMode:              pulumi.String("GLOBAL"),
			BgpBestPathSelectionMode: pulumi.String("STANDARD"),
			BgpAlwaysCompareMed:      pulumi.Bool(true),
			BgpInterRegionCost:       pulumi.String("ADD_COST_TO_MED"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  project                      = "my-project-name"
  name                         = "vpc-network"
  routing_mode                 = "GLOBAL"
  bgp_best_path_selection_mode = "STANDARD"
  bgp_always_compare_med       = true
  bgp_inter_region_cost        = "ADD_COST_TO_MED"
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .project("my-project-name")
            .name("vpc-network")
            .routingMode("GLOBAL")
            .bgpBestPathSelectionMode("STANDARD")
            .bgpAlwaysCompareMed(true)
            .bgpInterRegionCost("ADD_COST_TO_MED")
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      project: my-project-name
      name: vpc-network
      routingMode: GLOBAL
      bgpBestPathSelectionMode: STANDARD
      bgpAlwaysCompareMed: true
      bgpInterRegionCost: ADD_COST_TO_MED

Network Bgp Standard Mode Delete Med

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

const vpcNetwork = new gcp.compute.Network("vpc_network", {
    name: "vpc-network",
    autoCreateSubnetworks: false,
    routingMode: "GLOBAL",
    project: "my-project-name",
    bgpBestPathSelectionMode: "LEGACY",
    bgpAlwaysCompareMed: false,
    deleteBgpAlwaysCompareMed: true,
});

import pulumi
import pulumi_gcp as gcp

vpc_network = gcp.compute.Network("vpc_network",
    name="vpc-network",
    auto_create_subnetworks=False,
    routing_mode="GLOBAL",
    project="my-project-name",
    bgp_best_path_selection_mode="LEGACY",
    bgp_always_compare_med=False,
    delete_bgp_always_compare_med=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() =>
{
    var vpcNetwork = new Gcp.Compute.Network("vpc_network", new()
    {
        Name = "vpc-network",
        AutoCreateSubnetworks = false,
        RoutingMode = "GLOBAL",
        Project = "my-project-name",
        BgpBestPathSelectionMode = "LEGACY",
        BgpAlwaysCompareMed = false,
        DeleteBgpAlwaysCompareMed = true,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewNetwork(ctx, "vpc_network", &compute.NetworkArgs{
			Name:                      pulumi.String("vpc-network"),
			AutoCreateSubnetworks:     pulumi.Bool(false),
			RoutingMode:               pulumi.String("GLOBAL"),
			Project:                   pulumi.String("my-project-name"),
			BgpBestPathSelectionMode:  pulumi.String("LEGACY"),
			BgpAlwaysCompareMed:       pulumi.Bool(false),
			DeleteBgpAlwaysCompareMed: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_network" "vpc_network" {
  name                         = "vpc-network"
  auto_create_subnetworks      = false
  routing_mode                 = "GLOBAL"
  project                      = "my-project-name"
  bgp_best_path_selection_mode = "LEGACY"
  bgp_always_compare_med       = false
  # By setting this to true, any previous value for bgp_always_compare_med
  # will be cleared, reverting it to the API default.
  delete_bgp_always_compare_med = true
}

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 java.util.ArrayList;
import java.util.Arrays;
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 vpcNetwork = new Network("vpcNetwork", NetworkArgs.builder()
            .name("vpc-network")
            .autoCreateSubnetworks(false)
            .routingMode("GLOBAL")
            .project("my-project-name")
            .bgpBestPathSelectionMode("LEGACY")
            .bgpAlwaysCompareMed(false)
            .deleteBgpAlwaysCompareMed(true)
            .build());

    }
}

resources:
  vpcNetwork:
    type: gcp:compute:Network
    name: vpc_network
    properties:
      name: vpc-network
      autoCreateSubnetworks: false
      routingMode: GLOBAL
      project: my-project-name
      bgpBestPathSelectionMode: LEGACY
      bgpAlwaysCompareMed: false # By setting this to true, any previous value for bgp_always_compare_med
      #   # will be cleared, reverting it to the API default.
      deleteBgpAlwaysCompareMed: true

Import

Network can be imported using any of these accepted formats:

  • projects/{{project}}/global/networks/{{name}}
  • {{project}}/{{name}}
  • {{name}}

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

$ pulumi import gcp:compute/network:Network default projects/{{project}}/global/networks/{{name}}
$ pulumi import gcp:compute/network:Network default {{project}}/{{name}}
$ pulumi import gcp:compute/network:Network default {{name}}

Constructors

Network(String name, {NetworkArgs? args, CustomResourceOptions? options})
Creates a new Network. name The Pulumi resource name. args Arguments used to configure this Network. The set of arguments for Network. options Resource options controlling this resource's behavior.
Network.reference(String urn)
Creates a typed reference to an existing Network resource.

Properties

autoCreateSubnetworks ↔ Output<bool?>
When set to true, the network is created in "auto subnet mode" and it will create a subnet for each region automatically across the 10.128.0.0/9 address range. When set to false, the network is created in "custom subnet mode" so the user can explicitly connect subnetwork resources.
latefinal
bgpAlwaysCompareMed ↔ Output<bool>
Enables/disables the comparison of MED across routes with different Neighbor ASNs. This value can only be set if the --bgp-best-path-selection-mode is STANDARD
latefinal
bgpBestPathSelectionMode ↔ Output<String>
The BGP best selection algorithm to be employed. MODE can be LEGACY or STANDARD. Possible values are: LEGACY, STANDARD.
latefinal
bgpInterRegionCost ↔ Output<String>
Choice of the behavior of inter-regional cost and MED in the BPS algorithm. Possible values are: DEFAULT, ADD_COST_TO_MED.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
deleteBgpAlwaysCompareMed ↔ Output<bool?>
If set to true, the bgpAlwaysCompareMed field will be cleared. If set to false (the default), bgpAlwaysCompareMed will be set to the value specified in the configuration.
latefinal
deleteDefaultRoutesOnCreate ↔ Output<bool?>
If set to true, default routes (0.0.0.0/0) will be deleted immediately after network creation. Defaults to false.
latefinal
deletionPolicy ↔ Output<String>
Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
latefinal
description ↔ Output<String?>
An optional description of this resource. The resource must be recreated to modify this field.
latefinal
enableUlaInternalIpv6 ↔ Output<bool?>
Enable ULA internal ipv6 on this network. Enabling this feature will assign a /48 from google defined ULA prefix fd20::/20.
latefinal
gatewayIpv4 ↔ Output<String>
The gateway address for default routing out of the network. This value is selected by GCP.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
internalIpv6Range ↔ Output<String>
When enabling ula internal ipv6, caller optionally can specify the /48 range they want from the google defined ULA prefix fd20::/20. The input must be a valid /48 ULA IPv6 address and must be within the fd20::/20. Operation will fail if the speficied /48 is already in used by another resource. If the field is not speficied, then a /48 range will be randomly allocated from fd20::/20 and returned via this field.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
mtu ↔ Output<int>
Maximum Transmission Unit in bytes. The default value is 1460 bytes. The minimum value for this field is 1300 and the maximum value is 8896 bytes (jumbo frames). Note that packets larger than 1500 bytes (standard Ethernet) can be subject to TCP-MSS clamping or dropped with an ICMP Fragmentation-Needed message if the packets are routed to the Internet or other VPCs with varying MTUs.
latefinal
name ↔ Output<String>
Name of the resource. Provided by the client when the resource is created. 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.
latefinal
networkFirewallPolicyEnforcementOrder ↔ Output<String?>
Set the order that Firewall Rules and Firewall Policies are evaluated. Default value is AFTER_CLASSIC_FIREWALL. Possible values are: BEFORE_CLASSIC_FIREWALL, AFTER_CLASSIC_FIREWALL.
latefinal
networkId ↔ Output<String>
The unique identifier for the resource. This identifier is defined by the server.
latefinal
networkProfile ↔ Output<String?>
A full or partial URL of the network profile to apply to this network. This field can be set only at resource creation time. For example, the following are valid URLs:
latefinal
numericId ↔ Output<String>
(Deprecated) The unique identifier for the resource. This identifier is defined by the server.
latefinal
params ↔ Output<NetworkParams?>
Additional params passed with the request, but not persisted as part of resource payload Structure is documented below.
latefinal
project ↔ Output<String>
The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
routingMode ↔ Output<String>
The network-wide routing mode to use. If set to REGIONAL, this network's cloud routers will only advertise routes with subnetworks of this network in the same region as the router. If set to GLOBAL, this network's cloud routers will advertise routes with all subnetworks of this network, across regions. Possible values are: REGIONAL, GLOBAL.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
The URI of the created resource.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {NetworkState? state, CustomResourceOptions? options}) → Network
Gets an existing Network resource's state with the given name and id.