pulumi-azure-native 2.36.1a1712722234__py3-none-any.whl → 2.36.1a1713161317__py3-none-any.whl

pulumi_azure_native/network/v20231101/get_load_balancer.py

@@ -0,0 +1,292 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from ... import _utilities
+from . import outputs
+
+__all__ = [
+    'GetLoadBalancerResult',
+    'AwaitableGetLoadBalancerResult',
+    'get_load_balancer',
+    'get_load_balancer_output',
+]
+
+@pulumi.output_type
+class GetLoadBalancerResult:
+    """
+    LoadBalancer resource.
+    """
+    def __init__(__self__, backend_address_pools=None, etag=None, extended_location=None, frontend_ip_configurations=None, id=None, inbound_nat_pools=None, inbound_nat_rules=None, load_balancing_rules=None, location=None, name=None, outbound_rules=None, probes=None, provisioning_state=None, resource_guid=None, sku=None, tags=None, type=None):
+        if backend_address_pools and not isinstance(backend_address_pools, list):
+            raise TypeError("Expected argument 'backend_address_pools' to be a list")
+        pulumi.set(__self__, "backend_address_pools", backend_address_pools)
+        if etag and not isinstance(etag, str):
+            raise TypeError("Expected argument 'etag' to be a str")
+        pulumi.set(__self__, "etag", etag)
+        if extended_location and not isinstance(extended_location, dict):
+            raise TypeError("Expected argument 'extended_location' to be a dict")
+        pulumi.set(__self__, "extended_location", extended_location)
+        if frontend_ip_configurations and not isinstance(frontend_ip_configurations, list):
+            raise TypeError("Expected argument 'frontend_ip_configurations' to be a list")
+        pulumi.set(__self__, "frontend_ip_configurations", frontend_ip_configurations)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if inbound_nat_pools and not isinstance(inbound_nat_pools, list):
+            raise TypeError("Expected argument 'inbound_nat_pools' to be a list")
+        pulumi.set(__self__, "inbound_nat_pools", inbound_nat_pools)
+        if inbound_nat_rules and not isinstance(inbound_nat_rules, list):
+            raise TypeError("Expected argument 'inbound_nat_rules' to be a list")
+        pulumi.set(__self__, "inbound_nat_rules", inbound_nat_rules)
+        if load_balancing_rules and not isinstance(load_balancing_rules, list):
+            raise TypeError("Expected argument 'load_balancing_rules' to be a list")
+        pulumi.set(__self__, "load_balancing_rules", load_balancing_rules)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if outbound_rules and not isinstance(outbound_rules, list):
+            raise TypeError("Expected argument 'outbound_rules' to be a list")
+        pulumi.set(__self__, "outbound_rules", outbound_rules)
+        if probes and not isinstance(probes, list):
+            raise TypeError("Expected argument 'probes' to be a list")
+        pulumi.set(__self__, "probes", probes)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if resource_guid and not isinstance(resource_guid, str):
+            raise TypeError("Expected argument 'resource_guid' to be a str")
+        pulumi.set(__self__, "resource_guid", resource_guid)
+        if sku and not isinstance(sku, dict):
+            raise TypeError("Expected argument 'sku' to be a dict")
+        pulumi.set(__self__, "sku", sku)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="backendAddressPools")
+    def backend_address_pools(self) -> Optional[Sequence['outputs.BackendAddressPoolResponse']]:
+        """
+        Collection of backend address pools used by a load balancer.
+        """
+        return pulumi.get(self, "backend_address_pools")
+
+    @property
+    @pulumi.getter
+    def etag(self) -> str:
+        """
+        A unique read-only string that changes whenever the resource is updated.
+        """
+        return pulumi.get(self, "etag")
+
+    @property
+    @pulumi.getter(name="extendedLocation")
+    def extended_location(self) -> Optional['outputs.ExtendedLocationResponse']:
+        """
+        The extended location of the load balancer.
+        """
+        return pulumi.get(self, "extended_location")
+
+    @property
+    @pulumi.getter(name="frontendIPConfigurations")
+    def frontend_ip_configurations(self) -> Optional[Sequence['outputs.FrontendIPConfigurationResponse']]:
+        """
+        Object representing the frontend IPs to be used for the load balancer.
+        """
+        return pulumi.get(self, "frontend_ip_configurations")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="inboundNatPools")
+    def inbound_nat_pools(self) -> Optional[Sequence['outputs.InboundNatPoolResponse']]:
+        """
+        Defines an external port range for inbound NAT to a single backend port on NICs associated with a load balancer. Inbound NAT rules are created automatically for each NIC associated with the Load Balancer using an external port from this range. Defining an Inbound NAT pool on your Load Balancer is mutually exclusive with defining inbound NAT rules. Inbound NAT pools are referenced from virtual machine scale sets. NICs that are associated with individual virtual machines cannot reference an inbound NAT pool. They have to reference individual inbound NAT rules.
+        """
+        return pulumi.get(self, "inbound_nat_pools")
+
+    @property
+    @pulumi.getter(name="inboundNatRules")
+    def inbound_nat_rules(self) -> Optional[Sequence['outputs.InboundNatRuleResponse']]:
+        """
+        Collection of inbound NAT Rules used by a load balancer. Defining inbound NAT rules on your load balancer is mutually exclusive with defining an inbound NAT pool. Inbound NAT pools are referenced from virtual machine scale sets. NICs that are associated with individual virtual machines cannot reference an Inbound NAT pool. They have to reference individual inbound NAT rules.
+        """
+        return pulumi.get(self, "inbound_nat_rules")
+
+    @property
+    @pulumi.getter(name="loadBalancingRules")
+    def load_balancing_rules(self) -> Optional[Sequence['outputs.LoadBalancingRuleResponse']]:
+        """
+        Object collection representing the load balancing rules Gets the provisioning.
+        """
+        return pulumi.get(self, "load_balancing_rules")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[str]:
+        """
+        Resource location.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Resource name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="outboundRules")
+    def outbound_rules(self) -> Optional[Sequence['outputs.OutboundRuleResponse']]:
+        """
+        The outbound rules.
+        """
+        return pulumi.get(self, "outbound_rules")
+
+    @property
+    @pulumi.getter
+    def probes(self) -> Optional[Sequence['outputs.ProbeResponse']]:
+        """
+        Collection of probe objects used in the load balancer.
+        """
+        return pulumi.get(self, "probes")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The provisioning state of the load balancer resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="resourceGuid")
+    def resource_guid(self) -> str:
+        """
+        The resource GUID property of the load balancer resource.
+        """
+        return pulumi.get(self, "resource_guid")
+
+    @property
+    @pulumi.getter
+    def sku(self) -> Optional['outputs.LoadBalancerSkuResponse']:
+        """
+        The load balancer SKU.
+        """
+        return pulumi.get(self, "sku")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, str]]:
+        """
+        Resource tags.
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Resource type.
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetLoadBalancerResult(GetLoadBalancerResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetLoadBalancerResult(
+            backend_address_pools=self.backend_address_pools,
+            etag=self.etag,
+            extended_location=self.extended_location,
+            frontend_ip_configurations=self.frontend_ip_configurations,
+            id=self.id,
+            inbound_nat_pools=self.inbound_nat_pools,
+            inbound_nat_rules=self.inbound_nat_rules,
+            load_balancing_rules=self.load_balancing_rules,
+            location=self.location,
+            name=self.name,
+            outbound_rules=self.outbound_rules,
+            probes=self.probes,
+            provisioning_state=self.provisioning_state,
+            resource_guid=self.resource_guid,
+            sku=self.sku,
+            tags=self.tags,
+            type=self.type)
+
+
+def get_load_balancer(expand: Optional[str] = None,
+                      load_balancer_name: Optional[str] = None,
+                      resource_group_name: Optional[str] = None,
+                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLoadBalancerResult:
+    """
+    Gets the specified load balancer.
+
+
+    :param str expand: Expands referenced resources.
+    :param str load_balancer_name: The name of the load balancer.
+    :param str resource_group_name: The name of the resource group.
+    """
+    __args__ = dict()
+    __args__['expand'] = expand
+    __args__['loadBalancerName'] = load_balancer_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:network/v20231101:getLoadBalancer', __args__, opts=opts, typ=GetLoadBalancerResult).value
+
+    return AwaitableGetLoadBalancerResult(
+        backend_address_pools=pulumi.get(__ret__, 'backend_address_pools'),
+        etag=pulumi.get(__ret__, 'etag'),
+        extended_location=pulumi.get(__ret__, 'extended_location'),
+        frontend_ip_configurations=pulumi.get(__ret__, 'frontend_ip_configurations'),
+        id=pulumi.get(__ret__, 'id'),
+        inbound_nat_pools=pulumi.get(__ret__, 'inbound_nat_pools'),
+        inbound_nat_rules=pulumi.get(__ret__, 'inbound_nat_rules'),
+        load_balancing_rules=pulumi.get(__ret__, 'load_balancing_rules'),
+        location=pulumi.get(__ret__, 'location'),
+        name=pulumi.get(__ret__, 'name'),
+        outbound_rules=pulumi.get(__ret__, 'outbound_rules'),
+        probes=pulumi.get(__ret__, 'probes'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        resource_guid=pulumi.get(__ret__, 'resource_guid'),
+        sku=pulumi.get(__ret__, 'sku'),
+        tags=pulumi.get(__ret__, 'tags'),
+        type=pulumi.get(__ret__, 'type'))
+
+
+@_utilities.lift_output_func(get_load_balancer)
+def get_load_balancer_output(expand: Optional[pulumi.Input[Optional[str]]] = None,
+                             load_balancer_name: Optional[pulumi.Input[str]] = None,
+                             resource_group_name: Optional[pulumi.Input[str]] = None,
+                             opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetLoadBalancerResult]:
+    """
+    Gets the specified load balancer.
+
+
+    :param str expand: Expands referenced resources.
+    :param str load_balancer_name: The name of the load balancer.
+    :param str resource_group_name: The name of the resource group.
+    """
+    ...

pulumi_azure_native/network/v20231101/get_load_balancer_backend_address_pool.py

@@ -0,0 +1,279 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from ... import _utilities
+from . import outputs
+
+__all__ = [
+    'GetLoadBalancerBackendAddressPoolResult',
+    'AwaitableGetLoadBalancerBackendAddressPoolResult',
+    'get_load_balancer_backend_address_pool',
+    'get_load_balancer_backend_address_pool_output',
+]
+
+@pulumi.output_type
+class GetLoadBalancerBackendAddressPoolResult:
+    """
+    Pool of backend IP addresses.
+    """
+    def __init__(__self__, backend_ip_configurations=None, drain_period_in_seconds=None, etag=None, id=None, inbound_nat_rules=None, load_balancer_backend_addresses=None, load_balancing_rules=None, location=None, name=None, outbound_rule=None, outbound_rules=None, provisioning_state=None, sync_mode=None, tunnel_interfaces=None, type=None, virtual_network=None):
+        if backend_ip_configurations and not isinstance(backend_ip_configurations, list):
+            raise TypeError("Expected argument 'backend_ip_configurations' to be a list")
+        pulumi.set(__self__, "backend_ip_configurations", backend_ip_configurations)
+        if drain_period_in_seconds and not isinstance(drain_period_in_seconds, int):
+            raise TypeError("Expected argument 'drain_period_in_seconds' to be a int")
+        pulumi.set(__self__, "drain_period_in_seconds", drain_period_in_seconds)
+        if etag and not isinstance(etag, str):
+            raise TypeError("Expected argument 'etag' to be a str")
+        pulumi.set(__self__, "etag", etag)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if inbound_nat_rules and not isinstance(inbound_nat_rules, list):
+            raise TypeError("Expected argument 'inbound_nat_rules' to be a list")
+        pulumi.set(__self__, "inbound_nat_rules", inbound_nat_rules)
+        if load_balancer_backend_addresses and not isinstance(load_balancer_backend_addresses, list):
+            raise TypeError("Expected argument 'load_balancer_backend_addresses' to be a list")
+        pulumi.set(__self__, "load_balancer_backend_addresses", load_balancer_backend_addresses)
+        if load_balancing_rules and not isinstance(load_balancing_rules, list):
+            raise TypeError("Expected argument 'load_balancing_rules' to be a list")
+        pulumi.set(__self__, "load_balancing_rules", load_balancing_rules)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if outbound_rule and not isinstance(outbound_rule, dict):
+            raise TypeError("Expected argument 'outbound_rule' to be a dict")
+        pulumi.set(__self__, "outbound_rule", outbound_rule)
+        if outbound_rules and not isinstance(outbound_rules, list):
+            raise TypeError("Expected argument 'outbound_rules' to be a list")
+        pulumi.set(__self__, "outbound_rules", outbound_rules)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if sync_mode and not isinstance(sync_mode, str):
+            raise TypeError("Expected argument 'sync_mode' to be a str")
+        pulumi.set(__self__, "sync_mode", sync_mode)
+        if tunnel_interfaces and not isinstance(tunnel_interfaces, list):
+            raise TypeError("Expected argument 'tunnel_interfaces' to be a list")
+        pulumi.set(__self__, "tunnel_interfaces", tunnel_interfaces)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+        if virtual_network and not isinstance(virtual_network, dict):
+            raise TypeError("Expected argument 'virtual_network' to be a dict")
+        pulumi.set(__self__, "virtual_network", virtual_network)
+
+    @property
+    @pulumi.getter(name="backendIPConfigurations")
+    def backend_ip_configurations(self) -> Sequence['outputs.NetworkInterfaceIPConfigurationResponse']:
+        """
+        An array of references to IP addresses defined in network interfaces.
+        """
+        return pulumi.get(self, "backend_ip_configurations")
+
+    @property
+    @pulumi.getter(name="drainPeriodInSeconds")
+    def drain_period_in_seconds(self) -> Optional[int]:
+        """
+        Amount of seconds Load Balancer waits for before sending RESET to client and backend address.
+        """
+        return pulumi.get(self, "drain_period_in_seconds")
+
+    @property
+    @pulumi.getter
+    def etag(self) -> str:
+        """
+        A unique read-only string that changes whenever the resource is updated.
+        """
+        return pulumi.get(self, "etag")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="inboundNatRules")
+    def inbound_nat_rules(self) -> Sequence['outputs.SubResourceResponse']:
+        """
+        An array of references to inbound NAT rules that use this backend address pool.
+        """
+        return pulumi.get(self, "inbound_nat_rules")
+
+    @property
+    @pulumi.getter(name="loadBalancerBackendAddresses")
+    def load_balancer_backend_addresses(self) -> Optional[Sequence['outputs.LoadBalancerBackendAddressResponse']]:
+        """
+        An array of backend addresses.
+        """
+        return pulumi.get(self, "load_balancer_backend_addresses")
+
+    @property
+    @pulumi.getter(name="loadBalancingRules")
+    def load_balancing_rules(self) -> Sequence['outputs.SubResourceResponse']:
+        """
+        An array of references to load balancing rules that use this backend address pool.
+        """
+        return pulumi.get(self, "load_balancing_rules")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[str]:
+        """
+        The location of the backend address pool.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The name of the resource that is unique within the set of backend address pools used by the load balancer. This name can be used to access the resource.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="outboundRule")
+    def outbound_rule(self) -> 'outputs.SubResourceResponse':
+        """
+        A reference to an outbound rule that uses this backend address pool.
+        """
+        return pulumi.get(self, "outbound_rule")
+
+    @property
+    @pulumi.getter(name="outboundRules")
+    def outbound_rules(self) -> Sequence['outputs.SubResourceResponse']:
+        """
+        An array of references to outbound rules that use this backend address pool.
+        """
+        return pulumi.get(self, "outbound_rules")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The provisioning state of the backend address pool resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="syncMode")
+    def sync_mode(self) -> Optional[str]:
+        """
+        Backend address synchronous mode for the backend pool
+        """
+        return pulumi.get(self, "sync_mode")
+
+    @property
+    @pulumi.getter(name="tunnelInterfaces")
+    def tunnel_interfaces(self) -> Optional[Sequence['outputs.GatewayLoadBalancerTunnelInterfaceResponse']]:
+        """
+        An array of gateway load balancer tunnel interfaces.
+        """
+        return pulumi.get(self, "tunnel_interfaces")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of the resource.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="virtualNetwork")
+    def virtual_network(self) -> Optional['outputs.SubResourceResponse']:
+        """
+        A reference to a virtual network.
+        """
+        return pulumi.get(self, "virtual_network")
+
+
+class AwaitableGetLoadBalancerBackendAddressPoolResult(GetLoadBalancerBackendAddressPoolResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetLoadBalancerBackendAddressPoolResult(
+            backend_ip_configurations=self.backend_ip_configurations,
+            drain_period_in_seconds=self.drain_period_in_seconds,
+            etag=self.etag,
+            id=self.id,
+            inbound_nat_rules=self.inbound_nat_rules,
+            load_balancer_backend_addresses=self.load_balancer_backend_addresses,
+            load_balancing_rules=self.load_balancing_rules,
+            location=self.location,
+            name=self.name,
+            outbound_rule=self.outbound_rule,
+            outbound_rules=self.outbound_rules,
+            provisioning_state=self.provisioning_state,
+            sync_mode=self.sync_mode,
+            tunnel_interfaces=self.tunnel_interfaces,
+            type=self.type,
+            virtual_network=self.virtual_network)
+
+
+def get_load_balancer_backend_address_pool(backend_address_pool_name: Optional[str] = None,
+                                           load_balancer_name: Optional[str] = None,
+                                           resource_group_name: Optional[str] = None,
+                                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLoadBalancerBackendAddressPoolResult:
+    """
+    Gets load balancer backend address pool.
+
+
+    :param str backend_address_pool_name: The name of the backend address pool.
+    :param str load_balancer_name: The name of the load balancer.
+    :param str resource_group_name: The name of the resource group.
+    """
+    __args__ = dict()
+    __args__['backendAddressPoolName'] = backend_address_pool_name
+    __args__['loadBalancerName'] = load_balancer_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:network/v20231101:getLoadBalancerBackendAddressPool', __args__, opts=opts, typ=GetLoadBalancerBackendAddressPoolResult).value
+
+    return AwaitableGetLoadBalancerBackendAddressPoolResult(
+        backend_ip_configurations=pulumi.get(__ret__, 'backend_ip_configurations'),
+        drain_period_in_seconds=pulumi.get(__ret__, 'drain_period_in_seconds'),
+        etag=pulumi.get(__ret__, 'etag'),
+        id=pulumi.get(__ret__, 'id'),
+        inbound_nat_rules=pulumi.get(__ret__, 'inbound_nat_rules'),
+        load_balancer_backend_addresses=pulumi.get(__ret__, 'load_balancer_backend_addresses'),
+        load_balancing_rules=pulumi.get(__ret__, 'load_balancing_rules'),
+        location=pulumi.get(__ret__, 'location'),
+        name=pulumi.get(__ret__, 'name'),
+        outbound_rule=pulumi.get(__ret__, 'outbound_rule'),
+        outbound_rules=pulumi.get(__ret__, 'outbound_rules'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        sync_mode=pulumi.get(__ret__, 'sync_mode'),
+        tunnel_interfaces=pulumi.get(__ret__, 'tunnel_interfaces'),
+        type=pulumi.get(__ret__, 'type'),
+        virtual_network=pulumi.get(__ret__, 'virtual_network'))
+
+
+@_utilities.lift_output_func(get_load_balancer_backend_address_pool)
+def get_load_balancer_backend_address_pool_output(backend_address_pool_name: Optional[pulumi.Input[str]] = None,
+                                                  load_balancer_name: Optional[pulumi.Input[str]] = None,
+                                                  resource_group_name: Optional[pulumi.Input[str]] = None,
+                                                  opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetLoadBalancerBackendAddressPoolResult]:
+    """
+    Gets load balancer backend address pool.
+
+
+    :param str backend_address_pool_name: The name of the backend address pool.
+    :param str load_balancer_name: The name of the load balancer.
+    :param str resource_group_name: The name of the resource group.
+    """
+    ...