RouterInterfaceConnection

using Pulumi;
using AliCloud = Pulumi.AliCloud;

class MyStack : Stack
{
    public MyStack()
    {
        var config = new Config();
        var region = config.Get("region") ?? "cn-hangzhou";
        var name = config.Get("name") ?? "alicloudRouterInterfaceConnectionBasic";
        var fooNetwork = new AliCloud.Vpc.Network("fooNetwork", new AliCloud.Vpc.NetworkArgs
        {
            CidrBlock = "172.16.0.0/12",
        });
        var barNetwork = new AliCloud.Vpc.Network("barNetwork", new AliCloud.Vpc.NetworkArgs
        {
            CidrBlock = "192.168.0.0/16",
        });
        var initiate = new AliCloud.Vpc.RouterInterface("initiate", new AliCloud.Vpc.RouterInterfaceArgs
        {
            Description = name,
            InstanceChargeType = "PostPaid",
            OppositeRegion = region,
            Role = "InitiatingSide",
            RouterId = fooNetwork.RouterId,
            RouterType = "VRouter",
            Specification = "Large.2",
        });
        var opposite = new AliCloud.Vpc.RouterInterface("opposite", new AliCloud.Vpc.RouterInterfaceArgs
        {
            Description = $"{name}-opposite",
            OppositeRegion = region,
            Role = "AcceptingSide",
            RouterId = barNetwork.RouterId,
            RouterType = "VRouter",
            Specification = "Large.1",
        });
        // A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
        var fooRouterInterfaceConnection = new AliCloud.Vpc.RouterInterfaceConnection("fooRouterInterfaceConnection", new AliCloud.Vpc.RouterInterfaceConnectionArgs
        {
            InterfaceId = initiate.Id,
            OppositeInterfaceId = opposite.Id,
        });
        var barRouterInterfaceConnection = new AliCloud.Vpc.RouterInterfaceConnection("barRouterInterfaceConnection", new AliCloud.Vpc.RouterInterfaceConnectionArgs
        {
            InterfaceId = opposite.Id,
            OppositeInterfaceId = initiate.Id,
        });
    }

}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
region = config.get("region")
if region is None:
    region = "cn-hangzhou"
name = config.get("name")
if name is None:
    name = "alicloudRouterInterfaceConnectionBasic"
foo_network = alicloud.vpc.Network("fooNetwork", cidr_block="172.16.0.0/12")
bar_network = alicloud.vpc.Network("barNetwork", cidr_block="192.168.0.0/16")
initiate = alicloud.vpc.RouterInterface("initiate",
    description=name,
    instance_charge_type="PostPaid",
    opposite_region=region,
    role="InitiatingSide",
    router_id=foo_network.router_id,
    router_type="VRouter",
    specification="Large.2")
opposite = alicloud.vpc.RouterInterface("opposite",
    description=f"{name}-opposite",
    opposite_region=region,
    role="AcceptingSide",
    router_id=bar_network.router_id,
    router_type="VRouter",
    specification="Large.1")
# A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
foo_router_interface_connection = alicloud.vpc.RouterInterfaceConnection("fooRouterInterfaceConnection",
    interface_id=initiate.id,
    opposite_interface_id=opposite.id)
bar_router_interface_connection = alicloud.vpc.RouterInterfaceConnection("barRouterInterfaceConnection",
    interface_id=opposite.id,
    opposite_interface_id=initiate.id)

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

const config = new pulumi.Config();
const region = config.get("region") || "cn-hangzhou";
const name = config.get("name") || "alicloudRouterInterfaceConnectionBasic";

const fooNetwork = new alicloud.vpc.Network("foo", {
    cidrBlock: "172.16.0.0/12",
});
const barNetwork = new alicloud.vpc.Network("bar", {
    cidrBlock: "192.168.0.0/16",
});
const initiate = new alicloud.vpc.RouterInterface("initiate", {
    description: name,
    instanceChargeType: "PostPaid",
    oppositeRegion: region,
    role: "InitiatingSide",
    routerId: fooNetwork.routerId,
    routerType: "VRouter",
    specification: "Large.2",
});
const opposite = new alicloud.vpc.RouterInterface("opposite", {
    description: `${name}-opposite`,
    oppositeRegion: region,
    role: "AcceptingSide",
    routerId: barNetwork.routerId,
    routerType: "VRouter",
    specification: "Large.1",
});
const barRouterInterfaceConnection = new alicloud.vpc.RouterInterfaceConnection("bar", {
    interfaceId: opposite.id,
    oppositeInterfaceId: initiate.id,
});
// A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
const fooRouterInterfaceConnection = new alicloud.vpc.RouterInterfaceConnection("foo", {
    interfaceId: initiate.id,
    oppositeInterfaceId: opposite.id,
}, { dependsOn: [barRouterInterfaceConnection] });