azure.network.ApplicationGateway

using System.Collections.Generic;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        AddressSpaces = new[]
        {
            "10.254.0.0/16",
        },
    });

    var frontend = new Azure.Network.Subnet("frontend", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.254.0.0/24",
        },
    });

    var backend = new Azure.Network.Subnet("backend", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.254.2.0/24",
        },
    });

    var examplePublicIp = new Azure.Network.PublicIp("examplePublicIp", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        AllocationMethod = "Dynamic",
    });

    var backendAddressPoolName = exampleVirtualNetwork.Name.Apply(name => $"{name}-beap");

    var frontendPortName = exampleVirtualNetwork.Name.Apply(name => $"{name}-feport");

    var frontendIpConfigurationName = exampleVirtualNetwork.Name.Apply(name => $"{name}-feip");

    var httpSettingName = exampleVirtualNetwork.Name.Apply(name => $"{name}-be-htst");

    var listenerName = exampleVirtualNetwork.Name.Apply(name => $"{name}-httplstn");

    var requestRoutingRuleName = exampleVirtualNetwork.Name.Apply(name => $"{name}-rqrt");

    var redirectConfigurationName = exampleVirtualNetwork.Name.Apply(name => $"{name}-rdrcfg");

    var network = new Azure.Network.ApplicationGateway("network", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        Sku = new Azure.Network.Inputs.ApplicationGatewaySkuArgs
        {
            Name = "Standard_Small",
            Tier = "Standard",
            Capacity = 2,
        },
        GatewayIpConfigurations = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayGatewayIpConfigurationArgs
            {
                Name = "my-gateway-ip-configuration",
                SubnetId = frontend.Id,
            },
        },
        FrontendPorts = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayFrontendPortArgs
            {
                Name = frontendPortName,
                Port = 80,
            },
        },
        FrontendIpConfigurations = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayFrontendIpConfigurationArgs
            {
                Name = frontendIpConfigurationName,
                PublicIpAddressId = examplePublicIp.Id,
            },
        },
        BackendAddressPools = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayBackendAddressPoolArgs
            {
                Name = backendAddressPoolName,
            },
        },
        BackendHttpSettings = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayBackendHttpSettingArgs
            {
                Name = httpSettingName,
                CookieBasedAffinity = "Disabled",
                Path = "/path1/",
                Port = 80,
                Protocol = "Http",
                RequestTimeout = 60,
            },
        },
        HttpListeners = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayHttpListenerArgs
            {
                Name = listenerName,
                FrontendIpConfigurationName = frontendIpConfigurationName,
                FrontendPortName = frontendPortName,
                Protocol = "Http",
            },
        },
        RequestRoutingRules = new[]
        {
            new Azure.Network.Inputs.ApplicationGatewayRequestRoutingRuleArgs
            {
                Name = requestRoutingRuleName,
                RuleType = "Basic",
                HttpListenerName = listenerName,
                BackendAddressPoolName = backendAddressPoolName,
                BackendHttpSettingsName = httpSettingName,
            },
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "exampleVirtualNetwork", &network.VirtualNetworkArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.254.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		frontend, err := network.NewSubnet(ctx, "frontend", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.254.0.0/24"),
			},
		})
		if err != nil {
			return err
		}
		_, err = network.NewSubnet(ctx, "backend", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.254.2.0/24"),
			},
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "examplePublicIp", &network.PublicIpArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			AllocationMethod:  pulumi.String("Dynamic"),
		})
		if err != nil {
			return err
		}
		backendAddressPoolName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-beap", name), nil
		}).(pulumi.StringOutput)
		frontendPortName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-feport", name), nil
		}).(pulumi.StringOutput)
		frontendIpConfigurationName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-feip", name), nil
		}).(pulumi.StringOutput)
		httpSettingName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-be-htst", name), nil
		}).(pulumi.StringOutput)
		listenerName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-httplstn", name), nil
		}).(pulumi.StringOutput)
		requestRoutingRuleName := exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-rqrt", name), nil
		}).(pulumi.StringOutput)
		_ = exampleVirtualNetwork.Name.ApplyT(func(name string) (string, error) {
			return fmt.Sprintf("%v-rdrcfg", name), nil
		}).(pulumi.StringOutput)
		_, err = network.NewApplicationGateway(ctx, "network", &network.ApplicationGatewayArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Sku: &network.ApplicationGatewaySkuArgs{
				Name:     pulumi.String("Standard_Small"),
				Tier:     pulumi.String("Standard"),
				Capacity: pulumi.Int(2),
			},
			GatewayIpConfigurations: network.ApplicationGatewayGatewayIpConfigurationArray{
				&network.ApplicationGatewayGatewayIpConfigurationArgs{
					Name:     pulumi.String("my-gateway-ip-configuration"),
					SubnetId: frontend.ID(),
				},
			},
			FrontendPorts: network.ApplicationGatewayFrontendPortArray{
				&network.ApplicationGatewayFrontendPortArgs{
					Name: pulumi.String(frontendPortName),
					Port: pulumi.Int(80),
				},
			},
			FrontendIpConfigurations: network.ApplicationGatewayFrontendIpConfigurationArray{
				&network.ApplicationGatewayFrontendIpConfigurationArgs{
					Name:              pulumi.String(frontendIpConfigurationName),
					PublicIpAddressId: examplePublicIp.ID(),
				},
			},
			BackendAddressPools: network.ApplicationGatewayBackendAddressPoolArray{
				&network.ApplicationGatewayBackendAddressPoolArgs{
					Name: pulumi.String(backendAddressPoolName),
				},
			},
			BackendHttpSettings: network.ApplicationGatewayBackendHttpSettingArray{
				&network.ApplicationGatewayBackendHttpSettingArgs{
					Name:                pulumi.String(httpSettingName),
					CookieBasedAffinity: pulumi.String("Disabled"),
					Path:                pulumi.String("/path1/"),
					Port:                pulumi.Int(80),
					Protocol:            pulumi.String("Http"),
					RequestTimeout:      pulumi.Int(60),
				},
			},
			HttpListeners: network.ApplicationGatewayHttpListenerArray{
				&network.ApplicationGatewayHttpListenerArgs{
					Name:                        pulumi.String(listenerName),
					FrontendIpConfigurationName: pulumi.String(frontendIpConfigurationName),
					FrontendPortName:            pulumi.String(frontendPortName),
					Protocol:                    pulumi.String("Http"),
				},
			},
			RequestRoutingRules: network.ApplicationGatewayRequestRoutingRuleArray{
				&network.ApplicationGatewayRequestRoutingRuleArgs{
					Name:                    pulumi.String(requestRoutingRuleName),
					RuleType:                pulumi.String("Basic"),
					HttpListenerName:        pulumi.String(listenerName),
					BackendAddressPoolName:  pulumi.String(backendAddressPoolName),
					BackendHttpSettingsName: pulumi.String(httpSettingName),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azure.network.PublicIp;
import com.pulumi.azure.network.PublicIpArgs;
import com.pulumi.azure.network.ApplicationGateway;
import com.pulumi.azure.network.ApplicationGatewayArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewaySkuArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayGatewayIpConfigurationArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayFrontendPortArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayFrontendIpConfigurationArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayBackendAddressPoolArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayBackendHttpSettingArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayHttpListenerArgs;
import com.pulumi.azure.network.inputs.ApplicationGatewayRequestRoutingRuleArgs;
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 exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .addressSpaces("10.254.0.0/16")
            .build());

        var frontend = new Subnet("frontend", SubnetArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.254.0.0/24")
            .build());

        var backend = new Subnet("backend", SubnetArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.254.2.0/24")
            .build());

        var examplePublicIp = new PublicIp("examplePublicIp", PublicIpArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .allocationMethod("Dynamic")
            .build());

        final var backendAddressPoolName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-beap", name));

        final var frontendPortName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-feport", name));

        final var frontendIpConfigurationName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-feip", name));

        final var httpSettingName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-be-htst", name));

        final var listenerName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-httplstn", name));

        final var requestRoutingRuleName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-rqrt", name));

        final var redirectConfigurationName = exampleVirtualNetwork.name().applyValue(name -> String.format("%s-rdrcfg", name));

        var network = new ApplicationGateway("network", ApplicationGatewayArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .sku(ApplicationGatewaySkuArgs.builder()
                .name("Standard_Small")
                .tier("Standard")
                .capacity(2)
                .build())
            .gatewayIpConfigurations(ApplicationGatewayGatewayIpConfigurationArgs.builder()
                .name("my-gateway-ip-configuration")
                .subnetId(frontend.id())
                .build())
            .frontendPorts(ApplicationGatewayFrontendPortArgs.builder()
                .name(frontendPortName)
                .port(80)
                .build())
            .frontendIpConfigurations(ApplicationGatewayFrontendIpConfigurationArgs.builder()
                .name(frontendIpConfigurationName)
                .publicIpAddressId(examplePublicIp.id())
                .build())
            .backendAddressPools(ApplicationGatewayBackendAddressPoolArgs.builder()
                .name(backendAddressPoolName)
                .build())
            .backendHttpSettings(ApplicationGatewayBackendHttpSettingArgs.builder()
                .name(httpSettingName)
                .cookieBasedAffinity("Disabled")
                .path("/path1/")
                .port(80)
                .protocol("Http")
                .requestTimeout(60)
                .build())
            .httpListeners(ApplicationGatewayHttpListenerArgs.builder()
                .name(listenerName)
                .frontendIpConfigurationName(frontendIpConfigurationName)
                .frontendPortName(frontendPortName)
                .protocol("Http")
                .build())
            .requestRoutingRules(ApplicationGatewayRequestRoutingRuleArgs.builder()
                .name(requestRoutingRuleName)
                .ruleType("Basic")
                .httpListenerName(listenerName)
                .backendAddressPoolName(backendAddressPoolName)
                .backendHttpSettingsName(httpSettingName)
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_virtual_network = azure.network.VirtualNetwork("exampleVirtualNetwork",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    address_spaces=["10.254.0.0/16"])
frontend = azure.network.Subnet("frontend",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.254.0.0/24"])
backend = azure.network.Subnet("backend",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.254.2.0/24"])
example_public_ip = azure.network.PublicIp("examplePublicIp",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    allocation_method="Dynamic")
backend_address_pool_name = example_virtual_network.name.apply(lambda name: f"{name}-beap")
frontend_port_name = example_virtual_network.name.apply(lambda name: f"{name}-feport")
frontend_ip_configuration_name = example_virtual_network.name.apply(lambda name: f"{name}-feip")
http_setting_name = example_virtual_network.name.apply(lambda name: f"{name}-be-htst")
listener_name = example_virtual_network.name.apply(lambda name: f"{name}-httplstn")
request_routing_rule_name = example_virtual_network.name.apply(lambda name: f"{name}-rqrt")
redirect_configuration_name = example_virtual_network.name.apply(lambda name: f"{name}-rdrcfg")
network = azure.network.ApplicationGateway("network",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    sku=azure.network.ApplicationGatewaySkuArgs(
        name="Standard_Small",
        tier="Standard",
        capacity=2,
    ),
    gateway_ip_configurations=[azure.network.ApplicationGatewayGatewayIpConfigurationArgs(
        name="my-gateway-ip-configuration",
        subnet_id=frontend.id,
    )],
    frontend_ports=[azure.network.ApplicationGatewayFrontendPortArgs(
        name=frontend_port_name,
        port=80,
    )],
    frontend_ip_configurations=[azure.network.ApplicationGatewayFrontendIpConfigurationArgs(
        name=frontend_ip_configuration_name,
        public_ip_address_id=example_public_ip.id,
    )],
    backend_address_pools=[azure.network.ApplicationGatewayBackendAddressPoolArgs(
        name=backend_address_pool_name,
    )],
    backend_http_settings=[azure.network.ApplicationGatewayBackendHttpSettingArgs(
        name=http_setting_name,
        cookie_based_affinity="Disabled",
        path="/path1/",
        port=80,
        protocol="Http",
        request_timeout=60,
    )],
    http_listeners=[azure.network.ApplicationGatewayHttpListenerArgs(
        name=listener_name,
        frontend_ip_configuration_name=frontend_ip_configuration_name,
        frontend_port_name=frontend_port_name,
        protocol="Http",
    )],
    request_routing_rules=[azure.network.ApplicationGatewayRequestRoutingRuleArgs(
        name=request_routing_rule_name,
        rule_type="Basic",
        http_listener_name=listener_name,
        backend_address_pool_name=backend_address_pool_name,
        backend_http_settings_name=http_setting_name,
    )])

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("exampleVirtualNetwork", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    addressSpaces: ["10.254.0.0/16"],
});
const frontend = new azure.network.Subnet("frontend", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.254.0.0/24"],
});
const backend = new azure.network.Subnet("backend", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.254.2.0/24"],
});
const examplePublicIp = new azure.network.PublicIp("examplePublicIp", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    allocationMethod: "Dynamic",
});
const backendAddressPoolName = pulumi.interpolate`${exampleVirtualNetwork.name}-beap`;
const frontendPortName = pulumi.interpolate`${exampleVirtualNetwork.name}-feport`;
const frontendIpConfigurationName = pulumi.interpolate`${exampleVirtualNetwork.name}-feip`;
const httpSettingName = pulumi.interpolate`${exampleVirtualNetwork.name}-be-htst`;
const listenerName = pulumi.interpolate`${exampleVirtualNetwork.name}-httplstn`;
const requestRoutingRuleName = pulumi.interpolate`${exampleVirtualNetwork.name}-rqrt`;
const redirectConfigurationName = pulumi.interpolate`${exampleVirtualNetwork.name}-rdrcfg`;
const network = new azure.network.ApplicationGateway("network", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    sku: {
        name: "Standard_Small",
        tier: "Standard",
        capacity: 2,
    },
    gatewayIpConfigurations: [{
        name: "my-gateway-ip-configuration",
        subnetId: frontend.id,
    }],
    frontendPorts: [{
        name: frontendPortName,
        port: 80,
    }],
    frontendIpConfigurations: [{
        name: frontendIpConfigurationName,
        publicIpAddressId: examplePublicIp.id,
    }],
    backendAddressPools: [{
        name: backendAddressPoolName,
    }],
    backendHttpSettings: [{
        name: httpSettingName,
        cookieBasedAffinity: "Disabled",
        path: "/path1/",
        port: 80,
        protocol: "Http",
        requestTimeout: 60,
    }],
    httpListeners: [{
        name: listenerName,
        frontendIpConfigurationName: frontendIpConfigurationName,
        frontendPortName: frontendPortName,
        protocol: "Http",
    }],
    requestRoutingRules: [{
        name: requestRoutingRuleName,
        ruleType: "Basic",
        httpListenerName: listenerName,
        backendAddressPoolName: backendAddressPoolName,
        backendHttpSettingsName: httpSettingName,
    }],
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      addressSpaces:
        - 10.254.0.0/16
  frontend:
    type: azure:network:Subnet
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.254.0.0/24
  backend:
    type: azure:network:Subnet
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.254.2.0/24
  examplePublicIp:
    type: azure:network:PublicIp
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      allocationMethod: Dynamic
  network:
    type: azure:network:ApplicationGateway
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      sku:
        name: Standard_Small
        tier: Standard
        capacity: 2
      gatewayIpConfigurations:
        - name: my-gateway-ip-configuration
          subnetId: ${frontend.id}
      frontendPorts:
        - name: ${frontendPortName}
          port: 80
      frontendIpConfigurations:
        - name: ${frontendIpConfigurationName}
          publicIpAddressId: ${examplePublicIp.id}
      backendAddressPools:
        - name: ${backendAddressPoolName}
      backendHttpSettings:
        - name: ${httpSettingName}
          cookieBasedAffinity: Disabled
          path: /path1/
          port: 80
          protocol: Http
          requestTimeout: 60
      httpListeners:
        - name: ${listenerName}
          frontendIpConfigurationName: ${frontendIpConfigurationName}
          frontendPortName: ${frontendPortName}
          protocol: Http
      requestRoutingRules:
        - name: ${requestRoutingRuleName}
          ruleType: Basic
          httpListenerName: ${listenerName}
          backendAddressPoolName: ${backendAddressPoolName}
          backendHttpSettingsName: ${httpSettingName}
variables:
  backendAddressPoolName: ${exampleVirtualNetwork.name}-beap
  frontendPortName: ${exampleVirtualNetwork.name}-feport
  frontendIpConfigurationName: ${exampleVirtualNetwork.name}-feip
  httpSettingName: ${exampleVirtualNetwork.name}-be-htst
  listenerName: ${exampleVirtualNetwork.name}-httplstn
  requestRoutingRuleName: ${exampleVirtualNetwork.name}-rqrt
  redirectConfigurationName: ${exampleVirtualNetwork.name}-rdrcfg