ConnectPeer class

Manages an AWS Network Manager Connect Peer.

Use this resource to create a Connect peer in AWS Network Manager. Connect peers establish BGP sessions with your on-premises networks through Connect attachments, enabling dynamic routing between your core network and external networks.

Example Usage

Basic Usage

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

const example = new aws.networkmanager.VpcAttachment("example", {
    subnetArns: exampleAwsSubnet.map(__item => __item.arn),
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    vpcArn: exampleAwsVpc.arn,
});
const exampleConnectAttachment = new aws.networkmanager.ConnectAttachment("example", {
    options: {
        protocol: "GRE",
    },
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    transportAttachmentId: example.id,
    edgeLocation: example.edgeLocation,
});
const exampleConnectPeer = new aws.networkmanager.ConnectPeer("example", {
    bgpOptions: {
        peerAsn: "65000",
    },
    connectAttachmentId: exampleConnectAttachment.id,
    peerAddress: "127.0.0.1",
    insideCidrBlocks: ["172.16.0.0/16"],
});
import pulumi
import pulumi_aws as aws

example = aws.networkmanager.VpcAttachment("example",
    subnet_arns=[__item["arn"] for __item in example_aws_subnet],
    core_network_id=example_awscc_networkmanager_core_network["id"],
    vpc_arn=example_aws_vpc["arn"])
example_connect_attachment = aws.networkmanager.ConnectAttachment("example",
    options={
        "protocol": "GRE",
    },
    core_network_id=example_awscc_networkmanager_core_network["id"],
    transport_attachment_id=example.id,
    edge_location=example.edge_location)
