alicloud.vpc.RouterInterfaceConnection

using System.Collections.Generic;
using Pulumi;
using AliCloud = Pulumi.AliCloud;

return await Deployment.RunAsync(() => 
{
    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()
    {
        VpcName = name,
        CidrBlock = "172.16.0.0/12",
    });

    var barNetwork = new AliCloud.Vpc.Network("barNetwork", new()
    {
        VpcName = name,
        CidrBlock = "192.168.0.0/16",
    }, new CustomResourceOptions
    {
        Provider = alicloud,
    });

    var initiate = new AliCloud.Vpc.RouterInterface("initiate", new()
    {
        OppositeRegion = region,
        RouterType = "VRouter",
        RouterId = fooNetwork.RouterId,
        Role = "InitiatingSide",
        Specification = "Large.2",
        Description = name,
        InstanceChargeType = "PostPaid",
    });

    var opposite = new AliCloud.Vpc.RouterInterface("opposite", new()
    {
        OppositeRegion = region,
        RouterType = "VRouter",
        RouterId = barNetwork.RouterId,
        Role = "AcceptingSide",
        Specification = "Large.1",
        Description = $"{name}-opposite",
    }, new CustomResourceOptions
    {
        Provider = alicloud,
    });

    var barRouterInterfaceConnection = new AliCloud.Vpc.RouterInterfaceConnection("barRouterInterfaceConnection", new()
    {
        InterfaceId = opposite.Id,
        OppositeInterfaceId = initiate.Id,
    }, new CustomResourceOptions
    {
        Provider = alicloud,
    });

    // A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
    var fooRouterInterfaceConnection = new AliCloud.Vpc.RouterInterfaceConnection("fooRouterInterfaceConnection", new()
    {
        InterfaceId = initiate.Id,
        OppositeInterfaceId = opposite.Id,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            barRouterInterfaceConnection,
        },
    });

    // The connection must start from the accepting side.
});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		region := "cn-hangzhou"
		if param := cfg.Get("region"); param != "" {
			region = param
		}
		name := "alicloudRouterInterfaceConnectionBasic"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		fooNetwork, err := vpc.NewNetwork(ctx, "fooNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("172.16.0.0/12"),
		})
		if err != nil {
			return err
		}
		barNetwork, err := vpc.NewNetwork(ctx, "barNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("192.168.0.0/16"),
		}, pulumi.Provider(alicloud))
		if err != nil {
			return err
		}
		initiate, err := vpc.NewRouterInterface(ctx, "initiate", &vpc.RouterInterfaceArgs{
			OppositeRegion:     pulumi.String(region),
			RouterType:         pulumi.String("VRouter"),
			RouterId:           fooNetwork.RouterId,
			Role:               pulumi.String("InitiatingSide"),
			Specification:      pulumi.String("Large.2"),
			Description:        pulumi.String(name),
			InstanceChargeType: pulumi.String("PostPaid"),
		})
		if err != nil {
			return err
		}
		opposite, err := vpc.NewRouterInterface(ctx, "opposite", &vpc.RouterInterfaceArgs{
			OppositeRegion: pulumi.String(region),
			RouterType:     pulumi.String("VRouter"),
			RouterId:       barNetwork.RouterId,
			Role:           pulumi.String("AcceptingSide"),
			Specification:  pulumi.String("Large.1"),
			Description:    pulumi.String(fmt.Sprintf("%v-opposite", name)),
		}, pulumi.Provider(alicloud))
		if err != nil {
			return err
		}
		barRouterInterfaceConnection, err := vpc.NewRouterInterfaceConnection(ctx, "barRouterInterfaceConnection", &vpc.RouterInterfaceConnectionArgs{
			InterfaceId:         opposite.ID(),
			OppositeInterfaceId: initiate.ID(),
		}, pulumi.Provider(alicloud))
		if err != nil {
			return err
		}
		_, err = vpc.NewRouterInterfaceConnection(ctx, "fooRouterInterfaceConnection", &vpc.RouterInterfaceConnectionArgs{
			InterfaceId:         initiate.ID(),
			OppositeInterfaceId: opposite.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			barRouterInterfaceConnection,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.vpc.Network;
import com.pulumi.alicloud.vpc.NetworkArgs;
import com.pulumi.alicloud.vpc.RouterInterface;
import com.pulumi.alicloud.vpc.RouterInterfaceArgs;
import com.pulumi.alicloud.vpc.RouterInterfaceConnection;
import com.pulumi.alicloud.vpc.RouterInterfaceConnectionArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var region = config.get("region").orElse("cn-hangzhou");
        final var name = config.get("name").orElse("alicloudRouterInterfaceConnectionBasic");
        var fooNetwork = new Network("fooNetwork", NetworkArgs.builder()        
            .vpcName(name)
            .cidrBlock("172.16.0.0/12")
            .build());

        var barNetwork = new Network("barNetwork", NetworkArgs.builder()        
            .vpcName(name)
            .cidrBlock("192.168.0.0/16")
            .build(), CustomResourceOptions.builder()
                .provider(alicloud)
                .build());

        var initiate = new RouterInterface("initiate", RouterInterfaceArgs.builder()        
            .oppositeRegion(region)
            .routerType("VRouter")
            .routerId(fooNetwork.routerId())
            .role("InitiatingSide")
            .specification("Large.2")
            .description(name)
            .instanceChargeType("PostPaid")
            .build());

        var opposite = new RouterInterface("opposite", RouterInterfaceArgs.builder()        
            .oppositeRegion(region)
            .routerType("VRouter")
            .routerId(barNetwork.routerId())
            .role("AcceptingSide")
            .specification("Large.1")
            .description(String.format("%s-opposite", name))
            .build(), CustomResourceOptions.builder()
                .provider(alicloud)
                .build());

        var barRouterInterfaceConnection = new RouterInterfaceConnection("barRouterInterfaceConnection", RouterInterfaceConnectionArgs.builder()        
            .interfaceId(opposite.id())
            .oppositeInterfaceId(initiate.id())
            .build(), CustomResourceOptions.builder()
                .provider(alicloud)
                .build());

        var fooRouterInterfaceConnection = new RouterInterfaceConnection("fooRouterInterfaceConnection", RouterInterfaceConnectionArgs.builder()        
            .interfaceId(initiate.id())
            .oppositeInterfaceId(opposite.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(barRouterInterfaceConnection)
                .build());

    }
}

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",
    vpc_name=name,
    cidr_block="172.16.0.0/12")
