pulumi-azure-native-kotlin/com.pulumi.azurenative.peering.kotlin/Peering

Peering

class Peering : KotlinCustomResource

Peering is a logical representation of a set of connections to the Microsoft Cloud Edge at a location. Azure REST API version: 2022-10-01. Prior API version in Azure Native 1.x: 2021-01-01.

Example Usage

Create a direct peering

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var peering = new AzureNative.Peering.Peering("peering", new()
    {
        Direct = new AzureNative.Peering.Inputs.PeeringPropertiesDirectArgs
        {
            Connections = new[]
            {
                new AzureNative.Peering.Inputs.DirectConnectionArgs
                {
                    BandwidthInMbps = 10000,
                    BgpSession = new AzureNative.Peering.Inputs.BgpSessionArgs
                    {
                        MaxPrefixesAdvertisedV4 = 1000,
                        MaxPrefixesAdvertisedV6 = 100,
                        Md5AuthenticationKey = "test-md5-auth-key",
                        SessionPrefixV4 = "192.168.0.0/31",
                        SessionPrefixV6 = "fd00::0/127",
                    },
                    ConnectionIdentifier = "5F4CB5C7-6B43-4444-9338-9ABC72606C16",
                    PeeringDBFacilityId = 99999,
                    SessionAddressProvider = "Peer",
                    UseForPeeringService = false,
                },
                new AzureNative.Peering.Inputs.DirectConnectionArgs
                {
                    BandwidthInMbps = 10000,
                    ConnectionIdentifier = "8AB00818-D533-4504-A25A-03A17F61201C",
                    PeeringDBFacilityId = 99999,
                    SessionAddressProvider = "Microsoft",
                    UseForPeeringService = true,
                },
            },
            DirectPeeringType = "Edge",
            PeerAsn = new AzureNative.Peering.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1",
            },
        },
        Kind = "Direct",
        Location = "eastus",
        PeeringLocation = "peeringLocation0",
        PeeringName = "peeringName",
        ResourceGroupName = "rgName",
        Sku = new AzureNative.Peering.Inputs.PeeringSkuArgs
        {
            Name = "Basic_Direct_Free",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/peering/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := peering.NewPeering(ctx, "peering", &peering.PeeringArgs{
Direct: peering.PeeringPropertiesDirectResponse{
Connections: peering.DirectConnectionArray{
interface{}{
BandwidthInMbps: pulumi.Int(10000),
BgpSession: &peering.BgpSessionArgs{
MaxPrefixesAdvertisedV4: pulumi.Int(1000),
MaxPrefixesAdvertisedV6: pulumi.Int(100),
Md5AuthenticationKey: pulumi.String("test-md5-auth-key"),
SessionPrefixV4: pulumi.String("192.168.0.0/31"),
SessionPrefixV6: pulumi.String("fd00::0/127"),
},
ConnectionIdentifier: pulumi.String("5F4CB5C7-6B43-4444-9338-9ABC72606C16"),
PeeringDBFacilityId: pulumi.Int(99999),
SessionAddressProvider: pulumi.String("Peer"),
UseForPeeringService: pulumi.Bool(false),
},
&peering.DirectConnectionArgs{
BandwidthInMbps: pulumi.Int(10000),
ConnectionIdentifier: pulumi.String("8AB00818-D533-4504-A25A-03A17F61201C"),
PeeringDBFacilityId: pulumi.Int(99999),
SessionAddressProvider: pulumi.String("Microsoft"),
UseForPeeringService: pulumi.Bool(true),
},
},
DirectPeeringType: pulumi.String("Edge"),
PeerAsn: &peering.SubResourceArgs{
Id: pulumi.String("/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"),
},
},
Kind: pulumi.String("Direct"),
Location: pulumi.String("eastus"),
PeeringLocation: pulumi.String("peeringLocation0"),
PeeringName: pulumi.String("peeringName"),
ResourceGroupName: pulumi.String("rgName"),
Sku: &peering.PeeringSkuArgs{
Name: pulumi.String("Basic_Direct_Free"),
},
})
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.azurenative.peering.Peering;
import com.pulumi.azurenative.peering.PeeringArgs;
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) {
        var peering = new Peering("peering", PeeringArgs.builder()
            .direct(Map.ofEntries(
                Map.entry("connections",
                    Map.ofEntries(
                        Map.entry("bandwidthInMbps", 10000),
                        Map.entry("bgpSession", Map.ofEntries(
                            Map.entry("maxPrefixesAdvertisedV4", 1000),
                            Map.entry("maxPrefixesAdvertisedV6", 100),
                            Map.entry("md5AuthenticationKey", "test-md5-auth-key"),
                            Map.entry("sessionPrefixV4", "192.168.0.0/31"),
                            Map.entry("sessionPrefixV6", "fd00::0/127")
                        )),
                        Map.entry("connectionIdentifier", "5F4CB5C7-6B43-4444-9338-9ABC72606C16"),
                        Map.entry("peeringDBFacilityId", 99999),
                        Map.entry("sessionAddressProvider", "Peer"),
                        Map.entry("useForPeeringService", false)
                    ),
                    Map.ofEntries(
                        Map.entry("bandwidthInMbps", 10000),
                        Map.entry("connectionIdentifier", "8AB00818-D533-4504-A25A-03A17F61201C"),
                        Map.entry("peeringDBFacilityId", 99999),
                        Map.entry("sessionAddressProvider", "Microsoft"),
                        Map.entry("useForPeeringService", true)
                    )),
                Map.entry("directPeeringType", "Edge"),
                Map.entry("peerAsn", Map.of("id", "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"))
            ))
            .kind("Direct")
            .location("eastus")
            .peeringLocation("peeringLocation0")
            .peeringName("peeringName")
            .resourceGroupName("rgName")
            .sku(Map.of("name", "Basic_Direct_Free"))
            .build());
    }
}
Content copied to clipboard