example_connect_peer = aws.networkmanager.ConnectPeer("example",
    bgp_options={
        "peer_asn": "65000",
    },
    connect_attachment_id=example_connect_attachment.id,
    peer_address="127.0.0.1",
    inside_cidr_blocks=["172.16.0.0/16"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.NetworkManager.VpcAttachment("example", new()
    {
        SubnetArns = exampleAwsSubnet.Select(__item => __item.Arn).ToList(),
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        VpcArn = exampleAwsVpc.Arn,
    });

    var exampleConnectAttachment = new Aws.NetworkManager.ConnectAttachment("example", new()
    {
        Options = new Aws.NetworkManager.Inputs.ConnectAttachmentOptionsArgs
        {
            Protocol = "GRE",
        },
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        TransportAttachmentId = example.Id,
        EdgeLocation = example.EdgeLocation,
    });

    var exampleConnectPeer = new Aws.NetworkManager.ConnectPeer("example", new()
    {
        BgpOptions = new Aws.NetworkManager.Inputs.ConnectPeerBgpOptionsArgs
        {
            PeerAsn = "65000",
        },
        ConnectAttachmentId = exampleConnectAttachment.Id,
        PeerAddress = "127.0.0.1",
        InsideCidrBlocks = new[]
        {
            "172.16.0.0/16",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/networkmanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range exampleAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["arn"])
}
example, err := networkmanager.NewVpcAttachment(ctx, "example", &networkmanager.VpcAttachmentArgs{
SubnetArns: toPulumiArray(splat0),
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
VpcArn: pulumi.Any(exampleAwsVpc.Arn),
})
if err != nil {
return err
}
exampleConnectAttachment, err := networkmanager.NewConnectAttachment(ctx, "example", &networkmanager.ConnectAttachmentArgs{
Options: &networkmanager.ConnectAttachmentOptionsArgs{
Protocol: pulumi.String("GRE"),
},
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
TransportAttachmentId: example.ID().ToIDOutput().ToStringOutput(),
EdgeLocation: example.EdgeLocation,
})
if err != nil {
return err
}
_, err = networkmanager.NewConnectPeer(ctx, "example", &networkmanager.ConnectPeerArgs{
BgpOptions: &networkmanager.ConnectPeerBgpOptionsArgs{
PeerAsn: pulumi.String("65000"),
},
ConnectAttachmentId: exampleConnectAttachment.ID().ToIDOutput().ToStringOutput(),
PeerAddress: pulumi.String("127.0.0.1"),
InsideCidrBlocks: pulumi.StringArray{
pulumi.String("172.16.0.0/16"),
},
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_networkmanager_vpcattachment" "example" {
  subnet_arns     = exampleAwsSubnet[*].arn
  core_network_id = exampleAwsccNetworkmanagerCoreNetwork.id
  vpc_arn         = exampleAwsVpc.arn
}
resource "aws_networkmanager_connectattachment" "example" {
  options = {
    protocol = "GRE"
  }
  core_network_id         = exampleAwsccNetworkmanagerCoreNetwork.id
  transport_attachment_id = aws_networkmanager_vpcattachment.example.id
  edge_location           = aws_networkmanager_vpcattachment.example.edge_location
}
resource "aws_networkmanager_connectpeer" "example" {
  bgp_options = {
    peer_asn = 65000
  }
  connect_attachment_id = aws_networkmanager_connectattachment.example.id
  peer_address          = "127.0.0.1"
  inside_cidr_blocks    = ["172.16.0.0/16"]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.networkmanager.VpcAttachment;
import com.pulumi.aws.networkmanager.VpcAttachmentArgs;
import com.pulumi.aws.networkmanager.ConnectAttachment;
import com.pulumi.aws.networkmanager.ConnectAttachmentArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectAttachmentOptionsArgs;
import com.pulumi.aws.networkmanager.ConnectPeer;
import com.pulumi.aws.networkmanager.ConnectPeerArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectPeerBgpOptionsArgs;
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 example = new VpcAttachment("example", VpcAttachmentArgs.builder()
            .subnetArns(exampleAwsSubnet.stream().map(element -> element.arn()).collect(toList()))
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .vpcArn(exampleAwsVpc.arn())
            .build());

        var exampleConnectAttachment = new ConnectAttachment("exampleConnectAttachment", ConnectAttachmentArgs.builder()
            .options(ConnectAttachmentOptionsArgs.builder()
                .protocol("GRE")
                .build())
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .transportAttachmentId(example.id())
            .edgeLocation(example.edgeLocation())
            .build());

        var exampleConnectPeer = new ConnectPeer("exampleConnectPeer", ConnectPeerArgs.builder()
            .bgpOptions(ConnectPeerBgpOptionsArgs.builder()
                .peerAsn("65000")
                .build())
            .connectAttachmentId(exampleConnectAttachment.id())
            .peerAddress("127.0.0.1")
            .insideCidrBlocks("172.16.0.0/16")
            .build());

    }
}

Usage with attachment accepter

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

const example = new aws.networkmanager.VpcAttachment("example", {
    subnetArns: exampleAwsSubnet.map(__item => __item.arn),
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    vpcArn: exampleAwsVpc.arn,
});
const exampleAttachmentAccepter = new aws.networkmanager.AttachmentAccepter("example", {
    attachmentId: example.id,
    attachmentType: example.attachmentType,
});
const exampleConnectAttachment = new aws.networkmanager.ConnectAttachment("example", {
    options: {
        protocol: "GRE",
    },
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    transportAttachmentId: example.id,
    edgeLocation: example.edgeLocation,
}, {
    dependsOn: [exampleAttachmentAccepter],
});
const example2 = new aws.networkmanager.AttachmentAccepter("example2", {
    attachmentId: exampleConnectAttachment.id,
    attachmentType: exampleConnectAttachment.attachmentType,
});
const exampleConnectPeer = new aws.networkmanager.ConnectPeer("example", {
    bgpOptions: {
        peerAsn: "65500",
    },
    connectAttachmentId: exampleConnectAttachment.id,
    peerAddress: "127.0.0.1",
    insideCidrBlocks: ["172.16.0.0/16"],
}, {
    dependsOn: [example2],
});
import pulumi
import pulumi_aws as aws

example = aws.networkmanager.VpcAttachment("example",
    subnet_arns=[__item["arn"] for __item in example_aws_subnet],
    core_network_id=example_awscc_networkmanager_core_network["id"],
    vpc_arn=example_aws_vpc["arn"])
example_attachment_accepter = aws.networkmanager.AttachmentAccepter("example",
    attachment_id=example.id,
    attachment_type=example.attachment_type)
example_connect_attachment = aws.networkmanager.ConnectAttachment("example",
    options={
        "protocol": "GRE",
    },
    core_network_id=example_awscc_networkmanager_core_network["id"],
    transport_attachment_id=example.id,
    edge_location=example.edge_location,
    opts = pulumi.ResourceOptions(depends_on=[example_attachment_accepter]))
example2 = aws.networkmanager.AttachmentAccepter("example2",
    attachment_id=example_connect_attachment.id,
    attachment_type=example_connect_attachment.attachment_type)
example_connect_peer = aws.networkmanager.ConnectPeer("example",
    bgp_options={
        "peer_asn": "65500",
    },
    connect_attachment_id=example_connect_attachment.id,
    peer_address="127.0.0.1",
    inside_cidr_blocks=["172.16.0.0/16"],
    opts = pulumi.ResourceOptions(depends_on=[example2]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.NetworkManager.VpcAttachment("example", new()
    {
        SubnetArns = exampleAwsSubnet.Select(__item => __item.Arn).ToList(),
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        VpcArn = exampleAwsVpc.Arn,
    });

    var exampleAttachmentAccepter = new Aws.NetworkManager.AttachmentAccepter("example", new()
    {
        AttachmentId = example.Id,
        AttachmentType = example.AttachmentType,
    });

    var exampleConnectAttachment = new Aws.NetworkManager.ConnectAttachment("example", new()
    {
        Options = new Aws.NetworkManager.Inputs.ConnectAttachmentOptionsArgs
        {
            Protocol = "GRE",
        },
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        TransportAttachmentId = example.Id,
        EdgeLocation = example.EdgeLocation,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAttachmentAccepter,
        },
    });

    var example2 = new Aws.NetworkManager.AttachmentAccepter("example2", new()
    {
        AttachmentId = exampleConnectAttachment.Id,
        AttachmentType = exampleConnectAttachment.AttachmentType,
    });

    var exampleConnectPeer = new Aws.NetworkManager.ConnectPeer("example", new()
    {
        BgpOptions = new Aws.NetworkManager.Inputs.ConnectPeerBgpOptionsArgs
        {
            PeerAsn = "65500",
        },
        ConnectAttachmentId = exampleConnectAttachment.Id,
        PeerAddress = "127.0.0.1",
        InsideCidrBlocks = new[]
        {
            "172.16.0.0/16",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            example2,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/networkmanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range exampleAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["arn"])
}
example, err := networkmanager.NewVpcAttachment(ctx, "example", &networkmanager.VpcAttachmentArgs{
SubnetArns: toPulumiArray(splat0),
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
VpcArn: pulumi.Any(exampleAwsVpc.Arn),
})
if err != nil {
return err
}
exampleAttachmentAccepter, err := networkmanager.NewAttachmentAccepter(ctx, "example", &networkmanager.AttachmentAccepterArgs{
AttachmentId: example.ID().ToIDOutput().ToStringOutput(),
AttachmentType: example.AttachmentType,
})
if err != nil {
return err
}
exampleConnectAttachment, err := networkmanager.NewConnectAttachment(ctx, "example", &networkmanager.ConnectAttachmentArgs{
Options: &networkmanager.ConnectAttachmentOptionsArgs{
Protocol: pulumi.String("GRE"),
},
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
TransportAttachmentId: example.ID().ToIDOutput().ToStringOutput(),
EdgeLocation: example.EdgeLocation,
}, pulumi.DependsOn([]pulumi.Resource{
exampleAttachmentAccepter,
}))
if err != nil {
return err
}
example2, err := networkmanager.NewAttachmentAccepter(ctx, "example2", &networkmanager.AttachmentAccepterArgs{
AttachmentId: exampleConnectAttachment.ID().ToIDOutput().ToStringOutput(),
AttachmentType: exampleConnectAttachment.AttachmentType,
})
if err != nil {
return err
}
_, err = networkmanager.NewConnectPeer(ctx, "example", &networkmanager.ConnectPeerArgs{
BgpOptions: &networkmanager.ConnectPeerBgpOptionsArgs{
PeerAsn: pulumi.String("65500"),
},
ConnectAttachmentId: exampleConnectAttachment.ID().ToIDOutput().ToStringOutput(),
PeerAddress: pulumi.String("127.0.0.1"),
InsideCidrBlocks: pulumi.StringArray{
pulumi.String("172.16.0.0/16"),
},
}, pulumi.DependsOn([]pulumi.Resource{
example2,
}))
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_networkmanager_vpcattachment" "example" {
  subnet_arns     = exampleAwsSubnet[*].arn
  core_network_id = exampleAwsccNetworkmanagerCoreNetwork.id
  vpc_arn         = exampleAwsVpc.arn
}
resource "aws_networkmanager_attachmentaccepter" "example" {
  attachment_id   = aws_networkmanager_vpcattachment.example.id
  attachment_type = aws_networkmanager_vpcattachment.example.attachment_type
}
resource "aws_networkmanager_connectattachment" "example" {
  depends_on = [aws_networkmanager_attachmentaccepter.example]
  options = {
    protocol = "GRE"
  }
  core_network_id         = exampleAwsccNetworkmanagerCoreNetwork.id
  transport_attachment_id = aws_networkmanager_vpcattachment.example.id
  edge_location           = aws_networkmanager_vpcattachment.example.edge_location
}
resource "aws_networkmanager_attachmentaccepter" "example2" {
  attachment_id   = aws_networkmanager_connectattachment.example.id
  attachment_type = aws_networkmanager_connectattachment.example.attachment_type
}
resource "aws_networkmanager_connectpeer" "example" {
  depends_on = [aws_networkmanager_attachmentaccepter.example2]
  bgp_options = {
    peer_asn = 65500
  }
  connect_attachment_id = aws_networkmanager_connectattachment.example.id
  peer_address          = "127.0.0.1"
  inside_cidr_blocks    = ["172.16.0.0/16"]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.networkmanager.VpcAttachment;
import com.pulumi.aws.networkmanager.VpcAttachmentArgs;
import com.pulumi.aws.networkmanager.AttachmentAccepter;
import com.pulumi.aws.networkmanager.AttachmentAccepterArgs;
import com.pulumi.aws.networkmanager.ConnectAttachment;
import com.pulumi.aws.networkmanager.ConnectAttachmentArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectAttachmentOptionsArgs;
import com.pulumi.aws.networkmanager.ConnectPeer;
import com.pulumi.aws.networkmanager.ConnectPeerArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectPeerBgpOptionsArgs;
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 example = new VpcAttachment("example", VpcAttachmentArgs.builder()
            .subnetArns(exampleAwsSubnet.stream().map(element -> element.arn()).collect(toList()))
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .vpcArn(exampleAwsVpc.arn())
            .build());

        var exampleAttachmentAccepter = new AttachmentAccepter("exampleAttachmentAccepter", AttachmentAccepterArgs.builder()
            .attachmentId(example.id())
            .attachmentType(example.attachmentType())
            .build());

        var exampleConnectAttachment = new ConnectAttachment("exampleConnectAttachment", ConnectAttachmentArgs.builder()
            .options(ConnectAttachmentOptionsArgs.builder()
                .protocol("GRE")
                .build())
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .transportAttachmentId(example.id())
            .edgeLocation(example.edgeLocation())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAttachmentAccepter)
                .build());

        var example2 = new AttachmentAccepter("example2", AttachmentAccepterArgs.builder()
            .attachmentId(exampleConnectAttachment.id())
            .attachmentType(exampleConnectAttachment.attachmentType())
            .build());

        var exampleConnectPeer = new ConnectPeer("exampleConnectPeer", ConnectPeerArgs.builder()
            .bgpOptions(ConnectPeerBgpOptionsArgs.builder()
                .peerAsn("65500")
                .build())
            .connectAttachmentId(exampleConnectAttachment.id())
            .peerAddress("127.0.0.1")
            .insideCidrBlocks("172.16.0.0/16")
            .build(), CustomResourceOptions.builder()
                .dependsOn(example2)
                .build());

    }
}

Usage with a Tunnel-less Connect attachment

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

const example = new aws.networkmanager.VpcAttachment("example", {
    subnetArns: exampleAwsSubnet.map(__item => __item.arn),
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    vpcArn: exampleAwsVpc.arn,
});
const exampleConnectAttachment = new aws.networkmanager.ConnectAttachment("example", {
    options: {
        protocol: "NO_ENCAP",
    },
    coreNetworkId: exampleAwsccNetworkmanagerCoreNetwork.id,
    transportAttachmentId: example.id,
    edgeLocation: example.edgeLocation,
});
const exampleConnectPeer = new aws.networkmanager.ConnectPeer("example", {
    bgpOptions: {
        peerAsn: "65000",
    },
    connectAttachmentId: exampleConnectAttachment.id,
    peerAddress: "127.0.0.1",
    subnetArn: example2.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.networkmanager.VpcAttachment("example",
    subnet_arns=[__item["arn"] for __item in example_aws_subnet],
    core_network_id=example_awscc_networkmanager_core_network["id"],
    vpc_arn=example_aws_vpc["arn"])
example_connect_attachment = aws.networkmanager.ConnectAttachment("example",
    options={
        "protocol": "NO_ENCAP",
    },
    core_network_id=example_awscc_networkmanager_core_network["id"],
    transport_attachment_id=example.id,
    edge_location=example.edge_location)
example_connect_peer = aws.networkmanager.ConnectPeer("example",
    bgp_options={
        "peer_asn": "65000",
    },
    connect_attachment_id=example_connect_attachment.id,
    peer_address="127.0.0.1",
    subnet_arn=example2["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.NetworkManager.VpcAttachment("example", new()
    {
        SubnetArns = exampleAwsSubnet.Select(__item => __item.Arn).ToList(),
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        VpcArn = exampleAwsVpc.Arn,
    });

    var exampleConnectAttachment = new Aws.NetworkManager.ConnectAttachment("example", new()
    {
        Options = new Aws.NetworkManager.Inputs.ConnectAttachmentOptionsArgs
        {
            Protocol = "NO_ENCAP",
        },
        CoreNetworkId = exampleAwsccNetworkmanagerCoreNetwork.Id,
        TransportAttachmentId = example.Id,
        EdgeLocation = example.EdgeLocation,
    });

    var exampleConnectPeer = new Aws.NetworkManager.ConnectPeer("example", new()
    {
        BgpOptions = new Aws.NetworkManager.Inputs.ConnectPeerBgpOptionsArgs
        {
            PeerAsn = "65000",
        },
        ConnectAttachmentId = exampleConnectAttachment.Id,
        PeerAddress = "127.0.0.1",
        SubnetArn = example2.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/networkmanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range exampleAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["arn"])
}
example, err := networkmanager.NewVpcAttachment(ctx, "example", &networkmanager.VpcAttachmentArgs{
SubnetArns: toPulumiArray(splat0),
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
VpcArn: pulumi.Any(exampleAwsVpc.Arn),
})
if err != nil {
return err
}
exampleConnectAttachment, err := networkmanager.NewConnectAttachment(ctx, "example", &networkmanager.ConnectAttachmentArgs{
Options: &networkmanager.ConnectAttachmentOptionsArgs{
Protocol: pulumi.String("NO_ENCAP"),
},
CoreNetworkId: pulumi.Any(exampleAwsccNetworkmanagerCoreNetwork.Id),
TransportAttachmentId: example.ID().ToIDOutput().ToStringOutput(),
EdgeLocation: example.EdgeLocation,
})
if err != nil {
return err
}
_, err = networkmanager.NewConnectPeer(ctx, "example", &networkmanager.ConnectPeerArgs{
BgpOptions: &networkmanager.ConnectPeerBgpOptionsArgs{
PeerAsn: pulumi.String("65000"),
},
ConnectAttachmentId: exampleConnectAttachment.ID().ToIDOutput().ToStringOutput(),
PeerAddress: pulumi.String("127.0.0.1"),
SubnetArn: pulumi.Any(example2.Arn),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_networkmanager_vpcattachment" "example" {
  subnet_arns     = exampleAwsSubnet[*].arn
  core_network_id = exampleAwsccNetworkmanagerCoreNetwork.id
  vpc_arn         = exampleAwsVpc.arn
}
resource "aws_networkmanager_connectattachment" "example" {
  options = {
    protocol = "NO_ENCAP"
  }
  core_network_id         = exampleAwsccNetworkmanagerCoreNetwork.id
  transport_attachment_id = aws_networkmanager_vpcattachment.example.id
  edge_location           = aws_networkmanager_vpcattachment.example.edge_location
}
resource "aws_networkmanager_connectpeer" "example" {
  bgp_options = {
    peer_asn = 65000
  }
  connect_attachment_id = aws_networkmanager_connectattachment.example.id
  peer_address          = "127.0.0.1"
  subnet_arn            = example2.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.networkmanager.VpcAttachment;
import com.pulumi.aws.networkmanager.VpcAttachmentArgs;
import com.pulumi.aws.networkmanager.ConnectAttachment;
import com.pulumi.aws.networkmanager.ConnectAttachmentArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectAttachmentOptionsArgs;
import com.pulumi.aws.networkmanager.ConnectPeer;
import com.pulumi.aws.networkmanager.ConnectPeerArgs;
import com.pulumi.aws.networkmanager.inputs.ConnectPeerBgpOptionsArgs;
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 example = new VpcAttachment("example", VpcAttachmentArgs.builder()
            .subnetArns(exampleAwsSubnet.stream().map(element -> element.arn()).collect(toList()))
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .vpcArn(exampleAwsVpc.arn())
            .build());

        var exampleConnectAttachment = new ConnectAttachment("exampleConnectAttachment", ConnectAttachmentArgs.builder()
            .options(ConnectAttachmentOptionsArgs.builder()
                .protocol("NO_ENCAP")
                .build())
            .coreNetworkId(exampleAwsccNetworkmanagerCoreNetwork.id())
            .transportAttachmentId(example.id())
            .edgeLocation(example.edgeLocation())
            .build());

        var exampleConnectPeer = new ConnectPeer("exampleConnectPeer", ConnectPeerArgs.builder()
            .bgpOptions(ConnectPeerBgpOptionsArgs.builder()
                .peerAsn("65000")
                .build())
            .connectAttachmentId(exampleConnectAttachment.id())
            .peerAddress("127.0.0.1")
            .subnetArn(example2.arn())
            .build());

    }
}

Import

Using pulumi import, import aws.networkmanager.ConnectPeer using the connect peer ID. For example:

$ pulumi import aws:networkmanager/connectPeer:ConnectPeer example connect-peer-061f3e96275db1acc

Constructors

ConnectPeer(String name, {ConnectPeerArgs? args, CustomResourceOptions? options})
Creates a new ConnectPeer. name The Pulumi resource name. args Arguments used to configure this ConnectPeer. The set of arguments for ConnectPeer. options Resource options controlling this resource's behavior.
ConnectPeer.reference(String urn)
Creates a typed reference to an existing ConnectPeer resource.

Properties

arn ↔ Output<String>
ARN of the Connect peer.
latefinal
bgpOptions ↔ Output<ConnectPeerBgpOptions>
Connect peer BGP options. See bgpOptions for more information.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
configurations ↔ Output<List<ConnectPeerConfiguration>>
Configuration of the Connect peer.
latefinal
connectAttachmentId ↔ Output<String>
ID of the connection attachment.
latefinal
connectPeerId ↔ Output<String>
ID of the Connect peer.
latefinal
coreNetworkAddress ↔ Output<String?>
Connect peer core network address.
latefinal
coreNetworkId ↔ Output<String>
ID of a core network.
latefinal
createdAt ↔ Output<String>
Timestamp when the Connect peer was created.
latefinal
edgeLocation ↔ Output<String>
Region where the peer is located.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
insideCidrBlocks ↔ Output<List<String>?>
Inside IP addresses used for BGP peering. Required when the Connect attachment protocol is GRE. See aws.networkmanager.ConnectAttachment for details.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
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
peerAddress ↔ Output<String>
Connect peer address.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
state ↔ Output<String>
State of the Connect peer.
latefinal
subnetArn ↔ Output<String?>
Subnet ARN for the Connect peer. Required when the Connect attachment protocol is NO_ENCAP. See aws.networkmanager.ConnectAttachment for details.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value tags for the attachment. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

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, {ConnectPeerState? state, CustomResourceOptions? options}) → ConnectPeer
Gets an existing ConnectPeer resource's state with the given name and id.