azure.lb.BackendAddressPoolAddress

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleVirtualNetwork = Output.Create(Azure.Network.GetVirtualNetwork.InvokeAsync(new Azure.Network.GetVirtualNetworkArgs
        {
            Name = "example-network",
            ResourceGroupName = "example-resources",
        }));
        var exampleLB = Output.Create(Azure.Lb.GetLB.InvokeAsync(new Azure.Lb.GetLBArgs
        {
            Name = "example-lb",
            ResourceGroupName = "example-resources",
        }));
        var exampleBackendAddressPool = exampleLB.Apply(exampleLB => Output.Create(Azure.Lb.GetBackendAddressPool.InvokeAsync(new Azure.Lb.GetBackendAddressPoolArgs
        {
            Name = "first",
            LoadbalancerId = exampleLB.Id,
        })));
        var exampleBackendAddressPoolAddress = new Azure.Lb.BackendAddressPoolAddress("exampleBackendAddressPoolAddress", new Azure.Lb.BackendAddressPoolAddressArgs
        {
            BackendAddressPoolId = exampleBackendAddressPool.Apply(exampleBackendAddressPool => exampleBackendAddressPool.Id),
            VirtualNetworkId = exampleVirtualNetwork.Apply(exampleVirtualNetwork => exampleVirtualNetwork.Id),
            IpAddress = "10.0.0.1",
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/lb"
	"github.com/pulumi/pulumi-azure/sdk/v4/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
		}
		return nil
	})
}

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",
});

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")