Create a peering with exchange route server

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var peering = new AzureNative.Peering.Peering("peering", new()
    {
        Direct = new AzureNative.Peering.Inputs.PeeringPropertiesDirectArgs
        {
            Connections = new[]
            {
                new AzureNative.Peering.Inputs.DirectConnectionArgs
                {
                    BandwidthInMbps = 10000,
                    BgpSession = new AzureNative.Peering.Inputs.BgpSessionArgs
                    {
                        MaxPrefixesAdvertisedV4 = 1000,
                        MaxPrefixesAdvertisedV6 = 100,
                        MicrosoftSessionIPv4Address = "192.168.0.123",
                        PeerSessionIPv4Address = "192.168.0.234",
                        SessionPrefixV4 = "192.168.0.0/24",
                    },
                    ConnectionIdentifier = "5F4CB5C7-6B43-4444-9338-9ABC72606C16",
                    PeeringDBFacilityId = 99999,
                    SessionAddressProvider = "Peer",
                    UseForPeeringService = true,
                },
            },
            DirectPeeringType = "IxRs",
            PeerAsn = new AzureNative.Peering.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1",
            },
        },
        Kind = "Direct",
        Location = "eastus",
        PeeringLocation = "peeringLocation0",
        PeeringName = "peeringName",
        ResourceGroupName = "rgName",
        Sku = new AzureNative.Peering.Inputs.PeeringSkuArgs
        {
            Name = "Premium_Direct_Free",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/peering/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := peering.NewPeering(ctx, "peering", &peering.PeeringArgs{
Direct: peering.PeeringPropertiesDirectResponse{
Connections: peering.DirectConnectionArray{
interface{}{
BandwidthInMbps: pulumi.Int(10000),
BgpSession: &peering.BgpSessionArgs{
MaxPrefixesAdvertisedV4: pulumi.Int(1000),
MaxPrefixesAdvertisedV6: pulumi.Int(100),
MicrosoftSessionIPv4Address: pulumi.String("192.168.0.123"),
PeerSessionIPv4Address: pulumi.String("192.168.0.234"),
SessionPrefixV4: pulumi.String("192.168.0.0/24"),
},
ConnectionIdentifier: pulumi.String("5F4CB5C7-6B43-4444-9338-9ABC72606C16"),
PeeringDBFacilityId: pulumi.Int(99999),
SessionAddressProvider: pulumi.String("Peer"),
UseForPeeringService: pulumi.Bool(true),
},
},
DirectPeeringType: pulumi.String("IxRs"),
PeerAsn: &peering.SubResourceArgs{
Id: pulumi.String("/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"),
},
},
Kind: pulumi.String("Direct"),
Location: pulumi.String("eastus"),
PeeringLocation: pulumi.String("peeringLocation0"),
PeeringName: pulumi.String("peeringName"),
ResourceGroupName: pulumi.String("rgName"),
Sku: &peering.PeeringSkuArgs{
Name: pulumi.String("Premium_Direct_Free"),
},
})
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.azurenative.peering.Peering;
import com.pulumi.azurenative.peering.PeeringArgs;
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) {
        var peering = new Peering("peering", PeeringArgs.builder()
            .direct(Map.ofEntries(
                Map.entry("connections", Map.ofEntries(
                    Map.entry("bandwidthInMbps", 10000),
                    Map.entry("bgpSession", Map.ofEntries(
                        Map.entry("maxPrefixesAdvertisedV4", 1000),
                        Map.entry("maxPrefixesAdvertisedV6", 100),
                        Map.entry("microsoftSessionIPv4Address", "192.168.0.123"),
                        Map.entry("peerSessionIPv4Address", "192.168.0.234"),
                        Map.entry("sessionPrefixV4", "192.168.0.0/24")
                    )),
                    Map.entry("connectionIdentifier", "5F4CB5C7-6B43-4444-9338-9ABC72606C16"),
                    Map.entry("peeringDBFacilityId", 99999),
                    Map.entry("sessionAddressProvider", "Peer"),
                    Map.entry("useForPeeringService", true)
                )),
                Map.entry("directPeeringType", "IxRs"),
                Map.entry("peerAsn", Map.of("id", "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"))
            ))
            .kind("Direct")
            .location("eastus")
            .peeringLocation("peeringLocation0")
            .peeringName("peeringName")
            .resourceGroupName("rgName")
            .sku(Map.of("name", "Premium_Direct_Free"))
            .build());
    }
}
Content copied to clipboard

