pulumi-gcp-kotlin/com.pulumi.gcp.networkconnectivity.kotlin/Spoke

Spoke

class Spoke : KotlinCustomResource

The NetworkConnectivity Spoke resource To get more information about Spoke, see:

Example Usage

Network Connectivity Spoke Linked Vpc Network Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const network = new gcp.compute.Network("network", {
    name: "net",
    autoCreateSubnetworks: false,
});
const basicHub = new gcp.networkconnectivity.Hub("basic_hub", {
    name: "hub1",
    description: "A sample hub",
    labels: {
        "label-two": "value-one",
    },
});
const primary = new gcp.networkconnectivity.Spoke("primary", {
    name: "spoke1",
    location: "global",
    description: "A sample spoke with a linked router appliance instance",
    labels: {
        "label-one": "value-one",
    },
    hub: basicHub.id,
    linkedVpcNetwork: {
        excludeExportRanges: [
            "198.51.100.0/24",
            "10.10.0.0/16",
        ],
        uri: network.selfLink,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
network = gcp.compute.Network("network",
    name="net",
    auto_create_subnetworks=False)
basic_hub = gcp.networkconnectivity.Hub("basic_hub",
    name="hub1",
    description="A sample hub",
    labels={
        "label-two": "value-one",
    })
primary = gcp.networkconnectivity.Spoke("primary",
    name="spoke1",
    location="global",
    description="A sample spoke with a linked router appliance instance",
    labels={
        "label-one": "value-one",
    },
    hub=basic_hub.id,
    linked_vpc_network={
        "exclude_export_ranges": [
            "198.51.100.0/24",
            "10.10.0.0/16",
        ],
        "uri": network.self_link,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var network = new Gcp.Compute.Network("network", new()
    {
        Name = "net",
        AutoCreateSubnetworks = false,
    });
    var basicHub = new Gcp.NetworkConnectivity.Hub("basic_hub", new()
    {
        Name = "hub1",
        Description = "A sample hub",
        Labels =
        {
            { "label-two", "value-one" },
        },
    });
    var primary = new Gcp.NetworkConnectivity.Spoke("primary", new()
    {
        Name = "spoke1",
        Location = "global",
        Description = "A sample spoke with a linked router appliance instance",
        Labels =
        {
            { "label-one", "value-one" },
        },
        Hub = basicHub.Id,
        LinkedVpcNetwork = new Gcp.NetworkConnectivity.Inputs.SpokeLinkedVpcNetworkArgs
        {
            ExcludeExportRanges = new[]
            {
                "198.51.100.0/24",
                "10.10.0.0/16",
            },
            Uri = network.SelfLink,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
			Name:                  pulumi.String("net"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		basicHub, err := networkconnectivity.NewHub(ctx, "basic_hub", &networkconnectivity.HubArgs{
			Name:        pulumi.String("hub1"),
			Description: pulumi.String("A sample hub"),
			Labels: pulumi.StringMap{
				"label-two": pulumi.String("value-one"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkconnectivity.NewSpoke(ctx, "primary", &networkconnectivity.SpokeArgs{
			Name:        pulumi.String("spoke1"),
			Location:    pulumi.String("global"),
			Description: pulumi.String("A sample spoke with a linked router appliance instance"),
			Labels: pulumi.StringMap{
				"label-one": pulumi.String("value-one"),
			},
			Hub: basicHub.ID(),
			LinkedVpcNetwork: &networkconnectivity.SpokeLinkedVpcNetworkArgs{
				ExcludeExportRanges: pulumi.StringArray{
					pulumi.String("198.51.100.0/24"),
					pulumi.String("10.10.0.0/16"),
				},
				Uri: network.SelfLink,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.networkconnectivity.Hub;
import com.pulumi.gcp.networkconnectivity.HubArgs;
import com.pulumi.gcp.networkconnectivity.Spoke;
import com.pulumi.gcp.networkconnectivity.SpokeArgs;
import com.pulumi.gcp.networkconnectivity.inputs.SpokeLinkedVpcNetworkArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var network = new Network("network", NetworkArgs.builder()
            .name("net")
            .autoCreateSubnetworks(false)
            .build());
        var basicHub = new Hub("basicHub", HubArgs.builder()
            .name("hub1")
            .description("A sample hub")
            .labels(Map.of("label-two", "value-one"))
            .build());
        var primary = new Spoke("primary", SpokeArgs.builder()
            .name("spoke1")
            .location("global")
            .description("A sample spoke with a linked router appliance instance")
            .labels(Map.of("label-one", "value-one"))
            .hub(basicHub.id())
            .linkedVpcNetwork(SpokeLinkedVpcNetworkArgs.builder()
                .excludeExportRanges(
                    "198.51.100.0/24",
                    "10.10.0.0/16")
                .uri(network.selfLink())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  network:
    type: gcp:compute:Network
    properties:
      name: net
      autoCreateSubnetworks: false
  basicHub:
    type: gcp:networkconnectivity:Hub
    name: basic_hub
    properties:
      name: hub1
      description: A sample hub
      labels:
        label-two: value-one
  primary:
    type: gcp:networkconnectivity:Spoke
    properties:
      name: spoke1
      location: global
      description: A sample spoke with a linked router appliance instance
      labels:
        label-one: value-one
      hub: ${basicHub.id}
      linkedVpcNetwork:
        excludeExportRanges:
          - 198.51.100.0/24
          - 10.10.0.0/16
        uri: ${network.selfLink}
Content copied to clipboard

Network Connectivity Spoke Router Appliance Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const network = new gcp.compute.Network("network", {
    name: "tf-test-network_2067",
    autoCreateSubnetworks: false,
});
const subnetwork = new gcp.compute.Subnetwork("subnetwork", {
    name: "tf-test-subnet_40785",
    ipCidrRange: "10.0.0.0/28",
    region: "us-central1",
    network: network.selfLink,
});
const instance = new gcp.compute.Instance("instance", {
    name: "tf-test-instance_79169",
    machineType: "e2-medium",
    canIpForward: true,
    zone: "us-central1-a",
    bootDisk: {
        initializeParams: {
            image: "projects/debian-cloud/global/images/debian-10-buster-v20210817",
        },
    },
    networkInterfaces: [{
        subnetwork: subnetwork.name,
        networkIp: "10.0.0.2",
        accessConfigs: [{
            networkTier: "PREMIUM",
        }],
    }],
});
const basicHub = new gcp.networkconnectivity.Hub("basic_hub", {
    name: "tf-test-hub_56529",
    description: "A sample hub",
    labels: {
        "label-two": "value-one",
    },
});
const primary = new gcp.networkconnectivity.Spoke("primary", {
    name: "tf-test-name_75413",
    location: "us-central1",
    description: "A sample spoke with a linked routher appliance instance",
    labels: {
        "label-one": "value-one",
    },
    hub: basicHub.id,
    linkedRouterApplianceInstances: {
        instances: [{
            virtualMachine: instance.selfLink,
            ipAddress: "10.0.0.2",
        }],
        siteToSiteDataTransfer: true,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
network = gcp.compute.Network("network",
    name="tf-test-network_2067",
    auto_create_subnetworks=False)
subnetwork = gcp.compute.Subnetwork("subnetwork",
    name="tf-test-subnet_40785",
    ip_cidr_range="10.0.0.0/28",
    region="us-central1",
    network=network.self_link)
instance = gcp.compute.Instance("instance",
    name="tf-test-instance_79169",
    machine_type="e2-medium",
    can_ip_forward=True,
    zone="us-central1-a",
    boot_disk={
        "initialize_params": {
            "image": "projects/debian-cloud/global/images/debian-10-buster-v20210817",
        },
    },
    network_interfaces=[{
        "subnetwork": subnetwork.name,
        "network_ip": "10.0.0.2",
        "access_configs": [{
            "network_tier": "PREMIUM",
        }],
    }])
basic_hub = gcp.networkconnectivity.Hub("basic_hub",
    name="tf-test-hub_56529",
    description="A sample hub",
    labels={
        "label-two": "value-one",
    })
primary = gcp.networkconnectivity.Spoke("primary",
    name="tf-test-name_75413",
    location="us-central1",
    description="A sample spoke with a linked routher appliance instance",
    labels={
        "label-one": "value-one",
    },
    hub=basic_hub.id,
    linked_router_appliance_instances={
        "instances": [{
            "virtual_machine": instance.self_link,
            "ip_address": "10.0.0.2",
        }],
        "site_to_site_data_transfer": True,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var network = new Gcp.Compute.Network("network", new()
    {
        Name = "tf-test-network_2067",
        AutoCreateSubnetworks = false,
    });
    var subnetwork = new Gcp.Compute.Subnetwork("subnetwork", new()
    {
        Name = "tf-test-subnet_40785",
        IpCidrRange = "10.0.0.0/28",
        Region = "us-central1",
        Network = network.SelfLink,
    });
    var instance = new Gcp.Compute.Instance("instance", new()
    {
        Name = "tf-test-instance_79169",
        MachineType = "e2-medium",
        CanIpForward = true,
        Zone = "us-central1-a",
        BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
        {
            InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
            {
                Image = "projects/debian-cloud/global/images/debian-10-buster-v20210817",
            },
        },
        NetworkInterfaces = new[]
        {
            new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
            {
                Subnetwork = subnetwork.Name,
                NetworkIp = "10.0.0.2",
                AccessConfigs = new[]
                {
                    new Gcp.Compute.Inputs.InstanceNetworkInterfaceAccessConfigArgs
                    {
                        NetworkTier = "PREMIUM",
                    },
                },
            },
        },
    });
    var basicHub = new Gcp.NetworkConnectivity.Hub("basic_hub", new()
    {
        Name = "tf-test-hub_56529",
        Description = "A sample hub",
        Labels =
        {
            { "label-two", "value-one" },
        },
    });
    var primary = new Gcp.NetworkConnectivity.Spoke("primary", new()
    {
        Name = "tf-test-name_75413",
        Location = "us-central1",
        Description = "A sample spoke with a linked routher appliance instance",
        Labels =
        {
            { "label-one", "value-one" },
        },
        Hub = basicHub.Id,
        LinkedRouterApplianceInstances = new Gcp.NetworkConnectivity.Inputs.SpokeLinkedRouterApplianceInstancesArgs
        {
            Instances = new[]
            {
                new Gcp.NetworkConnectivity.Inputs.SpokeLinkedRouterApplianceInstancesInstanceArgs
                {
                    VirtualMachine = instance.SelfLink,
                    IpAddress = "10.0.0.2",
                },
            },
            SiteToSiteDataTransfer = true,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/networkconnectivity"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
			Name:                  pulumi.String("tf-test-network_2067"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		subnetwork, err := compute.NewSubnetwork(ctx, "subnetwork", &compute.SubnetworkArgs{
			Name:        pulumi.String("tf-test-subnet_40785"),
			IpCidrRange: pulumi.String("10.0.0.0/28"),
			Region:      pulumi.String("us-central1"),
			Network:     network.SelfLink,
		})
		if err != nil {
			return err
		}
		instance, err := compute.NewInstance(ctx, "instance", &compute.InstanceArgs{
			Name:         pulumi.String("tf-test-instance_79169"),
			MachineType:  pulumi.String("e2-medium"),
			CanIpForward: pulumi.Bool(true),
			Zone:         pulumi.String("us-central1-a"),
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String("projects/debian-cloud/global/images/debian-10-buster-v20210817"),
				},
			},
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					Subnetwork: subnetwork.Name,
					NetworkIp:  pulumi.String("10.0.0.2"),
					AccessConfigs: compute.InstanceNetworkInterfaceAccessConfigArray{
						&compute.InstanceNetworkInterfaceAccessConfigArgs{
							NetworkTier: pulumi.String("PREMIUM"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		basicHub, err := networkconnectivity.NewHub(ctx, "basic_hub", &networkconnectivity.HubArgs{
			Name:        pulumi.String("tf-test-hub_56529"),
			Description: pulumi.String("A sample hub"),
			Labels: pulumi.StringMap{
				"label-two": pulumi.String("value-one"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkconnectivity.NewSpoke(ctx, "primary", &networkconnectivity.SpokeArgs{
			Name:        pulumi.String("tf-test-name_75413"),
			Location:    pulumi.String("us-central1"),
			Description: pulumi.String("A sample spoke with a linked routher appliance instance"),
			Labels: pulumi.StringMap{
				"label-one": pulumi.String("value-one"),
			},
			Hub: basicHub.ID(),
			LinkedRouterApplianceInstances: &networkconnectivity.SpokeLinkedRouterApplianceInstancesArgs{
				Instances: networkconnectivity.SpokeLinkedRouterApplianceInstancesInstanceArray{
					&networkconnectivity.SpokeLinkedRouterApplianceInstancesInstanceArgs{
						VirtualMachine: instance.SelfLink,
						IpAddress:      pulumi.String("10.0.0.2"),
					},
				},
				SiteToSiteDataTransfer: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.networkconnectivity.Hub;
import com.pulumi.gcp.networkconnectivity.HubArgs;
import com.pulumi.gcp.networkconnectivity.Spoke;
import com.pulumi.gcp.networkconnectivity.SpokeArgs;
import com.pulumi.gcp.networkconnectivity.inputs.SpokeLinkedRouterApplianceInstancesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var network = new Network("network", NetworkArgs.builder()
            .name("tf-test-network_2067")
            .autoCreateSubnetworks(false)
            .build());
        var subnetwork = new Subnetwork("subnetwork", SubnetworkArgs.builder()
            .name("tf-test-subnet_40785")
            .ipCidrRange("10.0.0.0/28")
            .region("us-central1")
            .network(network.selfLink())
            .build());
        var instance = new Instance("instance", InstanceArgs.builder()
            .name("tf-test-instance_79169")
            .machineType("e2-medium")
            .canIpForward(true)
            .zone("us-central1-a")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image("projects/debian-cloud/global/images/debian-10-buster-v20210817")
                    .build())
                .build())
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .subnetwork(subnetwork.name())
                .networkIp("10.0.0.2")
                .accessConfigs(InstanceNetworkInterfaceAccessConfigArgs.builder()
                    .networkTier("PREMIUM")
                    .build())
                .build())
            .build());
        var basicHub = new Hub("basicHub", HubArgs.builder()
            .name("tf-test-hub_56529")
            .description("A sample hub")
            .labels(Map.of("label-two", "value-one"))
            .build());
        var primary = new Spoke("primary", SpokeArgs.builder()
            .name("tf-test-name_75413")
            .location("us-central1")
            .description("A sample spoke with a linked routher appliance instance")
            .labels(Map.of("label-one", "value-one"))
            .hub(basicHub.id())
            .linkedRouterApplianceInstances(SpokeLinkedRouterApplianceInstancesArgs.builder()
                .instances(SpokeLinkedRouterApplianceInstancesInstanceArgs.builder()
                    .virtualMachine(instance.selfLink())
                    .ipAddress("10.0.0.2")
                    .build())
                .siteToSiteDataTransfer(true)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  network:
    type: gcp:compute:Network
    properties:
      name: tf-test-network_2067
      autoCreateSubnetworks: false
  subnetwork:
    type: gcp:compute:Subnetwork
    properties:
      name: tf-test-subnet_40785
      ipCidrRange: 10.0.0.0/28
      region: us-central1
      network: ${network.selfLink}
  instance:
    type: gcp:compute:Instance
    properties:
      name: tf-test-instance_79169
      machineType: e2-medium
      canIpForward: true
      zone: us-central1-a
      bootDisk:
        initializeParams:
          image: projects/debian-cloud/global/images/debian-10-buster-v20210817
      networkInterfaces:
        - subnetwork: ${subnetwork.name}
          networkIp: 10.0.0.2
          accessConfigs:
            - networkTier: PREMIUM
  basicHub:
    type: gcp:networkconnectivity:Hub
    name: basic_hub
    properties:
      name: tf-test-hub_56529
      description: A sample hub
      labels:
        label-two: value-one
  primary:
    type: gcp:networkconnectivity:Spoke
    properties:
      name: tf-test-name_75413
      location: us-central1
      description: A sample spoke with a linked routher appliance instance
      labels:
        label-one: value-one
      hub: ${basicHub.id}
      linkedRouterApplianceInstances:
        instances:
          - virtualMachine: ${instance.selfLink}
            ipAddress: 10.0.0.2
        siteToSiteDataTransfer: true
Content copied to clipboard

Import

Spoke can be imported using any of these accepted formats:

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

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

  • {{location}}/{{name}} When using the pulumi import command, Spoke can be imported using one of the formats above. For example:

$ pulumi import gcp:networkconnectivity/spoke:Spoke default projects/{{project}}/locations/{{location}}/spokes/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkconnectivity/spoke:Spoke default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkconnectivity/spoke:Spoke default {{location}}/{{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val createTime: Output<String>

Output only. The time the spoke was created.

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

An optional description of the spoke.

Link copied to clipboard
val effectiveLabels: Output<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.

Link copied to clipboard
val hub: Output<String>

Immutable. The URI of the hub that this spoke is attached to.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

Optional labels in key:value format. For more information about labels, see Requirements for labels. 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.

Link copied to clipboard
val linkedInterconnectAttachments: Output<SpokeLinkedInterconnectAttachments>?

A collection of VLAN attachment resources. These resources should be redundant attachments that all advertise the same prefixes to Google Cloud. Alternatively, in active/passive configurations, all attachments should be capable of advertising the same prefixes. Structure is documented below.

Link copied to clipboard
val linkedRouterApplianceInstances: Output<SpokeLinkedRouterApplianceInstances>?

The URIs of linked Router appliance resources Structure is documented below.

Link copied to clipboard
val linkedVpcNetwork: Output<SpokeLinkedVpcNetwork>?

VPC network that is associated with the spoke. Structure is documented below.

Link copied to clipboard
val linkedVpnTunnels: Output<SpokeLinkedVpnTunnels>?

The URIs of linked VPN tunnel resources Structure is documented below.

Link copied to clipboard
val location: Output<String>

The location for the resource

Link copied to clipboard
val name: Output<String>

Immutable. The name of the spoke. Spoke names must be unique.

Link copied to clipboard
val project: Output<String>

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 pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val state: Output<String>

Output only. The current lifecycle state of this spoke.

Link copied to clipboard
val uniqueId: Output<String>

Output only. The Google-generated UUID for the spoke. This value is unique across all spoke resources. If a spoke is deleted and another with the same name is created, the new spoke is assigned a different unique_id.

Link copied to clipboard
val updateTime: Output<String>

Output only. The time the spoke was last updated.

Link copied to clipboard
val urn: Output<String>