Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Hpegl Provider
  3. API Docs
  4. VmaasLoadBalancerPool
hpegl 0.4.18 published on Friday, Apr 18, 2025 by hpe
hpe/terraform-provider-hpegl

hpegl.VmaasLoadBalancerPool

Explore with Pulumi AI

hpegl logo
hpegl 0.4.18 published on Friday, Apr 18, 2025 by hpe
hpe/terraform-provider-hpegl

    Compatible version >= 5.4.6

    loadbalancer Pool resource facilitates creating, updating and deleting NSX-T Network Load Balancer Pools. hpegl.VmaasLoadBalancerPool resource supports NSX-T Load Balancer Pool creation.

    Example Usage

    Creating NSX-T Load Balancer Pool With All Possible Attributes

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

// (C) Copyright 2022 Hewlett Packard Enterprise Development LP
const tfPOOL = new hpegl.VmaasLoadBalancerPool("tfPOOL", {
    lbId: data.hpegl_vmaas_load_balancer.tf_lb.id,
    description: "POOL created using tf",
    minActiveMembers: 1,
    algorithm: "WEIGHTED_ROUND_ROBIN",
    configs: [{
        snatTranslationType: "LBSnatAutoMap",
        activeMonitorPaths: data.hpegl_vmaas_load_balancer_monitor.tf_lb_active.id,
        passiveMonitorPath: data.hpegl_vmaas_load_balancer_monitor.tf_lb_passive.id,
        tcpMultiplexing: false,
        tcpMultiplexingNumber: 6,
        memberGroups: [{
            group: data.hpegl_vmaas_lb_pool_member_group.tf_pool_group.external_id,
            maxIpListSize: 1,
            ipRevisionFilter: "IPV4",
            port: 80,
        }],
    }],
    tags: [{
        tag: "tag1",
        scope: "scope1",
    }],
});

    import pulumi
import pulumi_hpegl as hpegl

