azure.lb.BackendAddressPoolAddress

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

return await Deployment.RunAsync(() => 
{
    var exampleVirtualNetwork = Azure.Network.GetVirtualNetwork.Invoke(new()
    {
        Name = "example-network",
        ResourceGroupName = "example-resources",
    });

    var exampleLB = Azure.Lb.GetLB.Invoke(new()
    {
        Name = "example-lb",
        ResourceGroupName = "example-resources",
    });

    var exampleBackendAddressPool = Azure.Lb.GetBackendAddressPool.Invoke(new()
    {
        Name = "first",
        LoadbalancerId = exampleLB.Apply(getLBResult => getLBResult.Id),
    });

    var exampleBackendAddressPoolAddress = new Azure.Lb.BackendAddressPoolAddress("exampleBackendAddressPoolAddress", new()
    {
        BackendAddressPoolId = exampleBackendAddressPool.Apply(getBackendAddressPoolResult => getBackendAddressPoolResult.Id),
        VirtualNetworkId = exampleVirtualNetwork.Apply(getVirtualNetworkResult => getVirtualNetworkResult.Id),
        IpAddress = "10.0.0.1",
    });

    var backend_pool_cr = Azure.Lb.GetBackendAddressPool.Invoke(new()
    {
        Name = "globalLBBackendPool",
        LoadbalancerId = exampleLB.Apply(getLBResult => getLBResult.Id),
    });

    var example_1 = new Azure.Lb.BackendAddressPoolAddress("example-1", new()
    {
        BackendAddressPoolId = backend_pool_cr.Apply(backend_pool_cr => backend_pool_cr.Apply(getBackendAddressPoolResult => getBackendAddressPoolResult.Id)),
        BackendAddressIpConfigurationId = azurerm_lb.Backend_lb_R1.Frontend_ip_configuration[0].Id,
    });

    var example_2 = new Azure.Lb.BackendAddressPoolAddress("example-2", new()
    {
        BackendAddressPoolId = backend_pool_cr.Apply(backend_pool_cr => backend_pool_cr.Apply(getBackendAddressPoolResult => getBackendAddressPoolResult.Id)),
        BackendAddressIpConfigurationId = azurerm_lb.Backend_lb_R2.Frontend_ip_configuration[0].Id,
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/lb"
	"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 {
		exampleVirtualNetwork, err := network.LookupVirtualNetwork(ctx, &network.LookupVirtualNetworkArgs{
			Name:              "example-network",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleLB, err := lb.GetLB(ctx, &lb.GetLBArgs{
			Name:              "example-lb",
			ResourceGroupName: "example-resources",
		}, nil)
		if err != nil {
			return err
		}
		exampleBackendAddressPool, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "first",
			LoadbalancerId: exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "exampleBackendAddressPoolAddress", &lb.BackendAddressPoolAddressArgs{
			BackendAddressPoolId: *pulumi.String(exampleBackendAddressPool.Id),
			VirtualNetworkId:     *pulumi.String(exampleVirtualNetwork.Id),
			IpAddress:            pulumi.String("10.0.0.1"),
		})
		if err != nil {
			return err
		}
		backend_pool_cr, err := lb.LookupBackendAddressPool(ctx, &lb.LookupBackendAddressPoolArgs{
			Name:           "globalLBBackendPool",
			LoadbalancerId: exampleLB.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "example-1", &lb.BackendAddressPoolAddressArgs{
			BackendAddressPoolId:            *pulumi.String(backend_pool_cr.Id),
			BackendAddressIpConfigurationId: pulumi.Any(azurerm_lb.BackendLbR1.Frontend_ip_configuration[0].Id),
		})
		if err != nil {
			return err
		}
		_, err = lb.NewBackendAddressPoolAddress(ctx, "example-2", &lb.BackendAddressPoolAddressArgs{
			BackendAddressPoolId:            *pulumi.String(backend_pool_cr.Id),
			BackendAddressIpConfigurationId: pulumi.Any(azurerm_lb.BackendLbR2.Frontend_ip_configuration[0].Id),
		})
		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.network.NetworkFunctions;
import com.pulumi.azure.network.inputs.GetVirtualNetworkArgs;
import com.pulumi.azure.lb.LbFunctions;
import com.pulumi.azure.lb.inputs.GetLBArgs;
import com.pulumi.azure.lb.inputs.GetBackendAddressPoolArgs;
import com.pulumi.azure.lb.BackendAddressPoolAddress;
import com.pulumi.azure.lb.BackendAddressPoolAddressArgs;
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) {
        final var exampleVirtualNetwork = NetworkFunctions.getVirtualNetwork(GetVirtualNetworkArgs.builder()
            .name("example-network")
            .resourceGroupName("example-resources")
            .build());

        final var exampleLB = LbFunctions.getLB(GetLBArgs.builder()
            .name("example-lb")
            .resourceGroupName("example-resources")
            .build());

        final var exampleBackendAddressPool = LbFunctions.getBackendAddressPool(GetBackendAddressPoolArgs.builder()
            .name("first")
            .loadbalancerId(exampleLB.applyValue(getLBResult -> getLBResult.id()))
            .build());

        var exampleBackendAddressPoolAddress = new BackendAddressPoolAddress("exampleBackendAddressPoolAddress", BackendAddressPoolAddressArgs.builder()        
            .backendAddressPoolId(exampleBackendAddressPool.applyValue(getBackendAddressPoolResult -> getBackendAddressPoolResult.id()))
            .virtualNetworkId(exampleVirtualNetwork.applyValue(getVirtualNetworkResult -> getVirtualNetworkResult.id()))
            .ipAddress("10.0.0.1")
            .build());

        final var backend-pool-cr = LbFunctions.getBackendAddressPool(GetBackendAddressPoolArgs.builder()
            .name("globalLBBackendPool")
            .loadbalancerId(exampleLB.applyValue(getLBResult -> getLBResult.id()))
            .build());

        var example_1 = new BackendAddressPoolAddress("example-1", BackendAddressPoolAddressArgs.builder()        
            .backendAddressPoolId(backend_pool_cr.id())
            .backendAddressIpConfigurationId(azurerm_lb.backend-lb-R1().frontend_ip_configuration()[0].id())
            .build());

        var example_2 = new BackendAddressPoolAddress("example-2", BackendAddressPoolAddressArgs.builder()        
            .backendAddressPoolId(backend_pool_cr.id())
            .backendAddressIpConfigurationId(azurerm_lb.backend-lb-R2().frontend_ip_configuration()[0].id())
            .build());

    }
}

import pulumi
import pulumi_azure as azure

example_virtual_network = azure.network.get_virtual_network(name="example-network",
    resource_group_name="example-resources")
example_lb = azure.lb.get_lb(name="example-lb",
    resource_group_name="example-resources")
example_backend_address_pool = azure.lb.get_backend_address_pool(name="first",
    loadbalancer_id=example_lb.id)
example_backend_address_pool_address = azure.lb.BackendAddressPoolAddress("exampleBackendAddressPoolAddress",
    backend_address_pool_id=example_backend_address_pool.id,
    virtual_network_id=example_virtual_network.id,
    ip_address="10.0.0.1")
backend_pool_cr = azure.lb.get_backend_address_pool(name="globalLBBackendPool",
    loadbalancer_id=example_lb.id)
example_1 = azure.lb.BackendAddressPoolAddress("example-1",
    backend_address_pool_id=backend_pool_cr.id,
    backend_address_ip_configuration_id=azurerm_lb["backend-lb-R1"]["frontend_ip_configuration"][0]["id"])
example_2 = azure.lb.BackendAddressPoolAddress("example-2",
    backend_address_pool_id=backend_pool_cr.id,
    backend_address_ip_configuration_id=azurerm_lb["backend-lb-R2"]["frontend_ip_configuration"][0]["id"])

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

const exampleVirtualNetwork = azure.network.getVirtualNetwork({
    name: "example-network",
    resourceGroupName: "example-resources",
});
const exampleLB = azure.lb.getLB({
    name: "example-lb",
    resourceGroupName: "example-resources",
});
const exampleBackendAddressPool = exampleLB.then(exampleLB => azure.lb.getBackendAddressPool({
    name: "first",
    loadbalancerId: exampleLB.id,
}));
const exampleBackendAddressPoolAddress = new azure.lb.BackendAddressPoolAddress("exampleBackendAddressPoolAddress", {
    backendAddressPoolId: exampleBackendAddressPool.then(exampleBackendAddressPool => exampleBackendAddressPool.id),
    virtualNetworkId: exampleVirtualNetwork.then(exampleVirtualNetwork => exampleVirtualNetwork.id),
    ipAddress: "10.0.0.1",
});
const backend-pool-cr = exampleLB.then(exampleLB => azure.lb.getBackendAddressPool({
    name: "globalLBBackendPool",
    loadbalancerId: exampleLB.id,
}));
const example_1 = new azure.lb.BackendAddressPoolAddress("example-1", {
    backendAddressPoolId: backend_pool_cr.then(backend_pool_cr => backend_pool_cr.id),
    backendAddressIpConfigurationId: azurerm_lb["backend-lb-R1"].frontend_ip_configuration[0].id,
});
const example_2 = new azure.lb.BackendAddressPoolAddress("example-2", {
    backendAddressPoolId: backend_pool_cr.then(backend_pool_cr => backend_pool_cr.id),
    backendAddressIpConfigurationId: azurerm_lb["backend-lb-R2"].frontend_ip_configuration[0].id,
});

resources:
  exampleBackendAddressPoolAddress:
    type: azure:lb:BackendAddressPoolAddress
    properties:
      backendAddressPoolId: ${exampleBackendAddressPool.id}
      virtualNetworkId: ${exampleVirtualNetwork.id}
      ipAddress: 10.0.0.1
  example-1:
    type: azure:lb:BackendAddressPoolAddress
    properties:
      backendAddressPoolId: ${["backend-pool-cr"].id}
      backendAddressIpConfigurationId: ${azurerm_lb"backend-lb-R1"[%!s(MISSING)].frontend_ip_configuration[0].id}
  example-2:
    type: azure:lb:BackendAddressPoolAddress
    properties:
      backendAddressPoolId: ${["backend-pool-cr"].id}
      backendAddressIpConfigurationId: ${azurerm_lb"backend-lb-R2"[%!s(MISSING)].frontend_ip_configuration[0].id}
variables:
  exampleVirtualNetwork:
    fn::invoke:
      Function: azure:network:getVirtualNetwork
      Arguments:
        name: example-network
        resourceGroupName: example-resources
  exampleLB:
    fn::invoke:
      Function: azure:lb:getLB
      Arguments:
        name: example-lb
        resourceGroupName: example-resources
  exampleBackendAddressPool:
    fn::invoke:
      Function: azure:lb:getBackendAddressPool
      Arguments:
        name: first
        loadbalancerId: ${exampleLB.id}
  backend-pool-cr:
    fn::invoke:
      Function: azure:lb:getBackendAddressPool
      Arguments:
        name: globalLBBackendPool
        loadbalancerId: ${exampleLB.id}