bar_network = alicloud.vpc.Network("barNetwork",
    vpc_name=name,
    cidr_block="192.168.0.0/16",
    opts=pulumi.ResourceOptions(provider=alicloud))
initiate = alicloud.vpc.RouterInterface("initiate",
    opposite_region=region,
    router_type="VRouter",
    router_id=foo_network.router_id,
    role="InitiatingSide",
    specification="Large.2",
    description=name,
    instance_charge_type="PostPaid")
opposite = alicloud.vpc.RouterInterface("opposite",
    opposite_region=region,
    router_type="VRouter",
    router_id=bar_network.router_id,
    role="AcceptingSide",
    specification="Large.1",
    description=f"{name}-opposite",
    opts=pulumi.ResourceOptions(provider=alicloud))
bar_router_interface_connection = alicloud.vpc.RouterInterfaceConnection("barRouterInterfaceConnection",
    interface_id=opposite.id,
    opposite_interface_id=initiate.id,
    opts=pulumi.ResourceOptions(provider=alicloud))
# 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,
    opts=pulumi.ResourceOptions(depends_on=[bar_router_interface_connection]))
# The connection must start from the accepting side.

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("fooNetwork", {
    vpcName: name,
    cidrBlock: "172.16.0.0/12",
});
const barNetwork = new alicloud.vpc.Network("barNetwork", {
    vpcName: name,
    cidrBlock: "192.168.0.0/16",
}, {
    provider: alicloud,
});
const initiate = new alicloud.vpc.RouterInterface("initiate", {
    oppositeRegion: region,
    routerType: "VRouter",
    routerId: fooNetwork.routerId,
    role: "InitiatingSide",
    specification: "Large.2",
    description: name,
    instanceChargeType: "PostPaid",
});
const opposite = new alicloud.vpc.RouterInterface("opposite", {
    oppositeRegion: region,
    routerType: "VRouter",
    routerId: barNetwork.routerId,
    role: "AcceptingSide",
    specification: "Large.1",
    description: `${name}-opposite`,
}, {
    provider: alicloud,
});
const barRouterInterfaceConnection = new alicloud.vpc.RouterInterfaceConnection("barRouterInterfaceConnection", {
    interfaceId: opposite.id,
    oppositeInterfaceId: initiate.id,
}, {
    provider: alicloud,
});
// A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
const fooRouterInterfaceConnection = new alicloud.vpc.RouterInterfaceConnection("fooRouterInterfaceConnection", {
    interfaceId: initiate.id,
    oppositeInterfaceId: opposite.id,
}, {
    dependsOn: [barRouterInterfaceConnection],
});
// The connection must start from the accepting side.

configuration:
  region:
    type: string
    default: cn-hangzhou
  name:
    type: string
    default: alicloudRouterInterfaceConnectionBasic
resources:
  fooNetwork:
    type: alicloud:vpc:Network
    properties:
      vpcName: ${name}
      cidrBlock: 172.16.0.0/12
  barNetwork:
    type: alicloud:vpc:Network
    properties:
      vpcName: ${name}
      cidrBlock: 192.168.0.0/16
    options:
      provider: ${alicloud}
  initiate:
    type: alicloud:vpc:RouterInterface
    properties:
      oppositeRegion: ${region}
      routerType: VRouter
      routerId: ${fooNetwork.routerId}
      role: InitiatingSide
      specification: Large.2
      description: ${name}
      instanceChargeType: PostPaid
  opposite:
    type: alicloud:vpc:RouterInterface
    properties:
      oppositeRegion: ${region}
      routerType: VRouter
      routerId: ${barNetwork.routerId}
      role: AcceptingSide
      specification: Large.1
      description: ${name}-opposite
    options:
      provider: ${alicloud}
  # A integrated router interface connection tunnel requires both InitiatingSide and AcceptingSide configuring opposite router interface.
  fooRouterInterfaceConnection:
    type: alicloud:vpc:RouterInterfaceConnection
    properties:
      interfaceId: ${initiate.id}
      oppositeInterfaceId: ${opposite.id}
    options:
      dependson:
        - ${barRouterInterfaceConnection}
  barRouterInterfaceConnection:
    type: alicloud:vpc:RouterInterfaceConnection
    properties:
      interfaceId: ${opposite.id}
      oppositeInterfaceId: ${initiate.id}
    options:
      provider: ${alicloud}