RouterPeer class
BGP information that must be configured into the routing stack to establish BGP peering. This information must specify the peer ASN and either the interface name, IP address, or peer IP address. Please refer to RFC4273.
To get more information about RouterBgpPeer, see:
- API documentation
- How-to Guides
- Google Cloud Router
Example Usage
Router Peer Basic
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: "my-router",
region: "us-central1",
peerAsn: 65513,
advertisedRoutePriority: 100,
"interface": "interface-1",
});
import pulumi
import pulumi_gcp as gcp
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router="my-router",
region="us-central1",
peer_asn=65513,
advertised_route_priority=100,
interface="interface-1")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = "my-router",
Region = "us-central1",
PeerAsn = 65513,
AdvertisedRoutePriority = 100,
Interface = "interface-1",
});
});
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.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: pulumi.String("my-router"),
Region: pulumi.String("us-central1"),
PeerAsn: pulumi.Int(65513),
AdvertisedRoutePriority: pulumi.Int(100),
Interface: pulumi.String("interface-1"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = "my-router"
region = "us-central1"
peer_asn = 65513
advertised_route_priority = 100
interface = "interface-1"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
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 peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router("my-router")
.region("us-central1")
.peerAsn(65513)
.advertisedRoutePriority(100)
.interface_("interface-1")
.build());
}
}
resources:
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: my-router
region: us-central1
peerAsn: 65513
advertisedRoutePriority: 100
interface: interface-1
Router Peer Disabled
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: "my-router",
region: "us-central1",
peerIpAddress: "169.254.1.2",
peerAsn: 65513,
advertisedRoutePriority: 100,
"interface": "interface-1",
enable: false,
});
import pulumi
import pulumi_gcp as gcp
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router="my-router",
region="us-central1",
peer_ip_address="169.254.1.2",
peer_asn=65513,
advertised_route_priority=100,
interface="interface-1",
enable=False)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = "my-router",
Region = "us-central1",
PeerIpAddress = "169.254.1.2",
PeerAsn = 65513,
AdvertisedRoutePriority = 100,
Interface = "interface-1",
Enable = false,
});
});
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.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: pulumi.String("my-router"),
Region: pulumi.String("us-central1"),
PeerIpAddress: pulumi.String("169.254.1.2"),
PeerAsn: pulumi.Int(65513),
AdvertisedRoutePriority: pulumi.Int(100),
Interface: pulumi.String("interface-1"),
Enable: pulumi.Bool(false),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = "my-router"
region = "us-central1"
peer_ip_address = "169.254.1.2"
peer_asn = 65513
advertised_route_priority = 100
interface = "interface-1"
enable = false
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
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 peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router("my-router")
.region("us-central1")
.peerIpAddress("169.254.1.2")
.peerAsn(65513)
.advertisedRoutePriority(100)
.interface_("interface-1")
.enable(false)
.build());
}
}
resources:
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: my-router
region: us-central1
peerIpAddress: 169.254.1.2
peerAsn: 65513
advertisedRoutePriority: 100
interface: interface-1
enable: false
Router Peer Bfd
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: "my-router",
region: "us-central1",
peerIpAddress: "169.254.1.2",
peerAsn: 65513,
advertisedRoutePriority: 100,
"interface": "interface-1",
bfd: {
minReceiveInterval: 1000,
minTransmitInterval: 1000,
multiplier: 5,
sessionInitializationMode: "ACTIVE",
},
});
import pulumi
import pulumi_gcp as gcp
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router="my-router",
region="us-central1",
peer_ip_address="169.254.1.2",
peer_asn=65513,
advertised_route_priority=100,
interface="interface-1",
bfd={
"min_receive_interval": 1000,
"min_transmit_interval": 1000,
"multiplier": 5,
"session_initialization_mode": "ACTIVE",
})
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = "my-router",
Region = "us-central1",
PeerIpAddress = "169.254.1.2",
PeerAsn = 65513,
AdvertisedRoutePriority = 100,
Interface = "interface-1",
Bfd = new Gcp.Compute.Inputs.RouterPeerBfdArgs
{
MinReceiveInterval = 1000,
MinTransmitInterval = 1000,
Multiplier = 5,
SessionInitializationMode = "ACTIVE",
},
});
});
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.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: pulumi.String("my-router"),
Region: pulumi.String("us-central1"),
PeerIpAddress: pulumi.String("169.254.1.2"),
PeerAsn: pulumi.Int(65513),
AdvertisedRoutePriority: pulumi.Int(100),
Interface: pulumi.String("interface-1"),
Bfd: &compute.RouterPeerBfdArgs{
MinReceiveInterval: pulumi.Int(1000),
MinTransmitInterval: pulumi.Int(1000),
Multiplier: pulumi.Int(5),
SessionInitializationMode: pulumi.String("ACTIVE"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = "my-router"
region = "us-central1"
peer_ip_address = "169.254.1.2"
peer_asn = 65513
advertised_route_priority = 100
interface = "interface-1"
bfd = {
min_receive_interval = 1000
min_transmit_interval = 1000
multiplier = 5
session_initialization_mode = "ACTIVE"
}
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
import com.pulumi.gcp.compute.inputs.RouterPeerBfdArgs;
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 peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router("my-router")
.region("us-central1")
.peerIpAddress("169.254.1.2")
.peerAsn(65513)
.advertisedRoutePriority(100)
.interface_("interface-1")
.bfd(RouterPeerBfdArgs.builder()
.minReceiveInterval(1000)
.minTransmitInterval(1000)
.multiplier(5)
.sessionInitializationMode("ACTIVE")
.build())
.build());
}
}
resources:
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: my-router
region: us-central1
peerIpAddress: 169.254.1.2
peerAsn: 65513
advertisedRoutePriority: 100
interface: interface-1
bfd:
minReceiveInterval: 1000
minTransmitInterval: 1000
multiplier: 5
sessionInitializationMode: ACTIVE
Router Zero Custom Learend Route Priority
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: "my-router",
region: "us-central1",
"interface": "interface-1",
peerAsn: 65513,
customLearnedRoutePriority: 0,
zeroCustomLearnedRoutePriority: true,
});
import pulumi
import pulumi_gcp as gcp
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router="my-router",
region="us-central1",
interface="interface-1",
peer_asn=65513,
custom_learned_route_priority=0,
zero_custom_learned_route_priority=True)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = "my-router",
Region = "us-central1",
Interface = "interface-1",
PeerAsn = 65513,
CustomLearnedRoutePriority = 0,
ZeroCustomLearnedRoutePriority = 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.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: pulumi.String("my-router"),
Region: pulumi.String("us-central1"),
Interface: pulumi.String("interface-1"),
PeerAsn: pulumi.Int(65513),
CustomLearnedRoutePriority: pulumi.Int(0),
ZeroCustomLearnedRoutePriority: pulumi.Bool(true),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = "my-router"
region = "us-central1"
interface = "interface-1"
peer_asn = 65513
custom_learned_route_priority = 0
zero_custom_learned_route_priority = true
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
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 peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router("my-router")
.region("us-central1")
.interface_("interface-1")
.peerAsn(65513)
.customLearnedRoutePriority(0)
.zeroCustomLearnedRoutePriority(true)
.build());
}
}
resources:
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: my-router
region: us-central1
interface: interface-1
peerAsn: 65513
customLearnedRoutePriority: 0
zeroCustomLearnedRoutePriority: true
Router Zero Advertised Route Priority
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: "my-router",
region: "us-central1",
"interface": "interface-1",
peerAsn: 65513,
advertisedRoutePriority: 0,
zeroAdvertisedRoutePriority: true,
});
import pulumi
import pulumi_gcp as gcp
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router="my-router",
region="us-central1",
interface="interface-1",
peer_asn=65513,
advertised_route_priority=0,
zero_advertised_route_priority=True)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = "my-router",
Region = "us-central1",
Interface = "interface-1",
PeerAsn = 65513,
AdvertisedRoutePriority = 0,
ZeroAdvertisedRoutePriority = 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.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: pulumi.String("my-router"),
Region: pulumi.String("us-central1"),
Interface: pulumi.String("interface-1"),
PeerAsn: pulumi.Int(65513),
AdvertisedRoutePriority: pulumi.Int(0),
ZeroAdvertisedRoutePriority: pulumi.Bool(true),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = "my-router"
region = "us-central1"
interface = "interface-1"
peer_asn = 65513
advertised_route_priority = 0
zero_advertised_route_priority = true
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
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 peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router("my-router")
.region("us-central1")
.interface_("interface-1")
.peerAsn(65513)
.advertisedRoutePriority(0)
.zeroAdvertisedRoutePriority(true)
.build());
}
}
resources:
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: my-router
region: us-central1
interface: interface-1
peerAsn: 65513
advertisedRoutePriority: 0
zeroAdvertisedRoutePriority: true
Router Peer Router Appliance
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const network = new gcp.compute.Network("network", {
name: "my-router-net",
autoCreateSubnetworks: false,
});
const subnetwork = new gcp.compute.Subnetwork("subnetwork", {
name: "my-router-sub",
network: network.selfLink,
ipCidrRange: "10.0.0.0/16",
region: "us-central1",
});
const addrIntf = new gcp.compute.Address("addr_intf", {
name: "my-router-addr-intf",
region: subnetwork.region,
subnetwork: subnetwork.id,
addressType: "INTERNAL",
});
const addrIntfRedundant = new gcp.compute.Address("addr_intf_redundant", {
name: "my-router-addr-intf-red",
region: subnetwork.region,
subnetwork: subnetwork.id,
addressType: "INTERNAL",
});
const addrPeer = new gcp.compute.Address("addr_peer", {
name: "my-router-addr-peer",
region: subnetwork.region,
subnetwork: subnetwork.id,
addressType: "INTERNAL",
});
const instance = new gcp.compute.Instance("instance", {
name: "router-appliance",
zone: "us-central1-a",
machineType: "e2-medium",
canIpForward: true,
bootDisk: {
initializeParams: {
image: "debian-cloud/debian-11",
},
},
networkInterfaces: [{
networkIp: addrPeer.address,
subnetwork: subnetwork.selfLink,
}],
});
const hub = new gcp.networkconnectivity.Hub("hub", {name: "my-router-hub"});
const spoke = new gcp.networkconnectivity.Spoke("spoke", {
name: "my-router-spoke",
location: subnetwork.region,
hub: hub.id,
linkedRouterApplianceInstances: {
instances: [{
virtualMachine: instance.selfLink,
ipAddress: addrPeer.address,
}],
siteToSiteDataTransfer: false,
},
});
const router = new gcp.compute.Router("router", {
name: "my-router-router",
region: subnetwork.region,
network: network.selfLink,
bgp: {
asn: 64514,
},
});
const interfaceRedundant = new gcp.compute.RouterInterface("interface_redundant", {
name: "my-router-intf-red",
region: router.region,
router: router.name,
subnetwork: subnetwork.selfLink,
privateIpAddress: addrIntfRedundant.address,
});
const _interface = new gcp.compute.RouterInterface("interface", {
name: "my-router-intf",
region: router.region,
router: router.name,
subnetwork: subnetwork.selfLink,
privateIpAddress: addrIntf.address,
redundantInterface: interfaceRedundant.name,
});
const peer = new gcp.compute.RouterPeer("peer", {
name: "my-router-peer",
router: router.name,
region: router.region,
"interface": _interface.name,
routerApplianceInstance: instance.selfLink,
peerAsn: 65513,
peerIpAddress: addrPeer.address,
});
import pulumi
import pulumi_gcp as gcp
network = gcp.compute.Network("network",
name="my-router-net",
auto_create_subnetworks=False)
subnetwork = gcp.compute.Subnetwork("subnetwork",
name="my-router-sub",
network=network.self_link,
ip_cidr_range="10.0.0.0/16",
region="us-central1")
addr_intf = gcp.compute.Address("addr_intf",
name="my-router-addr-intf",
region=subnetwork.region,
subnetwork=subnetwork.id,
address_type="INTERNAL")
addr_intf_redundant = gcp.compute.Address("addr_intf_redundant",
name="my-router-addr-intf-red",
region=subnetwork.region,
subnetwork=subnetwork.id,
address_type="INTERNAL")
addr_peer = gcp.compute.Address("addr_peer",
name="my-router-addr-peer",
region=subnetwork.region,
subnetwork=subnetwork.id,
address_type="INTERNAL")
instance = gcp.compute.Instance("instance",
name="router-appliance",
zone="us-central1-a",
machine_type="e2-medium",
can_ip_forward=True,
boot_disk={
"initialize_params": {
"image": "debian-cloud/debian-11",
},
},
network_interfaces=[{
"network_ip": addr_peer.address,
"subnetwork": subnetwork.self_link,
}])
hub = gcp.networkconnectivity.Hub("hub", name="my-router-hub")
spoke = gcp.networkconnectivity.Spoke("spoke",
name="my-router-spoke",
location=subnetwork.region,
hub=hub.id,
linked_router_appliance_instances={
"instances": [{
"virtual_machine": instance.self_link,
"ip_address": addr_peer.address,
}],
"site_to_site_data_transfer": False,
})
router = gcp.compute.Router("router",
name="my-router-router",
region=subnetwork.region,
network=network.self_link,
bgp={
"asn": 64514,
})
interface_redundant = gcp.compute.RouterInterface("interface_redundant",
name="my-router-intf-red",
region=router.region,
router=router.name,
subnetwork=subnetwork.self_link,
private_ip_address=addr_intf_redundant.address)
interface = gcp.compute.RouterInterface("interface",
name="my-router-intf",
region=router.region,
router=router.name,
subnetwork=subnetwork.self_link,
private_ip_address=addr_intf.address,
redundant_interface=interface_redundant.name)
peer = gcp.compute.RouterPeer("peer",
name="my-router-peer",
router=router.name,
region=router.region,
interface=interface.name,
router_appliance_instance=instance.self_link,
peer_asn=65513,
peer_ip_address=addr_peer.address)
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 = "my-router-net",
AutoCreateSubnetworks = false,
});
var subnetwork = new Gcp.Compute.Subnetwork("subnetwork", new()
{
Name = "my-router-sub",
Network = network.SelfLink,
IpCidrRange = "10.0.0.0/16",
Region = "us-central1",
});
var addrIntf = new Gcp.Compute.Address("addr_intf", new()
{
Name = "my-router-addr-intf",
Region = subnetwork.Region,
Subnetwork = subnetwork.Id,
AddressType = "INTERNAL",
});
var addrIntfRedundant = new Gcp.Compute.Address("addr_intf_redundant", new()
{
Name = "my-router-addr-intf-red",
Region = subnetwork.Region,
Subnetwork = subnetwork.Id,
AddressType = "INTERNAL",
});
var addrPeer = new Gcp.Compute.Address("addr_peer", new()
{
Name = "my-router-addr-peer",
Region = subnetwork.Region,
Subnetwork = subnetwork.Id,
AddressType = "INTERNAL",
});
var instance = new Gcp.Compute.Instance("instance", new()
{
Name = "router-appliance",
Zone = "us-central1-a",
MachineType = "e2-medium",
CanIpForward = true,
BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
{
InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
{
Image = "debian-cloud/debian-11",
},
},
NetworkInterfaces = new[]
{
new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
{
NetworkIp = addrPeer.IPAddress,
Subnetwork = subnetwork.SelfLink,
},
},
});
var hub = new Gcp.NetworkConnectivity.Hub("hub", new()
{
Name = "my-router-hub",
});
var spoke = new Gcp.NetworkConnectivity.Spoke("spoke", new()
{
Name = "my-router-spoke",
Location = subnetwork.Region,
Hub = hub.Id,
LinkedRouterApplianceInstances = new Gcp.NetworkConnectivity.Inputs.SpokeLinkedRouterApplianceInstancesArgs
{
Instances = new[]
{
new Gcp.NetworkConnectivity.Inputs.SpokeLinkedRouterApplianceInstancesInstanceArgs
{
VirtualMachine = instance.SelfLink,
IpAddress = addrPeer.IPAddress,
},
},
SiteToSiteDataTransfer = false,
},
});
var router = new Gcp.Compute.Router("router", new()
{
Name = "my-router-router",
Region = subnetwork.Region,
Network = network.SelfLink,
Bgp = new Gcp.Compute.Inputs.RouterBgpArgs
{
Asn = 64514,
},
});
var interfaceRedundant = new Gcp.Compute.RouterInterface("interface_redundant", new()
{
Name = "my-router-intf-red",
Region = router.Region,
Router = router.Name,
Subnetwork = subnetwork.SelfLink,
PrivateIpAddress = addrIntfRedundant.IPAddress,
});
var @interface = new Gcp.Compute.RouterInterface("interface", new()
{
Name = "my-router-intf",
Region = router.Region,
Router = router.Name,
Subnetwork = subnetwork.SelfLink,
PrivateIpAddress = addrIntf.IPAddress,
RedundantInterface = interfaceRedundant.Name,
});
var peer = new Gcp.Compute.RouterPeer("peer", new()
{
Name = "my-router-peer",
Router = router.Name,
Region = router.Region,
Interface = @interface.Name,
RouterApplianceInstance = instance.SelfLink,
PeerAsn = 65513,
PeerIpAddress = addrPeer.IPAddress,
});
});
package main
import (
"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
"github.com/pulumi/pulumi-gcp/sdk/v9/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("my-router-net"),
AutoCreateSubnetworks: pulumi.Bool(false),
})
if err != nil {
return err
}
subnetwork, err := compute.NewSubnetwork(ctx, "subnetwork", &compute.SubnetworkArgs{
Name: pulumi.String("my-router-sub"),
Network: network.SelfLink,
IpCidrRange: pulumi.String("10.0.0.0/16"),
Region: pulumi.String("us-central1"),
})
if err != nil {
return err
}
addrIntf, err := compute.NewAddress(ctx, "addr_intf", &compute.AddressArgs{
Name: pulumi.String("my-router-addr-intf"),
Region: subnetwork.Region,
Subnetwork: subnetwork.ID().ToIDOutput().ToStringOutput(),
AddressType: pulumi.String("INTERNAL"),
})
if err != nil {
return err
}
addrIntfRedundant, err := compute.NewAddress(ctx, "addr_intf_redundant", &compute.AddressArgs{
Name: pulumi.String("my-router-addr-intf-red"),
Region: subnetwork.Region,
Subnetwork: subnetwork.ID().ToIDOutput().ToStringOutput(),
AddressType: pulumi.String("INTERNAL"),
})
if err != nil {
return err
}
addrPeer, err := compute.NewAddress(ctx, "addr_peer", &compute.AddressArgs{
Name: pulumi.String("my-router-addr-peer"),
Region: subnetwork.Region,
Subnetwork: subnetwork.ID().ToIDOutput().ToStringOutput(),
AddressType: pulumi.String("INTERNAL"),
})
if err != nil {
return err
}
instance, err := compute.NewInstance(ctx, "instance", &compute.InstanceArgs{
Name: pulumi.String("router-appliance"),
Zone: pulumi.String("us-central1-a"),
MachineType: pulumi.String("e2-medium"),
CanIpForward: pulumi.Bool(true),
BootDisk: &compute.InstanceBootDiskArgs{
InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
Image: pulumi.String("debian-cloud/debian-11"),
},
},
NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
&compute.InstanceNetworkInterfaceArgs{
NetworkIp: addrPeer.Address,
Subnetwork: subnetwork.SelfLink,
},
},
})
if err != nil {
return err
}
hub, err := networkconnectivity.NewHub(ctx, "hub", &networkconnectivity.HubArgs{
Name: pulumi.String("my-router-hub"),
})
if err != nil {
return err
}
_, err = networkconnectivity.NewSpoke(ctx, "spoke", &networkconnectivity.SpokeArgs{
Name: pulumi.String("my-router-spoke"),
Location: subnetwork.Region,
Hub: hub.ID().ToIDOutput().ToStringOutput(),
LinkedRouterApplianceInstances: &networkconnectivity.SpokeLinkedRouterApplianceInstancesArgs{
Instances: networkconnectivity.SpokeLinkedRouterApplianceInstancesInstanceArray{
&networkconnectivity.SpokeLinkedRouterApplianceInstancesInstanceArgs{
VirtualMachine: instance.SelfLink,
IpAddress: addrPeer.Address,
},
},
SiteToSiteDataTransfer: pulumi.Bool(false),
},
})
if err != nil {
return err
}
router, err := compute.NewRouter(ctx, "router", &compute.RouterArgs{
Name: pulumi.String("my-router-router"),
Region: subnetwork.Region,
Network: network.SelfLink,
Bgp: &compute.RouterBgpArgs{
Asn: pulumi.Int(64514),
},
})
if err != nil {
return err
}
interfaceRedundant, err := compute.NewRouterInterface(ctx, "interface_redundant", &compute.RouterInterfaceArgs{
Name: pulumi.String("my-router-intf-red"),
Region: router.Region,
Router: router.Name,
Subnetwork: subnetwork.SelfLink,
PrivateIpAddress: addrIntfRedundant.Address,
})
if err != nil {
return err
}
_interface, err := compute.NewRouterInterface(ctx, "interface", &compute.RouterInterfaceArgs{
Name: pulumi.String("my-router-intf"),
Region: router.Region,
Router: router.Name,
Subnetwork: subnetwork.SelfLink,
PrivateIpAddress: addrIntf.Address,
RedundantInterface: interfaceRedundant.Name,
})
if err != nil {
return err
}
_, err = compute.NewRouterPeer(ctx, "peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: router.Name,
Region: router.Region,
Interface: _interface.Name,
RouterApplianceInstance: instance.SelfLink,
PeerAsn: pulumi.Int(65513),
PeerIpAddress: addrPeer.Address,
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_network" "network" {
name = "my-router-net"
auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "subnetwork" {
name = "my-router-sub"
network = gcp_compute_network.network.self_link
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "gcp_compute_address" "addr_intf" {
name = "my-router-addr-intf"
region = gcp_compute_subnetwork.subnetwork.region
subnetwork = gcp_compute_subnetwork.subnetwork.id
address_type = "INTERNAL"
}
resource "gcp_compute_address" "addr_intf_redundant" {
name = "my-router-addr-intf-red"
region = gcp_compute_subnetwork.subnetwork.region
subnetwork = gcp_compute_subnetwork.subnetwork.id
address_type = "INTERNAL"
}
resource "gcp_compute_address" "addr_peer" {
name = "my-router-addr-peer"
region = gcp_compute_subnetwork.subnetwork.region
subnetwork = gcp_compute_subnetwork.subnetwork.id
address_type = "INTERNAL"
}
resource "gcp_compute_instance" "instance" {
name = "router-appliance"
zone = "us-central1-a"
machine_type = "e2-medium"
can_ip_forward = true
boot_disk = {
initialize_params = {
image = "debian-cloud/debian-11"
}
}
network_interfaces {
network_ip = gcp_compute_address.addr_peer.address
subnetwork = gcp_compute_subnetwork.subnetwork.self_link
}
}
resource "gcp_networkconnectivity_hub" "hub" {
name = "my-router-hub"
}
resource "gcp_networkconnectivity_spoke" "spoke" {
name = "my-router-spoke"
location = gcp_compute_subnetwork.subnetwork.region
hub = gcp_networkconnectivity_hub.hub.id
linked_router_appliance_instances = {
instances = [{
"virtualMachine" = gcp_compute_instance.instance.self_link
"ipAddress" = gcp_compute_address.addr_peer.address
}]
site_to_site_data_transfer = false
}
}
resource "gcp_compute_router" "router" {
name = "my-router-router"
region = gcp_compute_subnetwork.subnetwork.region
network = gcp_compute_network.network.self_link
bgp = {
asn = 64514
}
}
resource "gcp_compute_routerinterface" "interface_redundant" {
name = "my-router-intf-red"
region = gcp_compute_router.router.region
router = gcp_compute_router.router.name
subnetwork = gcp_compute_subnetwork.subnetwork.self_link
private_ip_address = gcp_compute_address.addr_intf_redundant.address
}
resource "gcp_compute_routerinterface" "interface" {
name = "my-router-intf"
region = gcp_compute_router.router.region
router = gcp_compute_router.router.name
subnetwork = gcp_compute_subnetwork.subnetwork.self_link
private_ip_address = gcp_compute_address.addr_intf.address
redundant_interface = gcp_compute_routerinterface.interface_redundant.name
}
resource "gcp_compute_routerpeer" "peer" {
name = "my-router-peer"
router = gcp_compute_router.router.name
region = gcp_compute_router.router.region
interface = gcp_compute_routerinterface.interface.name
router_appliance_instance = gcp_compute_instance.instance.self_link
peer_asn = 65513
peer_ip_address = gcp_compute_address.addr_peer.address
}
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.Address;
import com.pulumi.gcp.compute.AddressArgs;
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 com.pulumi.gcp.networkconnectivity.inputs.SpokeLinkedRouterApplianceInstancesInstanceArgs;
import com.pulumi.gcp.compute.Router;
import com.pulumi.gcp.compute.RouterArgs;
import com.pulumi.gcp.compute.inputs.RouterBgpArgs;
import com.pulumi.gcp.compute.RouterInterface;
import com.pulumi.gcp.compute.RouterInterfaceArgs;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
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 network = new Network("network", NetworkArgs.builder()
.name("my-router-net")
.autoCreateSubnetworks(false)
.build());
var subnetwork = new Subnetwork("subnetwork", SubnetworkArgs.builder()
.name("my-router-sub")
.network(network.selfLink())
.ipCidrRange("10.0.0.0/16")
.region("us-central1")
.build());
var addrIntf = new Address("addrIntf", AddressArgs.builder()
.name("my-router-addr-intf")
.region(subnetwork.region())
.subnetwork(subnetwork.id())
.addressType("INTERNAL")
.build());
var addrIntfRedundant = new Address("addrIntfRedundant", AddressArgs.builder()
.name("my-router-addr-intf-red")
.region(subnetwork.region())
.subnetwork(subnetwork.id())
.addressType("INTERNAL")
.build());
var addrPeer = new Address("addrPeer", AddressArgs.builder()
.name("my-router-addr-peer")
.region(subnetwork.region())
.subnetwork(subnetwork.id())
.addressType("INTERNAL")
.build());
var instance = new Instance("instance", InstanceArgs.builder()
.name("router-appliance")
.zone("us-central1-a")
.machineType("e2-medium")
.canIpForward(true)
.bootDisk(InstanceBootDiskArgs.builder()
.initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
.image("debian-cloud/debian-11")
.build())
.build())
.networkInterfaces(InstanceNetworkInterfaceArgs.builder()
.networkIp(addrPeer.address())
.subnetwork(subnetwork.selfLink())
.build())
.build());
var hub = new Hub("hub", HubArgs.builder()
.name("my-router-hub")
.build());
var spoke = new Spoke("spoke", SpokeArgs.builder()
.name("my-router-spoke")
.location(subnetwork.region())
.hub(hub.id())
.linkedRouterApplianceInstances(SpokeLinkedRouterApplianceInstancesArgs.builder()
.instances(SpokeLinkedRouterApplianceInstancesInstanceArgs.builder()
.virtualMachine(instance.selfLink())
.ipAddress(addrPeer.address())
.build())
.siteToSiteDataTransfer(false)
.build())
.build());
var router = new Router("router", RouterArgs.builder()
.name("my-router-router")
.region(subnetwork.region())
.network(network.selfLink())
.bgp(RouterBgpArgs.builder()
.asn(64514)
.build())
.build());
var interfaceRedundant = new RouterInterface("interfaceRedundant", RouterInterfaceArgs.builder()
.name("my-router-intf-red")
.region(router.region())
.router(router.name())
.subnetwork(subnetwork.selfLink())
.privateIpAddress(addrIntfRedundant.address())
.build());
var interface_ = new RouterInterface("interface", RouterInterfaceArgs.builder()
.name("my-router-intf")
.region(router.region())
.router(router.name())
.subnetwork(subnetwork.selfLink())
.privateIpAddress(addrIntf.address())
.redundantInterface(interfaceRedundant.name())
.build());
var peer = new RouterPeer("peer", RouterPeerArgs.builder()
.name("my-router-peer")
.router(router.name())
.region(router.region())
.interface_(interface_.name())
.routerApplianceInstance(instance.selfLink())
.peerAsn(65513)
.peerIpAddress(addrPeer.address())
.build());
}
}
resources:
network:
type: gcp:compute:Network
properties:
name: my-router-net
autoCreateSubnetworks: false
subnetwork:
type: gcp:compute:Subnetwork
properties:
name: my-router-sub
network: ${network.selfLink}
ipCidrRange: 10.0.0.0/16
region: us-central1
addrIntf:
type: gcp:compute:Address
name: addr_intf
properties:
name: my-router-addr-intf
region: ${subnetwork.region}
subnetwork: ${subnetwork.id}
addressType: INTERNAL
addrIntfRedundant:
type: gcp:compute:Address
name: addr_intf_redundant
properties:
name: my-router-addr-intf-red
region: ${subnetwork.region}
subnetwork: ${subnetwork.id}
addressType: INTERNAL
addrPeer:
type: gcp:compute:Address
name: addr_peer
properties:
name: my-router-addr-peer
region: ${subnetwork.region}
subnetwork: ${subnetwork.id}
addressType: INTERNAL
instance:
type: gcp:compute:Instance
properties:
name: router-appliance
zone: us-central1-a
machineType: e2-medium
canIpForward: true
bootDisk:
initializeParams:
image: debian-cloud/debian-11
networkInterfaces:
- networkIp: ${addrPeer.address}
subnetwork: ${subnetwork.selfLink}
hub:
type: gcp:networkconnectivity:Hub
properties:
name: my-router-hub
spoke:
type: gcp:networkconnectivity:Spoke
properties:
name: my-router-spoke
location: ${subnetwork.region}
hub: ${hub.id}
linkedRouterApplianceInstances:
instances:
- virtualMachine: ${instance.selfLink}
ipAddress: ${addrPeer.address}
siteToSiteDataTransfer: false
router:
type: gcp:compute:Router
properties:
name: my-router-router
region: ${subnetwork.region}
network: ${network.selfLink}
bgp:
asn: 64514
interfaceRedundant:
type: gcp:compute:RouterInterface
name: interface_redundant
properties:
name: my-router-intf-red
region: ${router.region}
router: ${router.name}
subnetwork: ${subnetwork.selfLink}
privateIpAddress: ${addrIntfRedundant.address}
interface:
type: gcp:compute:RouterInterface
properties:
name: my-router-intf
region: ${router.region}
router: ${router.name}
subnetwork: ${subnetwork.selfLink}
privateIpAddress: ${addrIntf.address}
redundantInterface: ${interfaceRedundant.name}
peer:
type: gcp:compute:RouterPeer
properties:
name: my-router-peer
router: ${router.name}
region: ${router.region}
interface: ${interface.name}
routerApplianceInstance: ${instance.selfLink}
peerAsn: 65513
peerIpAddress: ${addrPeer.address}
Router Peer Md5 Authentication Key
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const foobar = new gcp.compute.RouterPeer("foobar", {
name: "%s-peer",
router: foobarGoogleComputeRouter.name,
region: foobarGoogleComputeRouter.region,
peerAsn: 65515,
advertisedRoutePriority: 100,
"interface": foobarGoogleComputeRouterInterface.name,
peerIpAddress: "169.254.3.2",
md5AuthenticationKey: {
name: "%s-peer-key",
key: "%s-peer-key-value",
},
});
import pulumi
import pulumi_gcp as gcp
foobar = gcp.compute.RouterPeer("foobar",
name="%s-peer",
router=foobar_google_compute_router["name"],
region=foobar_google_compute_router["region"],
peer_asn=65515,
advertised_route_priority=100,
interface=foobar_google_compute_router_interface["name"],
peer_ip_address="169.254.3.2",
md5_authentication_key={
"name": "%s-peer-key",
"key": "%s-peer-key-value",
})
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
var foobar = new Gcp.Compute.RouterPeer("foobar", new()
{
Name = "%s-peer",
Router = foobarGoogleComputeRouter.Name,
Region = foobarGoogleComputeRouter.Region,
PeerAsn = 65515,
AdvertisedRoutePriority = 100,
Interface = foobarGoogleComputeRouterInterface.Name,
PeerIpAddress = "169.254.3.2",
Md5AuthenticationKey = new Gcp.Compute.Inputs.RouterPeerMd5AuthenticationKeyArgs
{
Name = "%s-peer-key",
Key = "%s-peer-key-value",
},
});
});
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.NewRouterPeer(ctx, "foobar", &compute.RouterPeerArgs{
Name: pulumi.String("%s-peer"),
Router: pulumi.Any(foobarGoogleComputeRouter.Name),
Region: pulumi.Any(foobarGoogleComputeRouter.Region),
PeerAsn: pulumi.Int(65515),
AdvertisedRoutePriority: pulumi.Int(100),
Interface: pulumi.Any(foobarGoogleComputeRouterInterface.Name),
PeerIpAddress: pulumi.String("169.254.3.2"),
Md5AuthenticationKey: &compute.RouterPeerMd5AuthenticationKeyArgs{
Name: pulumi.String("%s-peer-key"),
Key: pulumi.String("%s-peer-key-value"),
},
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_routerpeer" "foobar" {
name = "%s-peer"
router = foobarGoogleComputeRouter.name
region = foobarGoogleComputeRouter.region
peer_asn = 65515
advertised_route_priority = 100
interface = foobarGoogleComputeRouterInterface.name
peer_ip_address = "169.254.3.2"
md5_authentication_key = {
name = "%s-peer-key"
key = "%s-peer-key-value"
}
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
import com.pulumi.gcp.compute.inputs.RouterPeerMd5AuthenticationKeyArgs;
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 foobar = new RouterPeer("foobar", RouterPeerArgs.builder()
.name("%s-peer")
.router(foobarGoogleComputeRouter.get("name"))
.region(foobarGoogleComputeRouter.get("region"))
.peerAsn(65515)
.advertisedRoutePriority(100)
.interface_(foobarGoogleComputeRouterInterface.get("name"))
.peerIpAddress("169.254.3.2")
.md5AuthenticationKey(RouterPeerMd5AuthenticationKeyArgs.builder()
.name("%s-peer-key")
.key("%s-peer-key-value")
.build())
.build());
}
}
resources:
foobar:
type: gcp:compute:RouterPeer
properties:
name: '%s-peer'
router: ${foobarGoogleComputeRouter.name}
region: ${foobarGoogleComputeRouter.region}
peerAsn: 65515
advertisedRoutePriority: 100
interface: ${foobarGoogleComputeRouterInterface.name}
peerIpAddress: 169.254.3.2
md5AuthenticationKey:
name: '%s-peer-key'
key: '%s-peer-key-value'
Router Peer Export And Import Policies
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const network = new gcp.compute.Network("network", {
name: "my-router-net",
autoCreateSubnetworks: false,
});
const subnetwork = new gcp.compute.Subnetwork("subnetwork", {
name: "my-router-subnet",
network: network.selfLink,
ipCidrRange: "10.0.0.0/16",
region: "us-central1",
});
const address = new gcp.compute.Address("address", {
name: "my-router",
region: subnetwork.region,
});
const vpnGateway = new gcp.compute.HaVpnGateway("vpn_gateway", {
name: "my-router-gateway",
network: network.selfLink,
region: subnetwork.region,
});
const externalGateway = new gcp.compute.ExternalVpnGateway("external_gateway", {
name: "my-router-external-gateway",
redundancyType: "SINGLE_IP_INTERNALLY_REDUNDANT",
description: "An externally managed VPN gateway",
interfaces: [{
id: 0,
ipAddress: "8.8.8.8",
}],
});
const router = new gcp.compute.Router("router", {
name: "my-router",
region: subnetwork.region,
network: network.selfLink,
bgp: {
asn: 64514,
},
});
const vpnTunnel = new gcp.compute.VPNTunnel("vpn_tunnel", {
name: "my-router",
region: subnetwork.region,
vpnGateway: vpnGateway.id,
peerExternalGateway: externalGateway.id,
peerExternalGatewayInterface: 0,
sharedSecret: "unguessable",
router: router.name,
vpnGatewayInterface: 0,
});
const routerInterface = new gcp.compute.RouterInterface("router_interface", {
name: "my-router",
router: router.name,
region: router.region,
vpnTunnel: vpnTunnel.name,
});
const rp_export = new gcp.compute.RouterRoutePolicy("rp-export", {
name: "my-router-rp-export",
router: router.name,
region: router.region,
type: "ROUTE_POLICY_TYPE_EXPORT",
terms: [{
priority: 2,
match: {
expression: "destination == '10.0.0.0/12'",
title: "export_expression",
description: "acceptance expression for export",
},
actions: [{
expression: "accept()",
}],
}],
}, {
dependsOn: [routerInterface],
});
const rp_import = new gcp.compute.RouterRoutePolicy("rp-import", {
name: "my-router-rp-import",
router: router.name,
region: router.region,
type: "ROUTE_POLICY_TYPE_IMPORT",
terms: [{
priority: 1,
match: {
expression: "destination == '10.0.0.0/12'",
title: "import_expression",
description: "acceptance expression for import",
},
actions: [{
expression: "accept()",
}],
}],
}, {
dependsOn: [
routerInterface,
rp_export,
],
});
const routerPeer = new gcp.compute.RouterPeer("router_peer", {
name: "my-router-peer",
router: router.name,
region: router.region,
peerAsn: 65515,
advertisedRoutePriority: 100,
"interface": routerInterface.name,
md5AuthenticationKey: {
name: "my-router-peer-key",
key: "my-router-peer-key-value",
},
importPolicies: [rp_import.name],
exportPolicies: [rp_export.name],
}, {
dependsOn: [
rp_export,
rp_import,
routerInterface,
],
});
import pulumi
import pulumi_gcp as gcp
network = gcp.compute.Network("network",
name="my-router-net",
auto_create_subnetworks=False)
subnetwork = gcp.compute.Subnetwork("subnetwork",
name="my-router-subnet",
network=network.self_link,
ip_cidr_range="10.0.0.0/16",
region="us-central1")
address = gcp.compute.Address("address",
name="my-router",
region=subnetwork.region)
vpn_gateway = gcp.compute.HaVpnGateway("vpn_gateway",
name="my-router-gateway",
network=network.self_link,
region=subnetwork.region)
external_gateway = gcp.compute.ExternalVpnGateway("external_gateway",
name="my-router-external-gateway",
redundancy_type="SINGLE_IP_INTERNALLY_REDUNDANT",
description="An externally managed VPN gateway",
interfaces=[{
"id": 0,
"ip_address": "8.8.8.8",
}])
router = gcp.compute.Router("router",
name="my-router",
region=subnetwork.region,
network=network.self_link,
bgp={
"asn": 64514,
})
vpn_tunnel = gcp.compute.VPNTunnel("vpn_tunnel",
name="my-router",
region=subnetwork.region,
vpn_gateway=vpn_gateway.id,
peer_external_gateway=external_gateway.id,
peer_external_gateway_interface=0,
shared_secret="unguessable",
router=router.name,
vpn_gateway_interface=0)
router_interface = gcp.compute.RouterInterface("router_interface",
name="my-router",
router=router.name,
region=router.region,
vpn_tunnel=vpn_tunnel.name)
rp_export = gcp.compute.RouterRoutePolicy("rp-export",
name="my-router-rp-export",
router=router.name,
region=router.region,
type="ROUTE_POLICY_TYPE_EXPORT",
terms=[{
"priority": 2,
"match": {
"expression": "destination == '10.0.0.0/12'",
"title": "export_expression",
"description": "acceptance expression for export",
},
"actions": [{
"expression": "accept()",
}],
}],
opts = pulumi.ResourceOptions(depends_on=[router_interface]))
rp_import = gcp.compute.RouterRoutePolicy("rp-import",
name="my-router-rp-import",
router=router.name,
region=router.region,
type="ROUTE_POLICY_TYPE_IMPORT",
terms=[{
"priority": 1,
"match": {
"expression": "destination == '10.0.0.0/12'",
"title": "import_expression",
"description": "acceptance expression for import",
},
"actions": [{
"expression": "accept()",
}],
}],
opts = pulumi.ResourceOptions(depends_on=[
router_interface,
rp_export,
]))
router_peer = gcp.compute.RouterPeer("router_peer",
name="my-router-peer",
router=router.name,
region=router.region,
peer_asn=65515,
advertised_route_priority=100,
interface=router_interface.name,
md5_authentication_key={
"name": "my-router-peer-key",
"key": "my-router-peer-key-value",
},
import_policies=[rp_import.name],
export_policies=[rp_export.name],
opts = pulumi.ResourceOptions(depends_on=[
rp_export,
rp_import,
router_interface,
]))
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 = "my-router-net",
AutoCreateSubnetworks = false,
});
var subnetwork = new Gcp.Compute.Subnetwork("subnetwork", new()
{
Name = "my-router-subnet",
Network = network.SelfLink,
IpCidrRange = "10.0.0.0/16",
Region = "us-central1",
});
var address = new Gcp.Compute.Address("address", new()
{
Name = "my-router",
Region = subnetwork.Region,
});
var vpnGateway = new Gcp.Compute.HaVpnGateway("vpn_gateway", new()
{
Name = "my-router-gateway",
Network = network.SelfLink,
Region = subnetwork.Region,
});
var externalGateway = new Gcp.Compute.ExternalVpnGateway("external_gateway", new()
{
Name = "my-router-external-gateway",
RedundancyType = "SINGLE_IP_INTERNALLY_REDUNDANT",
Description = "An externally managed VPN gateway",
Interfaces = new[]
{
new Gcp.Compute.Inputs.ExternalVpnGatewayInterfaceArgs
{
Id = 0,
IpAddress = "8.8.8.8",
},
},
});
var router = new Gcp.Compute.Router("router", new()
{
Name = "my-router",
Region = subnetwork.Region,
Network = network.SelfLink,
Bgp = new Gcp.Compute.Inputs.RouterBgpArgs
{
Asn = 64514,
},
});
var vpnTunnel = new Gcp.Compute.VPNTunnel("vpn_tunnel", new()
{
Name = "my-router",
Region = subnetwork.Region,
VpnGateway = vpnGateway.Id,
PeerExternalGateway = externalGateway.Id,
PeerExternalGatewayInterface = 0,
SharedSecret = "unguessable",
Router = router.Name,
VpnGatewayInterface = 0,
});
var routerInterface = new Gcp.Compute.RouterInterface("router_interface", new()
{
Name = "my-router",
Router = router.Name,
Region = router.Region,
VpnTunnel = vpnTunnel.Name,
});
var rp_export = new Gcp.Compute.RouterRoutePolicy("rp-export", new()
{
Name = "my-router-rp-export",
Router = router.Name,
Region = router.Region,
Type = "ROUTE_POLICY_TYPE_EXPORT",
Terms = new[]
{
new Gcp.Compute.Inputs.RouterRoutePolicyTermArgs
{
Priority = 2,
Match = new Gcp.Compute.Inputs.RouterRoutePolicyTermMatchArgs
{
Expression = "destination == '10.0.0.0/12'",
Title = "export_expression",
Description = "acceptance expression for export",
},
Actions = new[]
{
new Gcp.Compute.Inputs.RouterRoutePolicyTermActionArgs
{
Expression = "accept()",
},
},
},
},
}, new CustomResourceOptions
{
DependsOn =
{
routerInterface,
},
});
var rp_import = new Gcp.Compute.RouterRoutePolicy("rp-import", new()
{
Name = "my-router-rp-import",
Router = router.Name,
Region = router.Region,
Type = "ROUTE_POLICY_TYPE_IMPORT",
Terms = new[]
{
new Gcp.Compute.Inputs.RouterRoutePolicyTermArgs
{
Priority = 1,
Match = new Gcp.Compute.Inputs.RouterRoutePolicyTermMatchArgs
{
Expression = "destination == '10.0.0.0/12'",
Title = "import_expression",
Description = "acceptance expression for import",
},
Actions = new[]
{
new Gcp.Compute.Inputs.RouterRoutePolicyTermActionArgs
{
Expression = "accept()",
},
},
},
},
}, new CustomResourceOptions
{
DependsOn =
{
routerInterface,
rp_export,
},
});
var routerPeer = new Gcp.Compute.RouterPeer("router_peer", new()
{
Name = "my-router-peer",
Router = router.Name,
Region = router.Region,
PeerAsn = 65515,
AdvertisedRoutePriority = 100,
Interface = routerInterface.Name,
Md5AuthenticationKey = new Gcp.Compute.Inputs.RouterPeerMd5AuthenticationKeyArgs
{
Name = "my-router-peer-key",
Key = "my-router-peer-key-value",
},
ImportPolicies = new[]
{
rp_import.Name,
},
ExportPolicies = new[]
{
rp_export.Name,
},
}, new CustomResourceOptions
{
DependsOn =
{
rp_export,
rp_import,
routerInterface,
},
});
});
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 {
network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
Name: pulumi.String("my-router-net"),
AutoCreateSubnetworks: pulumi.Bool(false),
})
if err != nil {
return err
}
subnetwork, err := compute.NewSubnetwork(ctx, "subnetwork", &compute.SubnetworkArgs{
Name: pulumi.String("my-router-subnet"),
Network: network.SelfLink,
IpCidrRange: pulumi.String("10.0.0.0/16"),
Region: pulumi.String("us-central1"),
})
if err != nil {
return err
}
_, err = compute.NewAddress(ctx, "address", &compute.AddressArgs{
Name: pulumi.String("my-router"),
Region: subnetwork.Region,
})
if err != nil {
return err
}
vpnGateway, err := compute.NewHaVpnGateway(ctx, "vpn_gateway", &compute.HaVpnGatewayArgs{
Name: pulumi.String("my-router-gateway"),
Network: network.SelfLink,
Region: subnetwork.Region,
})
if err != nil {
return err
}
externalGateway, err := compute.NewExternalVpnGateway(ctx, "external_gateway", &compute.ExternalVpnGatewayArgs{
Name: pulumi.String("my-router-external-gateway"),
RedundancyType: pulumi.String("SINGLE_IP_INTERNALLY_REDUNDANT"),
Description: pulumi.String("An externally managed VPN gateway"),
Interfaces: compute.ExternalVpnGatewayInterfaceArray{
&compute.ExternalVpnGatewayInterfaceArgs{
Id: pulumi.Int(0),
IpAddress: pulumi.String("8.8.8.8"),
},
},
})
if err != nil {
return err
}
router, err := compute.NewRouter(ctx, "router", &compute.RouterArgs{
Name: pulumi.String("my-router"),
Region: subnetwork.Region,
Network: network.SelfLink,
Bgp: &compute.RouterBgpArgs{
Asn: pulumi.Int(64514),
},
})
if err != nil {
return err
}
vpnTunnel, err := compute.NewVPNTunnel(ctx, "vpn_tunnel", &compute.VPNTunnelArgs{
Name: pulumi.String("my-router"),
Region: subnetwork.Region,
VpnGateway: vpnGateway.ID().ToIDOutput().ToStringOutput(),
PeerExternalGateway: externalGateway.ID().ToIDOutput().ToStringOutput(),
PeerExternalGatewayInterface: pulumi.Int(0),
SharedSecret: pulumi.String("unguessable"),
Router: router.Name,
VpnGatewayInterface: pulumi.Int(0),
})
if err != nil {
return err
}
routerInterface, err := compute.NewRouterInterface(ctx, "router_interface", &compute.RouterInterfaceArgs{
Name: pulumi.String("my-router"),
Router: router.Name,
Region: router.Region,
VpnTunnel: vpnTunnel.Name,
})
if err != nil {
return err
}
rp_export, err := compute.NewRouterRoutePolicy(ctx, "rp-export", &compute.RouterRoutePolicyArgs{
Name: pulumi.String("my-router-rp-export"),
Router: router.Name,
Region: router.Region,
Type: pulumi.String("ROUTE_POLICY_TYPE_EXPORT"),
Terms: compute.RouterRoutePolicyTermArray{
&compute.RouterRoutePolicyTermArgs{
Priority: pulumi.Int(2),
Match: &compute.RouterRoutePolicyTermMatchArgs{
Expression: pulumi.String("destination == '10.0.0.0/12'"),
Title: pulumi.String("export_expression"),
Description: pulumi.String("acceptance expression for export"),
},
Actions: compute.RouterRoutePolicyTermActionArray{
&compute.RouterRoutePolicyTermActionArgs{
Expression: pulumi.String("accept()"),
},
},
},
},
}, pulumi.DependsOn([]pulumi.Resource{
routerInterface,
}))
if err != nil {
return err
}
rp_import, err := compute.NewRouterRoutePolicy(ctx, "rp-import", &compute.RouterRoutePolicyArgs{
Name: pulumi.String("my-router-rp-import"),
Router: router.Name,
Region: router.Region,
Type: pulumi.String("ROUTE_POLICY_TYPE_IMPORT"),
Terms: compute.RouterRoutePolicyTermArray{
&compute.RouterRoutePolicyTermArgs{
Priority: pulumi.Int(1),
Match: &compute.RouterRoutePolicyTermMatchArgs{
Expression: pulumi.String("destination == '10.0.0.0/12'"),
Title: pulumi.String("import_expression"),
Description: pulumi.String("acceptance expression for import"),
},
Actions: compute.RouterRoutePolicyTermActionArray{
&compute.RouterRoutePolicyTermActionArgs{
Expression: pulumi.String("accept()"),
},
},
},
},
}, pulumi.DependsOn([]pulumi.Resource{
routerInterface,
rp_export,
}))
if err != nil {
return err
}
_, err = compute.NewRouterPeer(ctx, "router_peer", &compute.RouterPeerArgs{
Name: pulumi.String("my-router-peer"),
Router: router.Name,
Region: router.Region,
PeerAsn: pulumi.Int(65515),
AdvertisedRoutePriority: pulumi.Int(100),
Interface: routerInterface.Name,
Md5AuthenticationKey: &compute.RouterPeerMd5AuthenticationKeyArgs{
Name: pulumi.String("my-router-peer-key"),
Key: pulumi.String("my-router-peer-key-value"),
},
ImportPolicies: pulumi.StringArray{
rp_import.Name,
},
ExportPolicies: pulumi.StringArray{
rp_export.Name,
},
}, pulumi.DependsOn([]pulumi.Resource{
rp_export,
rp_import,
routerInterface,
}))
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
gcp = {
source = "pulumi/gcp"
}
}
}
resource "gcp_compute_network" "network" {
name = "my-router-net"
auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "subnetwork" {
name = "my-router-subnet"
network = gcp_compute_network.network.self_link
ip_cidr_range = "10.0.0.0/16"
region = "us-central1"
}
resource "gcp_compute_address" "address" {
name = "my-router"
region = gcp_compute_subnetwork.subnetwork.region
}
resource "gcp_compute_havpngateway" "vpn_gateway" {
name = "my-router-gateway"
network = gcp_compute_network.network.self_link
region = gcp_compute_subnetwork.subnetwork.region
}
resource "gcp_compute_externalvpngateway" "external_gateway" {
name = "my-router-external-gateway"
redundancy_type = "SINGLE_IP_INTERNALLY_REDUNDANT"
description = "An externally managed VPN gateway"
interfaces {
id = 0
ip_address = "8.8.8.8"
}
}
resource "gcp_compute_router" "router" {
name = "my-router"
region = gcp_compute_subnetwork.subnetwork.region
network = gcp_compute_network.network.self_link
bgp = {
asn = 64514
}
}
resource "gcp_compute_vpntunnel" "vpn_tunnel" {
name = "my-router"
region = gcp_compute_subnetwork.subnetwork.region
vpn_gateway = gcp_compute_havpngateway.vpn_gateway.id
peer_external_gateway = gcp_compute_externalvpngateway.external_gateway.id
peer_external_gateway_interface = 0
shared_secret = "unguessable"
router = gcp_compute_router.router.name
vpn_gateway_interface = 0
}
resource "gcp_compute_routerinterface" "router_interface" {
name = "my-router"
router = gcp_compute_router.router.name
region = gcp_compute_router.router.region
vpn_tunnel = gcp_compute_vpntunnel.vpn_tunnel.name
}
resource "gcp_compute_routerroutepolicy" "rp-export" {
depends_on = [gcp_compute_routerinterface.router_interface]
name = "my-router-rp-export"
router = gcp_compute_router.router.name
region = gcp_compute_router.router.region
type = "ROUTE_POLICY_TYPE_EXPORT"
terms {
priority = 2
match = {
expression = "destination == '10.0.0.0/12'"
title = "export_expression"
description = "acceptance expression for export"
}
actions {
expression = "accept()"
}
}
}
resource "gcp_compute_routerroutepolicy" "rp-import" {
depends_on = [gcp_compute_routerinterface.router_interface, gcp_compute_routerroutepolicy.rp-export]
name = "my-router-rp-import"
router = gcp_compute_router.router.name
region = gcp_compute_router.router.region
type = "ROUTE_POLICY_TYPE_IMPORT"
terms {
priority = 1
match = {
expression = "destination == '10.0.0.0/12'"
title = "import_expression"
description = "acceptance expression for import"
}
actions {
expression = "accept()"
}
}
}
resource "gcp_compute_routerpeer" "router_peer" {
depends_on = [gcp_compute_routerroutepolicy.rp-export, gcp_compute_routerroutepolicy.rp-import, gcp_compute_routerinterface.router_interface]
name = "my-router-peer"
router = gcp_compute_router.router.name
region = gcp_compute_router.router.region
peer_asn = 65515
advertised_route_priority = 100
interface = gcp_compute_routerinterface.router_interface.name
md5_authentication_key = {
name = "my-router-peer-key"
key = "my-router-peer-key-value"
}
import_policies = [gcp_compute_routerroutepolicy.rp-import.name]
export_policies = [gcp_compute_routerroutepolicy.rp-export.name]
}
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.Address;
import com.pulumi.gcp.compute.AddressArgs;
import com.pulumi.gcp.compute.HaVpnGateway;
import com.pulumi.gcp.compute.HaVpnGatewayArgs;
import com.pulumi.gcp.compute.ExternalVpnGateway;
import com.pulumi.gcp.compute.ExternalVpnGatewayArgs;
import com.pulumi.gcp.compute.inputs.ExternalVpnGatewayInterfaceArgs;
import com.pulumi.gcp.compute.Router;
import com.pulumi.gcp.compute.RouterArgs;
import com.pulumi.gcp.compute.inputs.RouterBgpArgs;
import com.pulumi.gcp.compute.VPNTunnel;
import com.pulumi.gcp.compute.VPNTunnelArgs;
import com.pulumi.gcp.compute.RouterInterface;
import com.pulumi.gcp.compute.RouterInterfaceArgs;
import com.pulumi.gcp.compute.RouterRoutePolicy;
import com.pulumi.gcp.compute.RouterRoutePolicyArgs;
import com.pulumi.gcp.compute.inputs.RouterRoutePolicyTermArgs;
import com.pulumi.gcp.compute.inputs.RouterRoutePolicyTermMatchArgs;
import com.pulumi.gcp.compute.inputs.RouterRoutePolicyTermActionArgs;
import com.pulumi.gcp.compute.RouterPeer;
import com.pulumi.gcp.compute.RouterPeerArgs;
import com.pulumi.gcp.compute.inputs.RouterPeerMd5AuthenticationKeyArgs;
import com.pulumi.resources.CustomResourceOptions;
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 network = new Network("network", NetworkArgs.builder()
.name("my-router-net")
.autoCreateSubnetworks(false)
.build());
var subnetwork = new Subnetwork("subnetwork", SubnetworkArgs.builder()
.name("my-router-subnet")
.network(network.selfLink())
.ipCidrRange("10.0.0.0/16")
.region("us-central1")
.build());
var address = new Address("address", AddressArgs.builder()
.name("my-router")
.region(subnetwork.region())
.build());
var vpnGateway = new HaVpnGateway("vpnGateway", HaVpnGatewayArgs.builder()
.name("my-router-gateway")
.network(network.selfLink())
.region(subnetwork.region())
.build());
var externalGateway = new ExternalVpnGateway("externalGateway", ExternalVpnGatewayArgs.builder()
.name("my-router-external-gateway")
.redundancyType("SINGLE_IP_INTERNALLY_REDUNDANT")
.description("An externally managed VPN gateway")
.interfaces(ExternalVpnGatewayInterfaceArgs.builder()
.id(0)
.ipAddress("8.8.8.8")
.build())
.build());
var router = new Router("router", RouterArgs.builder()
.name("my-router")
.region(subnetwork.region())
.network(network.selfLink())
.bgp(RouterBgpArgs.builder()
.asn(64514)
.build())
.build());
var vpnTunnel = new VPNTunnel("vpnTunnel", VPNTunnelArgs.builder()
.name("my-router")
.region(subnetwork.region())
.vpnGateway(vpnGateway.id())
.peerExternalGateway(externalGateway.id())
.peerExternalGatewayInterface(0)
.sharedSecret("unguessable")
.router(router.name())
.vpnGatewayInterface(0)
.build());
var routerInterface = new RouterInterface("routerInterface", RouterInterfaceArgs.builder()
.name("my-router")
.router(router.name())
.region(router.region())
.vpnTunnel(vpnTunnel.name())
.build());
var rp_export = new RouterRoutePolicy("rp-export", RouterRoutePolicyArgs.builder()
.name("my-router-rp-export")
.router(router.name())
.region(router.region())
.type("ROUTE_POLICY_TYPE_EXPORT")
.terms(RouterRoutePolicyTermArgs.builder()
.priority(2)
.match(RouterRoutePolicyTermMatchArgs.builder()
.expression("destination == '10.0.0.0/12'")
.title("export_expression")
.description("acceptance expression for export")
.build())
.actions(RouterRoutePolicyTermActionArgs.builder()
.expression("accept()")
.build())
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(routerInterface)
.build());
var rp_import = new RouterRoutePolicy("rp-import", RouterRoutePolicyArgs.builder()
.name("my-router-rp-import")
.router(router.name())
.region(router.region())
.type("ROUTE_POLICY_TYPE_IMPORT")
.terms(RouterRoutePolicyTermArgs.builder()
.priority(1)
.match(RouterRoutePolicyTermMatchArgs.builder()
.expression("destination == '10.0.0.0/12'")
.title("import_expression")
.description("acceptance expression for import")
.build())
.actions(RouterRoutePolicyTermActionArgs.builder()
.expression("accept()")
.build())
.build())
.build(), CustomResourceOptions.builder()
.dependsOn(
routerInterface,
rp_export)
.build());
var routerPeer = new RouterPeer("routerPeer", RouterPeerArgs.builder()
.name("my-router-peer")
.router(router.name())
.region(router.region())
.peerAsn(65515)
.advertisedRoutePriority(100)
.interface_(routerInterface.name())
.md5AuthenticationKey(RouterPeerMd5AuthenticationKeyArgs.builder()
.name("my-router-peer-key")
.key("my-router-peer-key-value")
.build())
.importPolicies(rp_import.name())
.exportPolicies(rp_export.name())
.build(), CustomResourceOptions.builder()
.dependsOn(
rp_export,
rp_import,
routerInterface)
.build());
}
}
resources:
network:
type: gcp:compute:Network
properties:
name: my-router-net
autoCreateSubnetworks: false
subnetwork:
type: gcp:compute:Subnetwork
properties:
name: my-router-subnet
network: ${network.selfLink}
ipCidrRange: 10.0.0.0/16
region: us-central1
address:
type: gcp:compute:Address
properties:
name: my-router
region: ${subnetwork.region}
vpnGateway:
type: gcp:compute:HaVpnGateway
name: vpn_gateway
properties:
name: my-router-gateway
network: ${network.selfLink}
region: ${subnetwork.region}
externalGateway:
type: gcp:compute:ExternalVpnGateway
name: external_gateway
properties:
name: my-router-external-gateway
redundancyType: SINGLE_IP_INTERNALLY_REDUNDANT
description: An externally managed VPN gateway
interfaces:
- id: 0
ipAddress: 8.8.8.8
router:
type: gcp:compute:Router
properties:
name: my-router
region: ${subnetwork.region}
network: ${network.selfLink}
bgp:
asn: 64514
vpnTunnel:
type: gcp:compute:VPNTunnel
name: vpn_tunnel
properties:
name: my-router
region: ${subnetwork.region}
vpnGateway: ${vpnGateway.id}
peerExternalGateway: ${externalGateway.id}
peerExternalGatewayInterface: 0
sharedSecret: unguessable
router: ${router.name}
vpnGatewayInterface: 0
routerInterface:
type: gcp:compute:RouterInterface
name: router_interface
properties:
name: my-router
router: ${router.name}
region: ${router.region}
vpnTunnel: ${vpnTunnel.name}
rp-export:
type: gcp:compute:RouterRoutePolicy
properties:
name: my-router-rp-export
router: ${router.name}
region: ${router.region}
type: ROUTE_POLICY_TYPE_EXPORT
terms:
- priority: 2
match:
expression: destination == '10.0.0.0/12'
title: export_expression
description: acceptance expression for export
actions:
- expression: accept()
options:
dependsOn:
- ${routerInterface}
rp-import:
type: gcp:compute:RouterRoutePolicy
properties:
name: my-router-rp-import
router: ${router.name}
region: ${router.region}
type: ROUTE_POLICY_TYPE_IMPORT
terms:
- priority: 1
match:
expression: destination == '10.0.0.0/12'
title: import_expression
description: acceptance expression for import
actions:
- expression: accept()
options:
dependsOn:
- ${routerInterface}
- ${["rp-export"]}
routerPeer:
type: gcp:compute:RouterPeer
name: router_peer
properties:
name: my-router-peer
router: ${router.name}
region: ${router.region}
peerAsn: 65515
advertisedRoutePriority: 100
interface: ${routerInterface.name}
md5AuthenticationKey:
name: my-router-peer-key
key: my-router-peer-key-value
importPolicies:
- ${["rp-import"].name}
exportPolicies:
- ${["rp-export"].name}
options:
dependsOn:
- ${["rp-export"]}
- ${["rp-import"]}
- ${routerInterface}
Import
RouterBgpPeer can be imported using any of these accepted formats:
projects/{{project}}/regions/{{region}}/routers/{{router}}/{{name}}{{project}}/{{region}}/{{router}}/{{name}}{{region}}/{{router}}/{{name}}{{router}}/{{name}}
When using the pulumi import command, RouterBgpPeer can be imported using one of the formats above. For example:
$ pulumi import gcp:compute/routerPeer:RouterPeer default projects/{{project}}/regions/{{region}}/routers/{{router}}/{{name}}
$ pulumi import gcp:compute/routerPeer:RouterPeer default {{project}}/{{region}}/{{router}}/{{name}}
$ pulumi import gcp:compute/routerPeer:RouterPeer default {{region}}/{{router}}/{{name}}
$ pulumi import gcp:compute/routerPeer:RouterPeer default {{router}}/{{name}}
Constructors
- RouterPeer(String name, {RouterPeerArgs? args, CustomResourceOptions? options})
-
Creates a new RouterPeer.
nameThe Pulumi resource name.argsArguments used to configure this RouterPeer. The set of arguments for RouterPeer.optionsResource options controlling this resource's behavior. - RouterPeer.reference(String urn)
- Creates a typed reference to an existing RouterPeer resource.
Properties
-
advertisedGroups
↔ Output<
List< String> ?> -
User-specified list of prefix groups to advertise in custom
mode, which currently supports the following option:
latefinal
-
advertisedIpRanges
↔ Output<
List< RouterPeerAdvertisedIpRange> ?> -
User-specified list of individual IP ranges to advertise in
custom mode. This field can only be populated if advertiseMode
is
CUSTOMand is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges. Structure is documented below.latefinal -
advertisedRoutePriority
↔ Output<
int?> -
The priority of routes advertised to this BGP peer.
Where there is more than one matching route of maximum
length, the routes with the lowest priority value win.
latefinal
-
advertiseMode
↔ Output<
String?> -
User-specified flag to indicate which mode to use for advertisement.
Valid values of this enum field are:
DEFAULT,CUSTOMDefault value isDEFAULT. Possible values are:DEFAULT,CUSTOM.latefinal -
bfd
↔ Output<
RouterPeerBfd> -
BFD configuration for the BGP peering.
Structure is documented below.
latefinal
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
customLearnedIpRanges
↔ Output<
List< RouterPeerCustomLearnedIpRange> ?> -
The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
a /32 singular IP address range, and, for IPv6, /128.
Structure is documented below.
latefinal
-
customLearnedRoutePriority
↔ Output<
int?> -
The user-defined custom learned route priority for a BGP session.
This value is applied to all custom learned route ranges for the session.
You can choose a value from 0 to 65335. If you don't provide a value,
Google Cloud assigns a priority of 100 to the ranges.
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
-
enable
↔ Output<
bool?> -
The status of the BGP peer connection. If set to false, any active session
with the peer is terminated and all associated routing information is removed.
If set to true, the peer connection can be established with routing information.
The default is true.
latefinal
-
enableIpv4
↔ Output<
bool> -
Enable IPv4 traffic over BGP Peer. It is enabled by default if the peerIpAddress is version 4.
latefinal
-
enableIpv6
↔ Output<
bool?> -
Enable IPv6 traffic over BGP Peer. If not specified, it is disabled by default.
latefinal
-
exportPolicies
↔ Output<
List< String> ?> -
(Optional, Beta)
routers.list of export policies applied to this peer, in the order they must be evaluated.
The name must correspond to an existing policy that has ROUTE_POLICY_TYPE_EXPORT type.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
-
importPolicies
↔ Output<
List< String> ?> -
(Optional, Beta)
routers.list of import policies applied to this peer, in the order they must be evaluated.
The name must correspond to an existing policy that has ROUTE_POLICY_TYPE_IMPORT type.
latefinal
-
interface
↔ Output<
String> -
Name of the interface the BGP peer is associated with.
latefinal
-
ipAddress
↔ Output<
String> -
IP address of the interface inside Google Cloud Platform.
Only IPv4 is supported.
latefinal
-
ipv4NexthopAddress
↔ Output<
String> -
IPv4 address of the interface inside Google Cloud Platform.
latefinal
-
ipv6NexthopAddress
↔ Output<
String> -
IPv6 address of the interface inside Google Cloud Platform.
The address must be in the range 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64.
If you do not specify the next hop addresses, Google Cloud automatically
assigns unused addresses from the 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64 range for you.
latefinal
-
isAdvertisedRoutePrioritySet
↔ Output<
bool> -
An internal boolean field for provider use for zero_advertised_route_priority.
latefinal
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
-
isCustomLearnedPrioritySet
↔ Output<
bool> -
An internal boolean field for provider use.
latefinal
- 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
-
managementType
↔ Output<
String> -
The resource that configures and manages this BGP peer.
latefinal
-
md5AuthenticationKey
↔ Output<
RouterPeerMd5AuthenticationKey?> -
Configuration for MD5 authentication on the BGP session.
Structure is documented below.
latefinal
-
name
↔ Output<
String> -
Name of this BGP peer. 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 -
peerAsn
↔ Output<
int> -
Peer BGP Autonomous System Number (ASN).
Each BGP interface may use a different value.
latefinal
-
peerIpAddress
↔ Output<
String> -
IP address of the BGP interface outside Google Cloud Platform.
Only IPv4 is supported. Required if
ipAddressis set.latefinal -
peerIpv4NexthopAddress
↔ Output<
String> -
IPv4 address of the BGP interface outside Google Cloud Platform.
latefinal
-
peerIpv6NexthopAddress
↔ Output<
String> -
IPv6 address of the BGP interface outside Google Cloud Platform.
The address must be in the range 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64.
If you do not specify the next hop addresses, Google Cloud automatically
assigns unused addresses from the 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64 range for you.
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
-
region
↔ Output<
String> -
Region where the router and BgpPeer reside.
If it is not provided, the provider region is used.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
-
router
↔ Output<
String> -
The name of the Cloud Router in which this BgpPeer will be configured.
latefinal
-
routerApplianceInstance
↔ Output<
String?> -
The URI of the VM instance that is used as third-party router appliances
such as Next Gen Firewalls, Virtual Routers, or Router Appliances.
The VM instance must be located in zones contained in the same region as
this Cloud Router. The VM instance is the peer side of the BGP session.
latefinal
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
urn
↔ Output<
String> -
latefinalinherited
-
zeroAdvertisedRoutePriority
↔ Output<
bool?> -
The user-defined zero-advertised-route-priority for a advertised-route-priority in BGP session.
This value has to be set true to force the advertisedRoutePriority to be 0.
latefinal
-
zeroCustomLearnedRoutePriority
↔ Output<
bool?> -
The user-defined zero-custom-learned-route-priority for a custom-learned-route-priority in BGP session.
This value has to be set true to force the customLearnedRoutePriority to be 0.
latefinal
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, {RouterPeerState? state, CustomResourceOptions? options}) → RouterPeer -
Gets an existing RouterPeer resource's state with the given
nameandid.