Create an exchange peering

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var peering = new AzureNative.Peering.Peering("peering", new()
    {
        Exchange = new AzureNative.Peering.Inputs.PeeringPropertiesExchangeArgs
        {
            Connections = new[]
            {
                new AzureNative.Peering.Inputs.ExchangeConnectionArgs
                {
                    BgpSession = new AzureNative.Peering.Inputs.BgpSessionArgs
                    {
                        MaxPrefixesAdvertisedV4 = 1000,
                        MaxPrefixesAdvertisedV6 = 100,
                        Md5AuthenticationKey = "test-md5-auth-key",
                        PeerSessionIPv4Address = "192.168.2.1",
                        PeerSessionIPv6Address = "fd00::1",
                    },
                    ConnectionIdentifier = "CE495334-0E94-4E51-8164-8116D6CD284D",
                    PeeringDBFacilityId = 99999,
                },
                new AzureNative.Peering.Inputs.ExchangeConnectionArgs
                {
                    BgpSession = new AzureNative.Peering.Inputs.BgpSessionArgs
                    {
                        MaxPrefixesAdvertisedV4 = 1000,
                        MaxPrefixesAdvertisedV6 = 100,
                        Md5AuthenticationKey = "test-md5-auth-key",
                        PeerSessionIPv4Address = "192.168.2.2",
                        PeerSessionIPv6Address = "fd00::2",
                    },
                    ConnectionIdentifier = "CDD8E673-CB07-47E6-84DE-3739F778762B",
                    PeeringDBFacilityId = 99999,
                },
            },
            PeerAsn = new AzureNative.Peering.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1",
            },
        },
        Kind = "Exchange",
        Location = "eastus",
        PeeringLocation = "peeringLocation0",
        PeeringName = "peeringName",
        ResourceGroupName = "rgName",
        Sku = new AzureNative.Peering.Inputs.PeeringSkuArgs
        {
            Name = "Basic_Exchange_Free",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/peering/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := peering.NewPeering(ctx, "peering", &peering.PeeringArgs{
Exchange: peering.PeeringPropertiesExchangeResponse{
Connections: peering.ExchangeConnectionArray{
interface{}{
BgpSession: &peering.BgpSessionArgs{
MaxPrefixesAdvertisedV4: pulumi.Int(1000),
MaxPrefixesAdvertisedV6: pulumi.Int(100),
Md5AuthenticationKey: pulumi.String("test-md5-auth-key"),
PeerSessionIPv4Address: pulumi.String("192.168.2.1"),
PeerSessionIPv6Address: pulumi.String("fd00::1"),
},
ConnectionIdentifier: pulumi.String("CE495334-0E94-4E51-8164-8116D6CD284D"),
PeeringDBFacilityId: pulumi.Int(99999),
},
interface{}{
BgpSession: &peering.BgpSessionArgs{
MaxPrefixesAdvertisedV4: pulumi.Int(1000),
MaxPrefixesAdvertisedV6: pulumi.Int(100),
Md5AuthenticationKey: pulumi.String("test-md5-auth-key"),
PeerSessionIPv4Address: pulumi.String("192.168.2.2"),
PeerSessionIPv6Address: pulumi.String("fd00::2"),
},
ConnectionIdentifier: pulumi.String("CDD8E673-CB07-47E6-84DE-3739F778762B"),
PeeringDBFacilityId: pulumi.Int(99999),
},
},
PeerAsn: &peering.SubResourceArgs{
Id: pulumi.String("/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"),
},
},
Kind: pulumi.String("Exchange"),
Location: pulumi.String("eastus"),
PeeringLocation: pulumi.String("peeringLocation0"),
PeeringName: pulumi.String("peeringName"),
ResourceGroupName: pulumi.String("rgName"),
Sku: &peering.PeeringSkuArgs{
Name: pulumi.String("Basic_Exchange_Free"),
},
})
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.azurenative.peering.Peering;
import com.pulumi.azurenative.peering.PeeringArgs;
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) {
        var peering = new Peering("peering", PeeringArgs.builder()
            .exchange(Map.ofEntries(
                Map.entry("connections",
                    Map.ofEntries(
                        Map.entry("bgpSession", Map.ofEntries(
                            Map.entry("maxPrefixesAdvertisedV4", 1000),
                            Map.entry("maxPrefixesAdvertisedV6", 100),
                            Map.entry("md5AuthenticationKey", "test-md5-auth-key"),
                            Map.entry("peerSessionIPv4Address", "192.168.2.1"),
                            Map.entry("peerSessionIPv6Address", "fd00::1")
                        )),
                        Map.entry("connectionIdentifier", "CE495334-0E94-4E51-8164-8116D6CD284D"),
                        Map.entry("peeringDBFacilityId", 99999)
                    ),
                    Map.ofEntries(
                        Map.entry("bgpSession", Map.ofEntries(
                            Map.entry("maxPrefixesAdvertisedV4", 1000),
                            Map.entry("maxPrefixesAdvertisedV6", 100),
                            Map.entry("md5AuthenticationKey", "test-md5-auth-key"),
                            Map.entry("peerSessionIPv4Address", "192.168.2.2"),
                            Map.entry("peerSessionIPv6Address", "fd00::2")
                        )),
                        Map.entry("connectionIdentifier", "CDD8E673-CB07-47E6-84DE-3739F778762B"),
                        Map.entry("peeringDBFacilityId", 99999)
                    )),
                Map.entry("peerAsn", Map.of("id", "/subscriptions/subId/providers/Microsoft.Peering/peerAsns/myAsn1"))
            ))
            .kind("Exchange")
            .location("eastus")
            .peeringLocation("peeringLocation0")
            .peeringName("peeringName")
            .resourceGroupName("rgName")
            .sku(Map.of("name", "Basic_Exchange_Free"))
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:peering:Peering peeringName /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Peering/peerings/{peeringName}
Content copied to clipboard

Properties

Link copied to clipboard
val direct: Output<PeeringPropertiesDirectResponse>?

The properties that define a direct peering.

Link copied to clipboard
val exchange: Output<PeeringPropertiesExchangeResponse>?

The properties that define an exchange peering.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val kind: Output<String>

The kind of the peering.

Link copied to clipboard
val location: Output<String>

The location of the resource.

Link copied to clipboard
val name: Output<String>

The name of the resource.

Link copied to clipboard
val peeringLocation: Output<String>?

The location of the peering.

Link copied to clipboard
val provisioningState: Output<String>

The provisioning state of the resource.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val sku: Output<PeeringSkuResponse>

The SKU that defines the tier and kind of the peering.

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

The resource tags.

Link copied to clipboard
val type: Output<String>

The type of the resource.

Link copied to clipboard
val urn: Output<String>