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

PeeringArgs

data class PeeringArgs(val direct: Output<PeeringPropertiesDirectArgs>? = null, val exchange: Output<PeeringPropertiesExchangeArgs>? = null, val kind: Output<Either<String, Kind>>? = null, val location: Output<String>? = null, val peeringLocation: Output<String>? = null, val peeringName: Output<String>? = null, val resourceGroupName: Output<String>? = null, val sku: Output<PeeringSkuArgs>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<PeeringArgs>

Peering is a logical representation of a set of connections to the Microsoft Cloud Edge at a location. API Version: 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 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 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 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/subId/resourceGroups/rgName/providers/Microsoft.Peering/peerings/peeringName
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(direct: Output<PeeringPropertiesDirectArgs>? = null, exchange: Output<PeeringPropertiesExchangeArgs>? = null, kind: Output<Either<String, Kind>>? = null, location: Output<String>? = null, peeringLocation: Output<String>? = null, peeringName: Output<String>? = null, resourceGroupName: Output<String>? = null, sku: Output<PeeringSkuArgs>? = null, tags: Output<Map<String, String>>? = null)

Properties

Link copied to clipboard
val direct: Output<PeeringPropertiesDirectArgs>? = null

The properties that define a direct peering.

Link copied to clipboard
val exchange: Output<PeeringPropertiesExchangeArgs>? = null

The properties that define an exchange peering.

Link copied to clipboard
val kind: Output<Either<String, Kind>>? = null

The kind of the peering.

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

The location of the resource.

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

The location of the peering.

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

The name of the peering.

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

The name of the resource group.

Link copied to clipboard
val sku: Output<PeeringSkuArgs>? = null

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

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

The resource tags.

Functions

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