pulumi-azure-native-kotlin/com.pulumi.azurenative.network.kotlin/VirtualNetworkGateway

VirtualNetworkGateway

class VirtualNetworkGateway : KotlinCustomResource

A common class for general resource information. Azure REST API version: 2023-02-01. Prior API version in Azure Native 1.x: 2020-11-01. Other available API versions: 2016-06-01, 2016-09-01, 2019-08-01, 2023-04-01, 2023-05-01.

Example Usage

UpdateVirtualNetworkGateway

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var virtualNetworkGateway = new AzureNative.Network.VirtualNetworkGateway("virtualNetworkGateway", new()
    {
        ActiveActive = false,
        AllowRemoteVnetTraffic = false,
        AllowVirtualWanTraffic = false,
        BgpSettings = new AzureNative.Network.Inputs.BgpSettingsArgs
        {
            Asn = 65515,
            BgpPeeringAddress = "10.0.1.30",
            PeerWeight = 0,
        },
        CustomRoutes = new AzureNative.Network.Inputs.AddressSpaceArgs
        {
            AddressPrefixes = new[]
            {
                "101.168.0.6/32",
            },
        },
        DisableIPSecReplayProtection = false,
        EnableBgp = false,
        EnableBgpRouteTranslationForNat = false,
        EnableDnsForwarding = true,
        GatewayType = "Vpn",
        IpConfigurations = new[]
        {
            new AzureNative.Network.Inputs.VirtualNetworkGatewayIPConfigurationArgs
            {
                Name = "gwipconfig1",
                PrivateIPAllocationMethod = "Dynamic",
                PublicIPAddress = new AzureNative.Network.Inputs.SubResourceArgs
                {
                    Id = "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/gwpip",
                },
                Subnet = new AzureNative.Network.Inputs.SubResourceArgs
                {
                    Id = "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/GatewaySubnet",
                },
            },
        },
        Location = "centralus",
        NatRules = new[]
        {
            new AzureNative.Network.Inputs.VirtualNetworkGatewayNatRuleArgs
            {
                ExternalMappings = new[]
                {
                    new AzureNative.Network.Inputs.VpnNatRuleMappingArgs
                    {
                        AddressSpace = "50.0.0.0/24",
                    },
                },
                Id = "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule1",
                InternalMappings = new[]
                {
                    new AzureNative.Network.Inputs.VpnNatRuleMappingArgs
                    {
                        AddressSpace = "10.10.0.0/24",
                    },
                },
                IpConfigurationId = "",
                Mode = "EgressSnat",
                Name = "natRule1",
                Type = "Static",
            },
            new AzureNative.Network.Inputs.VirtualNetworkGatewayNatRuleArgs
            {
                ExternalMappings = new[]
                {
                    new AzureNative.Network.Inputs.VpnNatRuleMappingArgs
                    {
                        AddressSpace = "30.0.0.0/24",
                    },
                },
                Id = "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule2",
                InternalMappings = new[]
                {
                    new AzureNative.Network.Inputs.VpnNatRuleMappingArgs
                    {
                        AddressSpace = "20.10.0.0/24",
                    },
                },
                IpConfigurationId = "",
                Mode = "IngressSnat",
                Name = "natRule2",
                Type = "Static",
            },
        },
        ResourceGroupName = "rg1",
        Sku = new AzureNative.Network.Inputs.VirtualNetworkGatewaySkuArgs
        {
            Name = "VpnGw1",
            Tier = "VpnGw1",
        },
        VirtualNetworkGatewayName = "vpngw",
        VpnClientConfiguration = new AzureNative.Network.Inputs.VpnClientConfigurationArgs
        {
            RadiusServers = new[]
            {
                new AzureNative.Network.Inputs.RadiusServerArgs
                {
                    RadiusServerAddress = "10.2.0.0",
                    RadiusServerScore = 20,
                    RadiusServerSecret = "radiusServerSecret",
                },
            },
            VpnClientProtocols = new[]
            {
                "OpenVPN",
            },
            VpnClientRevokedCertificates = new() { },
            VpnClientRootCertificates = new() { },
        },
        VpnType = "RouteBased",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/network/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := network.NewVirtualNetworkGateway(ctx, "virtualNetworkGateway", &network.VirtualNetworkGatewayArgs{
			ActiveActive:           pulumi.Bool(false),
			AllowRemoteVnetTraffic: pulumi.Bool(false),
			AllowVirtualWanTraffic: pulumi.Bool(false),
			BgpSettings: &network.BgpSettingsArgs{
				Asn:               pulumi.Float64(65515),
				BgpPeeringAddress: pulumi.String("10.0.1.30"),
				PeerWeight:        pulumi.Int(0),
			},
			CustomRoutes: &network.AddressSpaceArgs{
				AddressPrefixes: pulumi.StringArray{
					pulumi.String("101.168.0.6/32"),
				},
			},
			DisableIPSecReplayProtection:    pulumi.Bool(false),
			EnableBgp:                       pulumi.Bool(false),
			EnableBgpRouteTranslationForNat: pulumi.Bool(false),
			EnableDnsForwarding:             pulumi.Bool(true),
			GatewayType:                     pulumi.String("Vpn"),
			IpConfigurations: []network.VirtualNetworkGatewayIPConfigurationArgs{
				{
					Name:                      pulumi.String("gwipconfig1"),
					PrivateIPAllocationMethod: pulumi.String("Dynamic"),
					PublicIPAddress: {
						Id: pulumi.String("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/gwpip"),
					},
					Subnet: {
						Id: pulumi.String("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/GatewaySubnet"),
					},
				},
			},
			Location: pulumi.String("centralus"),
			NatRules: []network.VirtualNetworkGatewayNatRuleTypeArgs{
				{
					ExternalMappings: network.VpnNatRuleMappingArray{
						{
							AddressSpace: pulumi.String("50.0.0.0/24"),
						},
					},
					Id: pulumi.String("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule1"),
					InternalMappings: network.VpnNatRuleMappingArray{
						{
							AddressSpace: pulumi.String("10.10.0.0/24"),
						},
					},
					IpConfigurationId: pulumi.String(""),
					Mode:              pulumi.String("EgressSnat"),
					Name:              pulumi.String("natRule1"),
					Type:              pulumi.String("Static"),
				},
				{
					ExternalMappings: network.VpnNatRuleMappingArray{
						{
							AddressSpace: pulumi.String("30.0.0.0/24"),
						},
					},
					Id: pulumi.String("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule2"),
					InternalMappings: network.VpnNatRuleMappingArray{
						{
							AddressSpace: pulumi.String("20.10.0.0/24"),
						},
					},
					IpConfigurationId: pulumi.String(""),
					Mode:              pulumi.String("IngressSnat"),
					Name:              pulumi.String("natRule2"),
					Type:              pulumi.String("Static"),
				},
			},
			ResourceGroupName: pulumi.String("rg1"),
			Sku: &network.VirtualNetworkGatewaySkuArgs{
				Name: pulumi.String("VpnGw1"),
				Tier: pulumi.String("VpnGw1"),
			},
			VirtualNetworkGatewayName: pulumi.String("vpngw"),
			VpnClientConfiguration: network.VpnClientConfigurationResponse{
				RadiusServers: network.RadiusServerArray{
					&network.RadiusServerArgs{
						RadiusServerAddress: pulumi.String("10.2.0.0"),
						RadiusServerScore:   pulumi.Float64(20),
						RadiusServerSecret:  pulumi.String("radiusServerSecret"),
					},
				},
				VpnClientProtocols: pulumi.StringArray{
					pulumi.String("OpenVPN"),
				},
				VpnClientRevokedCertificates: network.VpnClientRevokedCertificateArray{},
				VpnClientRootCertificates:    network.VpnClientRootCertificateArray{},
			},
			VpnType: pulumi.String("RouteBased"),
		})
		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.network.VirtualNetworkGateway;
import com.pulumi.azurenative.network.VirtualNetworkGatewayArgs;
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 virtualNetworkGateway = new VirtualNetworkGateway("virtualNetworkGateway", VirtualNetworkGatewayArgs.builder()
            .activeActive(false)
            .allowRemoteVnetTraffic(false)
            .allowVirtualWanTraffic(false)
            .bgpSettings(Map.ofEntries(
                Map.entry("asn", 65515),
                Map.entry("bgpPeeringAddress", "10.0.1.30"),
                Map.entry("peerWeight", 0)
            ))
            .customRoutes(Map.of("addressPrefixes", "101.168.0.6/32"))
            .disableIPSecReplayProtection(false)
            .enableBgp(false)
            .enableBgpRouteTranslationForNat(false)
            .enableDnsForwarding(true)
            .gatewayType("Vpn")
            .ipConfigurations(Map.ofEntries(
                Map.entry("name", "gwipconfig1"),
                Map.entry("privateIPAllocationMethod", "Dynamic"),
                Map.entry("publicIPAddress", Map.of("id", "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/publicIPAddresses/gwpip")),
                Map.entry("subnet", Map.of("id", "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/GatewaySubnet"))
            ))
            .location("centralus")
            .natRules(
                Map.ofEntries(
                    Map.entry("externalMappings", Map.of("addressSpace", "50.0.0.0/24")),
                    Map.entry("id", "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule1"),
                    Map.entry("internalMappings", Map.of("addressSpace", "10.10.0.0/24")),
                    Map.entry("ipConfigurationId", ""),
                    Map.entry("mode", "EgressSnat"),
                    Map.entry("name", "natRule1"),
                    Map.entry("type", "Static")
                ),
                Map.ofEntries(
                    Map.entry("externalMappings", Map.of("addressSpace", "30.0.0.0/24")),
                    Map.entry("id", "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworkGateways/vpngw/natRules/natRule2"),
                    Map.entry("internalMappings", Map.of("addressSpace", "20.10.0.0/24")),
                    Map.entry("ipConfigurationId", ""),
                    Map.entry("mode", "IngressSnat"),
                    Map.entry("name", "natRule2"),
                    Map.entry("type", "Static")
                ))
            .resourceGroupName("rg1")
            .sku(Map.ofEntries(
                Map.entry("name", "VpnGw1"),
                Map.entry("tier", "VpnGw1")
            ))
            .virtualNetworkGatewayName("vpngw")
            .vpnClientConfiguration(Map.ofEntries(
                Map.entry("radiusServers", Map.ofEntries(
                    Map.entry("radiusServerAddress", "10.2.0.0"),
                    Map.entry("radiusServerScore", 20),
                    Map.entry("radiusServerSecret", "radiusServerSecret")
                )),
                Map.entry("vpnClientProtocols", "OpenVPN"),
                Map.entry("vpnClientRevokedCertificates", ),
                Map.entry("vpnClientRootCertificates", )
            ))
            .vpnType("RouteBased")
            .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:network:VirtualNetworkGateway vpngw /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}
Content copied to clipboard

Properties

Link copied to clipboard
val activeActive: Output<Boolean>?

ActiveActive flag.

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

Property to indicate if the Express Route Gateway serves traffic when there are multiple Express Route Gateways in the vnet

Link copied to clipboard
val allowRemoteVnetTraffic: Output<Boolean>?

Configure this gateway to accept traffic from other Azure Virtual Networks. This configuration does not support connectivity to Azure Virtual WAN.

Link copied to clipboard
val allowVirtualWanTraffic: Output<Boolean>?

Configures this gateway to accept traffic from remote Virtual WAN networks.

Link copied to clipboard
val bgpSettings: Output<BgpSettingsResponse>?

Virtual network gateway's BGP speaker settings.

Link copied to clipboard
val customRoutes: Output<AddressSpaceResponse>?

The reference to the address space resource which represents the custom routes address space specified by the customer for virtual network gateway and VpnClient.

Link copied to clipboard
val disableIPSecReplayProtection: Output<Boolean>?

disableIPSecReplayProtection flag.

Link copied to clipboard
val enableBgp: Output<Boolean>?

Whether BGP is enabled for this virtual network gateway or not.

Link copied to clipboard
val enableBgpRouteTranslationForNat: Output<Boolean>?

EnableBgpRouteTranslationForNat flag.

Link copied to clipboard
val enableDnsForwarding: Output<Boolean>?

Whether dns forwarding is enabled or not.

Link copied to clipboard
val enablePrivateIpAddress: Output<Boolean>?

Whether private IP needs to be enabled on this gateway for connections or not.

Link copied to clipboard
val etag: Output<String>

A unique read-only string that changes whenever the resource is updated.

Link copied to clipboard
val extendedLocation: Output<ExtendedLocationResponse>?

The extended location of type local virtual network gateway.

Link copied to clipboard
val gatewayDefaultSite: Output<SubResourceResponse>?

The reference to the LocalNetworkGateway resource which represents local network site having default routes. Assign Null value in case of removing existing default site setting.

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

The type of this virtual network gateway.

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

The IP address allocated by the gateway to which dns requests can be sent.

Link copied to clipboard
val ipConfigurations: Output<List<VirtualNetworkGatewayIPConfigurationResponse>>?

IP configurations for virtual network gateway.

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

Resource location.

Link copied to clipboard
val name: Output<String>

Resource name.

Link copied to clipboard
val natRules: Output<List<VirtualNetworkGatewayNatRuleResponse>>?

NatRules for virtual network gateway.

Link copied to clipboard
val provisioningState: Output<String>

The provisioning state of the virtual network gateway resource.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val resourceGuid: Output<String>

The resource GUID property of the virtual network gateway resource.

Link copied to clipboard
val sku: Output<VirtualNetworkGatewaySkuResponse>?

The reference to the VirtualNetworkGatewaySku resource which represents the SKU selected for Virtual network gateway.

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

Resource tags.

Link copied to clipboard
val type: Output<String>

Resource type.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val virtualNetworkGatewayPolicyGroups: Output<List<VirtualNetworkGatewayPolicyGroupResponse>>?

The reference to the VirtualNetworkGatewayPolicyGroup resource which represents the available VirtualNetworkGatewayPolicyGroup for the gateway.

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

Customer vnet resource id. VirtualNetworkGateway of type local gateway is associated with the customer vnet.

Link copied to clipboard
val vpnClientConfiguration: Output<VpnClientConfigurationResponse>?

The reference to the VpnClientConfiguration resource which represents the P2S VpnClient configurations.

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

The generation for this VirtualNetworkGateway. Must be None if gatewayType is not VPN.

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

The type of this virtual network gateway.