# (C) Copyright 2022 Hewlett Packard Enterprise Development LP
tf_pool = hpegl.VmaasLoadBalancerPool("tfPOOL",
    lb_id=data["hpegl_vmaas_load_balancer"]["tf_lb"]["id"],
    description="POOL created using tf",
    min_active_members=1,
    algorithm="WEIGHTED_ROUND_ROBIN",
    configs=[{
        "snat_translation_type": "LBSnatAutoMap",
        "active_monitor_paths": data["hpegl_vmaas_load_balancer_monitor"]["tf_lb_active"]["id"],
        "passive_monitor_path": data["hpegl_vmaas_load_balancer_monitor"]["tf_lb_passive"]["id"],
        "tcp_multiplexing": False,
        "tcp_multiplexing_number": 6,
        "member_groups": [{
            "group": data["hpegl_vmaas_lb_pool_member_group"]["tf_pool_group"]["external_id"],
            "max_ip_list_size": 1,
            "ip_revision_filter": "IPV4",
            "port": 80,
        }],
    }],
    tags=[{
        "tag": "tag1",
        "scope": "scope1",
    }])

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/hpegl/hpegl"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// (C) Copyright 2022 Hewlett Packard Enterprise Development LP
		_, err := hpegl.NewVmaasLoadBalancerPool(ctx, "tfPOOL", &hpegl.VmaasLoadBalancerPoolArgs{
			LbId:             pulumi.Any(data.Hpegl_vmaas_load_balancer.Tf_lb.Id),
			Description:      pulumi.String("POOL created using tf"),
			MinActiveMembers: pulumi.Float64(1),
			Algorithm:        pulumi.String("WEIGHTED_ROUND_ROBIN"),
			Configs: hpegl.VmaasLoadBalancerPoolConfigArray{
				&hpegl.VmaasLoadBalancerPoolConfigArgs{
					SnatTranslationType:   pulumi.String("LBSnatAutoMap"),
					ActiveMonitorPaths:    pulumi.Any(data.Hpegl_vmaas_load_balancer_monitor.Tf_lb_active.Id),
					PassiveMonitorPath:    pulumi.Any(data.Hpegl_vmaas_load_balancer_monitor.Tf_lb_passive.Id),
					TcpMultiplexing:       pulumi.Bool(false),
					TcpMultiplexingNumber: pulumi.Float64(6),
					MemberGroups: hpegl.VmaasLoadBalancerPoolConfigMemberGroupArray{
						&hpegl.VmaasLoadBalancerPoolConfigMemberGroupArgs{
							Group:            pulumi.Any(data.Hpegl_vmaas_lb_pool_member_group.Tf_pool_group.External_id),
							MaxIpListSize:    pulumi.Float64(1),
							IpRevisionFilter: pulumi.String("IPV4"),
							Port:             pulumi.Float64(80),
						},
					},
				},
			},
			Tags: hpegl.VmaasLoadBalancerPoolTagArray{
				&hpegl.VmaasLoadBalancerPoolTagArgs{
					Tag:   pulumi.String("tag1"),
					Scope: pulumi.String("scope1"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // (C) Copyright 2022 Hewlett Packard Enterprise Development LP
    var tfPOOL = new Hpegl.VmaasLoadBalancerPool("tfPOOL", new()
    {
        LbId = data.Hpegl_vmaas_load_balancer.Tf_lb.Id,
        Description = "POOL created using tf",
        MinActiveMembers = 1,
        Algorithm = "WEIGHTED_ROUND_ROBIN",
        Configs = new[]
        {
            new Hpegl.Inputs.VmaasLoadBalancerPoolConfigArgs
            {
                SnatTranslationType = "LBSnatAutoMap",
                ActiveMonitorPaths = data.Hpegl_vmaas_load_balancer_monitor.Tf_lb_active.Id,
                PassiveMonitorPath = data.Hpegl_vmaas_load_balancer_monitor.Tf_lb_passive.Id,
                TcpMultiplexing = false,
                TcpMultiplexingNumber = 6,
                MemberGroups = new[]
                {
                    new Hpegl.Inputs.VmaasLoadBalancerPoolConfigMemberGroupArgs
                    {
                        Group = data.Hpegl_vmaas_lb_pool_member_group.Tf_pool_group.External_id,
                        MaxIpListSize = 1,
                        IpRevisionFilter = "IPV4",
                        Port = 80,
                    },
                },
            },
        },
        Tags = new[]
        {
            new Hpegl.Inputs.VmaasLoadBalancerPoolTagArgs
            {
                Tag = "tag1",
                Scope = "scope1",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hpegl.VmaasLoadBalancerPool;
import com.pulumi.hpegl.VmaasLoadBalancerPoolArgs;
import com.pulumi.hpegl.inputs.VmaasLoadBalancerPoolConfigArgs;
import com.pulumi.hpegl.inputs.VmaasLoadBalancerPoolTagArgs;
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) {
        // (C) Copyright 2022 Hewlett Packard Enterprise Development LP
        var tfPOOL = new VmaasLoadBalancerPool("tfPOOL", VmaasLoadBalancerPoolArgs.builder()
            .lbId(data.hpegl_vmaas_load_balancer().tf_lb().id())
            .description("POOL created using tf")
            .minActiveMembers(1)
            .algorithm("WEIGHTED_ROUND_ROBIN")
            .configs(VmaasLoadBalancerPoolConfigArgs.builder()
                .snatTranslationType("LBSnatAutoMap")
                .activeMonitorPaths(data.hpegl_vmaas_load_balancer_monitor().tf_lb_active().id())
                .passiveMonitorPath(data.hpegl_vmaas_load_balancer_monitor().tf_lb_passive().id())
                .tcpMultiplexing(false)
                .tcpMultiplexingNumber(6)
                .memberGroups(VmaasLoadBalancerPoolConfigMemberGroupArgs.builder()
                    .group(data.hpegl_vmaas_lb_pool_member_group().tf_pool_group().external_id())
                    .maxIpListSize(1)
                    .ipRevisionFilter("IPV4")
                    .port(80)
                    .build())
                .build())
            .tags(VmaasLoadBalancerPoolTagArgs.builder()
                .tag("tag1")
                .scope("scope1")
                .build())
            .build());

    }
}

    resources:
  # (C) Copyright 2022 Hewlett Packard Enterprise Development LP
  tfPOOL:
    type: hpegl:VmaasLoadBalancerPool
    properties:
      lbId: ${data.hpegl_vmaas_load_balancer.tf_lb.id}
      description: POOL created using tf
      minActiveMembers: 1
      algorithm: WEIGHTED_ROUND_ROBIN
      configs:
        - snatTranslationType: LBSnatAutoMap
          activeMonitorPaths: ${data.hpegl_vmaas_load_balancer_monitor.tf_lb_active.id}
          passiveMonitorPath: ${data.hpegl_vmaas_load_balancer_monitor.tf_lb_passive.id}
          tcpMultiplexing: false
          tcpMultiplexingNumber: 6
          memberGroups:
            - group: ${data.hpegl_vmaas_lb_pool_member_group.tf_pool_group.external_id}
              maxIpListSize: 1
              ipRevisionFilter: IPV4
              port: 80
      tags:
        - tag: tag1
          scope: scope1

    Create VmaasLoadBalancerPool Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new VmaasLoadBalancerPool(name: string, args: VmaasLoadBalancerPoolArgs, opts?: CustomResourceOptions);
    @overload
def VmaasLoadBalancerPool(resource_name: str,
                          args: VmaasLoadBalancerPoolArgs,
                          opts: Optional[ResourceOptions] = None)

@overload
def VmaasLoadBalancerPool(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          algorithm: Optional[str] = None,
                          lb_id: Optional[float] = None,
                          configs: Optional[Sequence[VmaasLoadBalancerPoolConfigArgs]] = None,
                          description: Optional[str] = None,
                          min_active_members: Optional[float] = None,
                          name: Optional[str] = None,
                          tags: Optional[Sequence[VmaasLoadBalancerPoolTagArgs]] = None,
                          vmaas_load_balancer_pool_id: Optional[str] = None)
    func NewVmaasLoadBalancerPool(ctx *Context, name string, args VmaasLoadBalancerPoolArgs, opts ...ResourceOption) (*VmaasLoadBalancerPool, error)
    public VmaasLoadBalancerPool(string name, VmaasLoadBalancerPoolArgs args, CustomResourceOptions? opts = null)
    public VmaasLoadBalancerPool(String name, VmaasLoadBalancerPoolArgs args)
public VmaasLoadBalancerPool(String name, VmaasLoadBalancerPoolArgs args, CustomResourceOptions options)

    type: hpegl:VmaasLoadBalancerPool
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args VmaasLoadBalancerPoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args VmaasLoadBalancerPoolArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args VmaasLoadBalancerPoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args VmaasLoadBalancerPoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args VmaasLoadBalancerPoolArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var vmaasLoadBalancerPoolResource = new Hpegl.VmaasLoadBalancerPool("vmaasLoadBalancerPoolResource", new()
{
    Algorithm = "string",
    LbId = 0,
    Configs = new[]
    {
        new Hpegl.Inputs.VmaasLoadBalancerPoolConfigArgs
        {
            ActiveMonitorPaths = 0,
            MemberGroups = new[]
            {
                new Hpegl.Inputs.VmaasLoadBalancerPoolConfigMemberGroupArgs
                {
                    Group = "string",
                    IpRevisionFilter = "string",
                    MaxIpListSize = 0,
                    Port = 0,
                },
            },
            PassiveMonitorPath = 0,
            SnatIpAddress = "string",
            SnatTranslationType = "string",
            TcpMultiplexing = false,
            TcpMultiplexingNumber = 0,
        },
    },
    Description = "string",
    MinActiveMembers = 0,
    Name = "string",
    Tags = new[]
    {
        new Hpegl.Inputs.VmaasLoadBalancerPoolTagArgs
        {
            Scope = "string",
            Tag = "string",
        },
    },
    VmaasLoadBalancerPoolId = "string",
});

    example, err := hpegl.NewVmaasLoadBalancerPool(ctx, "vmaasLoadBalancerPoolResource", &hpegl.VmaasLoadBalancerPoolArgs{
	Algorithm: pulumi.String("string"),
	LbId:      pulumi.Float64(0),
	Configs: hpegl.VmaasLoadBalancerPoolConfigArray{
		&hpegl.VmaasLoadBalancerPoolConfigArgs{
			ActiveMonitorPaths: pulumi.Float64(0),
			MemberGroups: hpegl.VmaasLoadBalancerPoolConfigMemberGroupArray{
				&hpegl.VmaasLoadBalancerPoolConfigMemberGroupArgs{
					Group:            pulumi.String("string"),
					IpRevisionFilter: pulumi.String("string"),
					MaxIpListSize:    pulumi.Float64(0),
					Port:             pulumi.Float64(0),
				},
			},
			PassiveMonitorPath:    pulumi.Float64(0),
			SnatIpAddress:         pulumi.String("string"),
			SnatTranslationType:   pulumi.String("string"),
			TcpMultiplexing:       pulumi.Bool(false),
			TcpMultiplexingNumber: pulumi.Float64(0),
		},
	},
	Description:      pulumi.String("string"),
	MinActiveMembers: pulumi.Float64(0),
	Name:             pulumi.String("string"),
	Tags: hpegl.VmaasLoadBalancerPoolTagArray{
		&hpegl.VmaasLoadBalancerPoolTagArgs{
			Scope: pulumi.String("string"),
			Tag:   pulumi.String("string"),
		},
	},
	VmaasLoadBalancerPoolId: pulumi.String("string"),
})

    var vmaasLoadBalancerPoolResource = new VmaasLoadBalancerPool("vmaasLoadBalancerPoolResource", VmaasLoadBalancerPoolArgs.builder()
    .algorithm("string")
    .lbId(0)
    .configs(VmaasLoadBalancerPoolConfigArgs.builder()
        .activeMonitorPaths(0)
        .memberGroups(VmaasLoadBalancerPoolConfigMemberGroupArgs.builder()
            .group("string")
            .ipRevisionFilter("string")
            .maxIpListSize(0)
            .port(0)
            .build())
        .passiveMonitorPath(0)
        .snatIpAddress("string")
        .snatTranslationType("string")
        .tcpMultiplexing(false)
        .tcpMultiplexingNumber(0)
        .build())
    .description("string")
    .minActiveMembers(0)
    .name("string")
    .tags(VmaasLoadBalancerPoolTagArgs.builder()
        .scope("string")
        .tag("string")
        .build())
    .vmaasLoadBalancerPoolId("string")
    .build());

    vmaas_load_balancer_pool_resource = hpegl.VmaasLoadBalancerPool("vmaasLoadBalancerPoolResource",
    algorithm="string",
    lb_id=0,
    configs=[{
        "active_monitor_paths": 0,
        "member_groups": [{
            "group": "string",
            "ip_revision_filter": "string",
            "max_ip_list_size": 0,
            "port": 0,
        }],
        "passive_monitor_path": 0,
        "snat_ip_address": "string",
        "snat_translation_type": "string",
        "tcp_multiplexing": False,
        "tcp_multiplexing_number": 0,
    }],
    description="string",
    min_active_members=0,
    name="string",
    tags=[{
        "scope": "string",
        "tag": "string",
    }],
    vmaas_load_balancer_pool_id="string")

    const vmaasLoadBalancerPoolResource = new hpegl.VmaasLoadBalancerPool("vmaasLoadBalancerPoolResource", {
    algorithm: "string",
    lbId: 0,
    configs: [{
        activeMonitorPaths: 0,
        memberGroups: [{
            group: "string",
            ipRevisionFilter: "string",
            maxIpListSize: 0,
            port: 0,
        }],
        passiveMonitorPath: 0,
        snatIpAddress: "string",
        snatTranslationType: "string",
        tcpMultiplexing: false,
        tcpMultiplexingNumber: 0,
    }],
    description: "string",
    minActiveMembers: 0,
    name: "string",
    tags: [{
        scope: "string",
        tag: "string",
    }],
    vmaasLoadBalancerPoolId: "string",
});

    type: hpegl:VmaasLoadBalancerPool
properties:
    algorithm: string
    configs:
        - activeMonitorPaths: 0
          memberGroups:
            - group: string
              ipRevisionFilter: string
              maxIpListSize: 0
              port: 0
          passiveMonitorPath: 0
          snatIpAddress: string
          snatTranslationType: string
          tcpMultiplexing: false
          tcpMultiplexingNumber: 0
    description: string
    lbId: 0
    minActiveMembers: 0
    name: string
    tags:
        - scope: string
          tag: string
    vmaasLoadBalancerPoolId: string

    VmaasLoadBalancerPool Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The VmaasLoadBalancerPool resource accepts the following input properties:

    Algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    LbId double
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    Configs List<VmaasLoadBalancerPoolConfig>
    pool Configuration
    Description string
    Creating the Network loadbalancer pool.
    MinActiveMembers double
    The minimum number of members for the pool to be considered active
    Name string
    Network loadbalancer pool name
    Tags List<VmaasLoadBalancerPoolTag>
    tags Configuration
    VmaasLoadBalancerPoolId string
    The ID of this resource.
    Algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    LbId float64
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    Configs []VmaasLoadBalancerPoolConfigArgs
    pool Configuration
    Description string
    Creating the Network loadbalancer pool.
    MinActiveMembers float64
    The minimum number of members for the pool to be considered active
    Name string
    Network loadbalancer pool name
    Tags []VmaasLoadBalancerPoolTagArgs
    tags Configuration
    VmaasLoadBalancerPoolId string
    The ID of this resource.
    algorithm String
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    lbId Double
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    configs List<VmaasLoadBalancerPoolConfig>
    pool Configuration
    description String
    Creating the Network loadbalancer pool.
    minActiveMembers Double
    The minimum number of members for the pool to be considered active
    name String
    Network loadbalancer pool name
    tags List<VmaasLoadBalancerPoolTag>
    tags Configuration
    vmaasLoadBalancerPoolId String
    The ID of this resource.
    algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    lbId number
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    configs VmaasLoadBalancerPoolConfig[]
    pool Configuration
    description string
    Creating the Network loadbalancer pool.
    minActiveMembers number
    The minimum number of members for the pool to be considered active
    name string
    Network loadbalancer pool name
    tags VmaasLoadBalancerPoolTag[]
    tags Configuration
    vmaasLoadBalancerPoolId string
    The ID of this resource.
    algorithm str
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    lb_id float
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    configs Sequence[VmaasLoadBalancerPoolConfigArgs]
    pool Configuration
    description str
    Creating the Network loadbalancer pool.
    min_active_members float
    The minimum number of members for the pool to be considered active
    name str
    Network loadbalancer pool name
    tags Sequence[VmaasLoadBalancerPoolTagArgs]
    tags Configuration
    vmaas_load_balancer_pool_id str
    The ID of this resource.
    algorithm String
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    lbId Number
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    configs List<Property Map>
    pool Configuration
    description String
    Creating the Network loadbalancer pool.
    minActiveMembers Number
    The minimum number of members for the pool to be considered active
    name String
    Network loadbalancer pool name
    tags List<Property Map>
    tags Configuration
    vmaasLoadBalancerPoolId String
    The ID of this resource.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the VmaasLoadBalancerPool resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing VmaasLoadBalancerPool Resource

    Get an existing VmaasLoadBalancerPool resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: VmaasLoadBalancerPoolState, opts?: CustomResourceOptions): VmaasLoadBalancerPool
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        algorithm: Optional[str] = None,
        configs: Optional[Sequence[VmaasLoadBalancerPoolConfigArgs]] = None,
        description: Optional[str] = None,
        lb_id: Optional[float] = None,
        min_active_members: Optional[float] = None,
        name: Optional[str] = None,
        tags: Optional[Sequence[VmaasLoadBalancerPoolTagArgs]] = None,
        vmaas_load_balancer_pool_id: Optional[str] = None) -> VmaasLoadBalancerPool
    func GetVmaasLoadBalancerPool(ctx *Context, name string, id IDInput, state *VmaasLoadBalancerPoolState, opts ...ResourceOption) (*VmaasLoadBalancerPool, error)
    public static VmaasLoadBalancerPool Get(string name, Input<string> id, VmaasLoadBalancerPoolState? state, CustomResourceOptions? opts = null)
    public static VmaasLoadBalancerPool get(String name, Output<String> id, VmaasLoadBalancerPoolState state, CustomResourceOptions options)
    resources:  _:    type: hpegl:VmaasLoadBalancerPool    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    Configs List<VmaasLoadBalancerPoolConfig>
    pool Configuration
    Description string
    Creating the Network loadbalancer pool.
    LbId double
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    MinActiveMembers double
    The minimum number of members for the pool to be considered active
    Name string
    Network loadbalancer pool name
    Tags List<VmaasLoadBalancerPoolTag>
    tags Configuration
    VmaasLoadBalancerPoolId string
    The ID of this resource.
    Algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    Configs []VmaasLoadBalancerPoolConfigArgs
    pool Configuration
    Description string
    Creating the Network loadbalancer pool.
    LbId float64
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    MinActiveMembers float64
    The minimum number of members for the pool to be considered active
    Name string
    Network loadbalancer pool name
    Tags []VmaasLoadBalancerPoolTagArgs
    tags Configuration
    VmaasLoadBalancerPoolId string
    The ID of this resource.
    algorithm String
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    configs List<VmaasLoadBalancerPoolConfig>
    pool Configuration
    description String
    Creating the Network loadbalancer pool.
    lbId Double
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    minActiveMembers Double
    The minimum number of members for the pool to be considered active
    name String
    Network loadbalancer pool name
    tags List<VmaasLoadBalancerPoolTag>
    tags Configuration
    vmaasLoadBalancerPoolId String
    The ID of this resource.
    algorithm string
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    configs VmaasLoadBalancerPoolConfig[]
    pool Configuration
    description string
    Creating the Network loadbalancer pool.
    lbId number
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    minActiveMembers number
    The minimum number of members for the pool to be considered active
    name string
    Network loadbalancer pool name
    tags VmaasLoadBalancerPoolTag[]
    tags Configuration
    vmaasLoadBalancerPoolId string
    The ID of this resource.
    algorithm str
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    configs Sequence[VmaasLoadBalancerPoolConfigArgs]
    pool Configuration
    description str
    Creating the Network loadbalancer pool.
    lb_id float
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    min_active_members float
    The minimum number of members for the pool to be considered active
    name str
    Network loadbalancer pool name
    tags Sequence[VmaasLoadBalancerPoolTagArgs]
    tags Configuration
    vmaas_load_balancer_pool_id str
    The ID of this resource.
    algorithm String
    Load balancing pool algorithm controls how the incoming connectionsare distributed among the members
    configs List<Property Map>
    pool Configuration
    description String
    Creating the Network loadbalancer pool.
    lbId Number
    Parent lb ID, lb_id can be obtained by using LB datasource/resource.
    minActiveMembers Number
    The minimum number of members for the pool to be considered active
    name String
    Network loadbalancer pool name
    tags List<Property Map>
    tags Configuration
    vmaasLoadBalancerPoolId String
    The ID of this resource.

    Supporting Types

    VmaasLoadBalancerPoolConfig, VmaasLoadBalancerPoolConfigArgs

    ActiveMonitorPaths double
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    MemberGroups List<VmaasLoadBalancerPoolConfigMemberGroup>
    member group
    PassiveMonitorPath double
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    SnatIpAddress string
    Address of the snat_ip for Network loadbalancer pool
    SnatTranslationType string
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    TcpMultiplexing bool
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    TcpMultiplexingNumber double
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests
    ActiveMonitorPaths float64
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    MemberGroups []VmaasLoadBalancerPoolConfigMemberGroup
    member group
    PassiveMonitorPath float64
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    SnatIpAddress string
    Address of the snat_ip for Network loadbalancer pool
    SnatTranslationType string
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    TcpMultiplexing bool
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    TcpMultiplexingNumber float64
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests
    activeMonitorPaths Double
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    memberGroups List<VmaasLoadBalancerPoolConfigMemberGroup>
    member group
    passiveMonitorPath Double
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    snatIpAddress String
    Address of the snat_ip for Network loadbalancer pool
    snatTranslationType String
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    tcpMultiplexing Boolean
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    tcpMultiplexingNumber Double
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests
    activeMonitorPaths number
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    memberGroups VmaasLoadBalancerPoolConfigMemberGroup[]
    member group
    passiveMonitorPath number
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    snatIpAddress string
    Address of the snat_ip for Network loadbalancer pool
    snatTranslationType string
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    tcpMultiplexing boolean
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    tcpMultiplexingNumber number
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests
    active_monitor_paths float
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    member_groups Sequence[VmaasLoadBalancerPoolConfigMemberGroup]
    member group
    passive_monitor_path float
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    snat_ip_address str
    Address of the snat_ip for Network loadbalancer pool
    snat_translation_type str
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    tcp_multiplexing bool
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    tcp_multiplexing_number float
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests
    activeMonitorPaths Number
    Active Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the active monitor ID
    memberGroups List<Property Map>
    member group
    passiveMonitorPath Number
    Passive Monitor ID, Get the id from hpeglvmaasloadbalancermonitor datasource to obtain the passive monitor ID
    snatIpAddress String
    Address of the snat_ip for Network loadbalancer pool
    snatTranslationType String
    Network Loadbalancer Supported values are LBSnatAutoMap,LBSnatDisabled, LBSnatIpPool
    tcpMultiplexing Boolean
    With TCP multiplexing, user can use the same TCP connectionbetween a load balancer and the server forsending multiple client requests from different client TCP connections.
    tcpMultiplexingNumber Number
    The maximum number of TCP connections per poolthat are idly kept alive for sending future client requests

    VmaasLoadBalancerPoolConfigMemberGroup, VmaasLoadBalancerPoolConfigMemberGroupArgs

    Group string
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    IpRevisionFilter string
    Ip version filter is used to filter IPv4 addresses from the grouping object
    MaxIpListSize double
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    Port double
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM
    Group string
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    IpRevisionFilter string
    Ip version filter is used to filter IPv4 addresses from the grouping object
    MaxIpListSize float64
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    Port float64
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM
    group String
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    ipRevisionFilter String
    Ip version filter is used to filter IPv4 addresses from the grouping object
    maxIpListSize Double
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    port Double
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM
    group string
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    ipRevisionFilter string
    Ip version filter is used to filter IPv4 addresses from the grouping object
    maxIpListSize number
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    port number
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM
    group str
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    ip_revision_filter str
    Ip version filter is used to filter IPv4 addresses from the grouping object
    max_ip_list_size float
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    port float
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM
    group String
    Pool Member Groups path, get the externalId from hpeglvmaaslbpoolmember_groupdatasource to obtain the path
    ipRevisionFilter String
    Ip version filter is used to filter IPv4 addresses from the grouping object
    maxIpListSize Number
    It Should only be specified if limit_ip_list_size is set to true.Limits the max number of pool members to the specified value
    port Number
    This is member port, The traffic which enter into VIP will get transferto member groups based on the port specified.Depends on the application running on the member VM

    VmaasLoadBalancerPoolTag, VmaasLoadBalancerPoolTagArgs

    Scope string
    scope for Network Load balancer Pool
    Tag string
    tag for Network Load balancer Pool
    Scope string
    scope for Network Load balancer Pool
    Tag string
    tag for Network Load balancer Pool
    scope String
    scope for Network Load balancer Pool
    tag String
    tag for Network Load balancer Pool
    scope string
    scope for Network Load balancer Pool
    tag string
    tag for Network Load balancer Pool
    scope str
    scope for Network Load balancer Pool
    tag str
    tag for Network Load balancer Pool
    scope String
    scope for Network Load balancer Pool
    tag String
    tag for Network Load balancer Pool

    Package Details

    Repository
    hpegl hpe/terraform-provider-hpegl
    License
    Notes
    This Pulumi package is based on the hpegl Terraform Provider.
    hpegl logo
    hpegl 0.4.18 published on Friday, Apr 18, 2025 by hpe
    hpe/terraform-provider-hpegl