pulumi-aws-kotlin/com.pulumi.aws.directconnect.kotlin/HostedPrivateVirtualInterfaceAccepterArgs

HostedPrivateVirtualInterfaceAccepterArgs

data class HostedPrivateVirtualInterfaceAccepterArgs(val dxGatewayId: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val virtualInterfaceId: Output<String>? = null, val vpnGatewayId: Output<String>? = null) : ConvertibleToJava<HostedPrivateVirtualInterfaceAccepterArgs>

Provides a resource to manage the accepter's side of a Direct Connect hosted private virtual interface. This resource accepts ownership of a private virtual interface created by another AWS account.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const accepter = aws.getCallerIdentity({});
// Accepter's side of the VIF.
const vpnGw = new aws.ec2.VpnGateway("vpn_gw", {});
// Creator's side of the VIF
const creator = new aws.directconnect.HostedPrivateVirtualInterface("creator", {
    connectionId: "dxcon-zzzzzzzz",
    ownerAccountId: accepter.then(accepter => accepter.accountId),
    name: "vif-foo",
    vlan: 4094,
    addressFamily: "ipv4",
    bgpAsn: 65352,
}, {
    dependsOn: [vpnGw],
});
const accepterHostedPrivateVirtualInterfaceAccepter = new aws.directconnect.HostedPrivateVirtualInterfaceAccepter("accepter", {
    virtualInterfaceId: creator.id,
    vpnGatewayId: vpnGw.id,
    tags: {
        Side: "Accepter",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
accepter = aws.get_caller_identity()
# Accepter's side of the VIF.
vpn_gw = aws.ec2.VpnGateway("vpn_gw")
# Creator's side of the VIF
creator = aws.directconnect.HostedPrivateVirtualInterface("creator",
    connection_id="dxcon-zzzzzzzz",
    owner_account_id=accepter.account_id,
    name="vif-foo",
    vlan=4094,
    address_family="ipv4",
    bgp_asn=65352,
    opts = pulumi.ResourceOptions(depends_on=[vpn_gw]))
accepter_hosted_private_virtual_interface_accepter = aws.directconnect.HostedPrivateVirtualInterfaceAccepter("accepter",
    virtual_interface_id=creator.id,
    vpn_gateway_id=vpn_gw.id,
    tags={
        "Side": "Accepter",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var accepter = Aws.GetCallerIdentity.Invoke();
    // Accepter's side of the VIF.
    var vpnGw = new Aws.Ec2.VpnGateway("vpn_gw");
    // Creator's side of the VIF
    var creator = new Aws.DirectConnect.HostedPrivateVirtualInterface("creator", new()
    {
        ConnectionId = "dxcon-zzzzzzzz",
        OwnerAccountId = accepter.Apply(getCallerIdentityResult => getCallerIdentityResult.AccountId),
        Name = "vif-foo",
        Vlan = 4094,
        AddressFamily = "ipv4",
        BgpAsn = 65352,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            vpnGw,
        },
    });
    var accepterHostedPrivateVirtualInterfaceAccepter = new Aws.DirectConnect.HostedPrivateVirtualInterfaceAccepter("accepter", new()
    {
        VirtualInterfaceId = creator.Id,
        VpnGatewayId = vpnGw.Id,
        Tags =
        {
            { "Side", "Accepter" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/directconnect"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		accepter, err := aws.GetCallerIdentity(ctx, &aws.GetCallerIdentityArgs{}, nil)
		if err != nil {
			return err
		}
		// Accepter's side of the VIF.
		vpnGw, err := ec2.NewVpnGateway(ctx, "vpn_gw", nil)
		if err != nil {
			return err
		}
		// Creator's side of the VIF
		creator, err := directconnect.NewHostedPrivateVirtualInterface(ctx, "creator", &directconnect.HostedPrivateVirtualInterfaceArgs{
			ConnectionId:   pulumi.String("dxcon-zzzzzzzz"),
			OwnerAccountId: pulumi.String(accepter.AccountId),
			Name:           pulumi.String("vif-foo"),
			Vlan:           pulumi.Int(4094),
			AddressFamily:  pulumi.String("ipv4"),
			BgpAsn:         pulumi.Int(65352),
		}, pulumi.DependsOn([]pulumi.Resource{
			vpnGw,
		}))
		if err != nil {
			return err
		}
		_, err = directconnect.NewHostedPrivateVirtualInterfaceAccepter(ctx, "accepter", &directconnect.HostedPrivateVirtualInterfaceAccepterArgs{
			VirtualInterfaceId: creator.ID(),
			VpnGatewayId:       vpnGw.ID(),
			Tags: pulumi.StringMap{
				"Side": pulumi.String("Accepter"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetCallerIdentityArgs;
import com.pulumi.aws.ec2.VpnGateway;
import com.pulumi.aws.directconnect.HostedPrivateVirtualInterface;
import com.pulumi.aws.directconnect.HostedPrivateVirtualInterfaceArgs;
import com.pulumi.aws.directconnect.HostedPrivateVirtualInterfaceAccepter;
import com.pulumi.aws.directconnect.HostedPrivateVirtualInterfaceAccepterArgs;
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 accepter = AwsFunctions.getCallerIdentity(GetCallerIdentityArgs.builder()
            .build());
        // Accepter's side of the VIF.
        var vpnGw = new VpnGateway("vpnGw");
        // Creator's side of the VIF
        var creator = new HostedPrivateVirtualInterface("creator", HostedPrivateVirtualInterfaceArgs.builder()
            .connectionId("dxcon-zzzzzzzz")
            .ownerAccountId(accepter.accountId())
            .name("vif-foo")
            .vlan(4094)
            .addressFamily("ipv4")
            .bgpAsn(65352)
            .build(), CustomResourceOptions.builder()
                .dependsOn(vpnGw)
                .build());
        var accepterHostedPrivateVirtualInterfaceAccepter = new HostedPrivateVirtualInterfaceAccepter("accepterHostedPrivateVirtualInterfaceAccepter", HostedPrivateVirtualInterfaceAccepterArgs.builder()
            .virtualInterfaceId(creator.id())
            .vpnGatewayId(vpnGw.id())
            .tags(Map.of("Side", "Accepter"))
            .build());
    }
}
Content copied to clipboard
resources:
  # Creator's side of the VIF
  creator:
    type: aws:directconnect:HostedPrivateVirtualInterface
    properties:
      connectionId: dxcon-zzzzzzzz
      ownerAccountId: ${accepter.accountId}
      name: vif-foo
      vlan: 4094
      addressFamily: ipv4
      bgpAsn: 65352 # The aws_dx_hosted_private_virtual_interface
      #   # must be destroyed before the aws_vpn_gateway.
    options:
      dependsOn:
        - ${vpnGw}
  # Accepter's side of the VIF.
  vpnGw:
    type: aws:ec2:VpnGateway
    name: vpn_gw
  accepterHostedPrivateVirtualInterfaceAccepter:
    type: aws:directconnect:HostedPrivateVirtualInterfaceAccepter
    name: accepter
    properties:
      virtualInterfaceId: ${creator.id}
      vpnGatewayId: ${vpnGw.id}
      tags:
        Side: Accepter
variables:
  accepter:
    fn::invoke:
      function: aws:getCallerIdentity
      arguments: {}
Content copied to clipboard

Import

Using pulumi import, import Direct Connect hosted private virtual interfaces using the VIF id. For example:

$ pulumi import aws:directconnect/hostedPrivateVirtualInterfaceAccepter:HostedPrivateVirtualInterfaceAccepter test dxvif-33cc44dd
Content copied to clipboard

Constructors

constructor(dxGatewayId: Output<String>? = null, tags: Output<Map<String, String>>? = null, virtualInterfaceId: Output<String>? = null, vpnGatewayId: Output<String>? = null)

Properties

Link copied to clipboard
val dxGatewayId: Output<String>? = null

The ID of the Direct Connect gateway to which to connect the virtual interface.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A map of tags to assign to the resource. .If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val virtualInterfaceId: Output<String>? = null

The ID of the Direct Connect virtual interface to accept.

Link copied to clipboard
val vpnGatewayId: Output<String>? = null

The ID of the virtual private gateway to which to connect the virtual interface.

Functions

Link copied to clipboard
open override fun toJava(): HostedPrivateVirtualInterfaceAccepterArgs