Updated on 2024-09-26 GMT+08:00

Creating a Backend Server Group

Function

This API is used to create a backend server group.

Constraints

If session-persistence is specified, cookie_name is available only when type is set to APP_COOKIE.

If listener_id is specified, the listener must have no backend server group associated.

Calling Method

For details, see Calling APIs.

URI

POST /v3/{project_id}/elb/pools

Table 1 Path Parameters

Parameter

Mandatory

Type

Description

project_id

Yes

String

Specifies the project ID.

Request Parameters

Table 2 Request header parameters

Parameter

Mandatory

Type

Description

X-Auth-Token

Yes

String

Specifies the token used for IAM authentication.

Table 3 Request body parameters

Parameter

Mandatory

Type

Description

pool

Yes

CreatePoolOption object

Specifies the request body for creating a backend server group.

Table 4 CreatePoolOption

Parameter

Mandatory

Type

Description

admin_state_up

No

Boolean

Specifies the administrative status of the backend server group. The value can only be updated to true.

description

No

String

Provides supplementary information about the backend server group.

lb_algorithm

Yes

String

Specifies the load balancing algorithm used by the load balancer to route requests to backend servers in the associated backend server group.

The value can be one of the following:

  • ROUND_ROBIN: weighted round robin

  • LEAST_CONNECTIONS: weighted least connections

  • SOURCE_IP: source IP hash

  • QUIC_CID: connection ID

Notes and constraints:

  • If the value is SOURCE_IP or QUIC_CID, the weight parameter will not take effect for backend servers.

  • QUIC_CID is supported only when the protocol of the backend server group is QUIC.

listener_id

No

String

Specifies the ID of the listener with which the backend server group is associated.

Notes and constraints:

  • Specify one of listener_id, loadbalancer_id, or type, or all of them.

  • Specify either listener_id or loadbalancer_id for backend server groups of shared load balancers.

loadbalancer_id

No

String

Specifies the ID of the load balancer with which the backend server group is associated.

Notes and constraints:

  • Specify one of listener_id, loadbalancer_id, or type, or all of them.

  • Specify either listener_id or loadbalancer_id for backend server groups of shared load balancers.

name

No

String

Specifies the backend server group name.

project_id

No

String

Specifies the project ID of the backend server group.

protocol

Yes

String

Specifies the protocol used by the backend server group to receive requests.

The value can be TCP, UDP, TLS, HTTP, HTTPS, gRPC, or QUIC.

Notes and constraints:

  • If the listener's protocol is UDP, the protocol of the backend server group must be UDPor QUIC.

  • If the listener's protocol is TCP, the protocol of the backend server group must be TCP.

  • If the listener's protocol is HTTP, the protocol of the backend server group must be HTTP.

  • If the listener's protocol is HTTPS, the protocol of the backend server group can be HTTP, HTTPS, or gRPC.

  • If the listener's protocol is TERMINATED_HTTPS, the protocol of the backend server group must be HTTP.

  • If the listener's protocol is QUIC, the protocol of the backend server group can be HTTP, HTTPS, or gRPC.

  • If the listener's protocol is TLS, the protocol of the backend server group can be TLS or TCP. If protocol of the backend server group is TCP, the ip_version must be set to v4.

  • If protocol of the backend server group is QUIC, session_persistence must be set to true, with type set to SOURCE_IP.

  • If protocol of the backend server group is gRPC, http2_enable of the listener must be set to true.

session_persistence

No

CreatePoolSessionPersistenceOption object

Specifies the sticky session.

slow_start

No

CreatePoolSlowStartOption object

Specifies slow start details. After you enable slow start, new backend servers added to the backend server group are warmed up, and the number of requests they can receive increases linearly during the configured slow start duration.

Notes and constraints: This parameter can be used when the protocol of the backend server group is HTTP or HTTPS.

member_deletion_protection_enable

No

Boolean

Specifies whether to enable removal protection for the load balancer.

The value can be:

  • true: Enable removal protection.

  • false (default): Disable removal protection.

NOTE:

Disable removal protection for all your resources before deleting your account.

vpc_id

No

String

Specifies the ID of the VPC where the backend server group works.

Notes and constraints:

  • The backend server group must be associated with the VPC.

  • Only backend servers in the VPC or IP as backend servers can be added.

  • type must be set to instance.

  • If vpc_id is not specified, vpc_id is determined by the VPC where the backend server works.

type

No

String

Specifies the type of the backend server group.

The value can be:

  • instance: Any type of backend servers can be added. vpc_id is mandatory.

  • ip: Only IP as backend servers can be added. vpc_id cannot be specified.

Notes and constraints:

  • If this parameter is not passed, any type of backend servers can be added. type will be returned as an empty string.

  • Specify one of listener_id, loadbalancer_id, or type. For backend server groups of shared load balancers, specify loadbalancer_id or listener_id.

ip_version

No

String

Specifies the IP address version supported by the backend server group.

  • Shared load balancers: The value is fixed at v4.

  • Dedicated load balancers: The value can be dualstack, or v4. If the protocol of the backend server group is TCP or UDP, the value is dualstack. If the protocol of the backend server group is HTTP, the value is v4.

protection_status

No

String

Specifies the protection status.

The value can be:

  • nonProtection (default): The resource is not protected against being modified by accident.

  • consoleProtection: The resource is protected against being modified by accident.

protection_reason

No

String

Specifies why the modification protection function is enabled.

Notes and constraints: This parameter is valid only when protection_status is set to consoleProtection.

any_port_enable

No

Boolean

Specifies whether to enable any_port_enable for a backend server group. If this option is enabled, the listener routes the requests to the backend server over the same port as the frontend port. If this option is disabled, the listener routes the requests over the port specified by protocol_port.

The value can be:

  • false: Disable this option.

  • true: Enable this option.

Notes and constraints: This option is available only for TCP, UDP, or QUIC backend server groups.

Table 5 CreatePoolSessionPersistenceOption

Parameter

Mandatory

Type

Description

cookie_name

No

String

Specifies the cookie name.

Notes and constraints:

  • This parameter will take effect only when type is set to APP_COOKIE. Otherwise, an error will be returned.

Value ranges:

  • For shared load balancers, the name can contain a maximum of 64 characters, including letters, digits, underscores (_), and hyphens (-).

  • For dedicated load balancers, the name can contain a maximum of 255 characters, including letters, digits, underscores (_), hyphens (-), and periods (.).

type

Yes

String

Specifies the sticky session type.

The value can be SOURCE_IP, HTTP_COOKIE, or APP_COOKIE.

Notes and constraints:

  • If the protocol of the backend server group is TCP or UDP, only SOURCE_IP takes effect.

  • If the protocol of the backend server group is HTTP or HTTPS, the value can be HTTP_COOKIE or APP_COOKIE.

  • If the backend server group protocol is QUIC, sticky session must be enabled with type set to SOURCE_IP.

persistence_timeout

No

Integer

Specifies the stickiness duration, in minutes. This parameter will not take effect when type is set to APP_COOKIE.

Value ranges:

  • If the protocol of the backend server group is TCP or UDP, the value ranges from 1 to 60, and the default value is 1.

  • If the protocol of the backend server group is HTTP or HTTPS, the value ranges from 1 to 1440, and the default value is 1440.

Table 6 CreatePoolSlowStartOption

Parameter

Mandatory

Type

Description

enable

No

Boolean

Specifies whether to enable slow start.

The value can be:

  • true: Enable slow start.

  • false (default): Disable slow start.

duration

No

Integer

Specifies the slow start duration, in seconds.

The value ranges from 30 to 1200, and the default value is 30.

Response Parameters

Status code: 201

Table 7 Response body parameters

Parameter

Type

Description

request_id

String

Specifies the request ID.

Note: The value is automatically generated.

pool

Pool object

Specifies the backend server group.

Table 8 Pool

Parameter

Type

Description

admin_state_up

Boolean

Specifies the administrative status of the backend server group.

description

String

Provides supplementary information about the backend server group.

healthmonitor_id

String

Specifies the ID of the health check configured for the backend server group.

id

String

Specifies the backend server group ID.

lb_algorithm

String

Specifies the load balancing algorithm used by the load balancer to route requests to backend servers in the associated backend server group.

The value can be one of the following:

  • ROUND_ROBIN: weighted round robin

  • LEAST_CONNECTIONS: weighted least connections

  • SOURCE_IP: source IP hash

  • QUIC_CID: connection ID

Notes and constraints:

  • If the value is SOURCE_IP or QUIC_CID, the weight parameter will not take effect for backend servers.

  • QUIC_CID is supported only when the protocol of the backend server group is QUIC.

listeners

Array of ListenerRef objects

Specifies the IDs of the listeners with which the backend server group is associated.

loadbalancers

Array of LoadBalancerRef objects

Specifies the IDs of the load balancers with which the backend server group is associated.

members

Array of MemberRef objects

Specifies the IDs of the backend servers in the backend server group.

name

String

Specifies the backend server group name.

project_id

String

Specifies the project ID.

protocol

String

Specifies the protocol used by the backend server group to receive requests.

The value can be TCP, UDP, TLS, HTTP, HTTPS, gRPC, or QUIC.

Notes and constraints:

  • If the listener's protocol is UDP, the protocol of the backend server group must be UDPor QUIC.

  • If the listener's protocol is TCP, the protocol of the backend server group must be TCP.

  • If the listener's protocol is HTTP, the protocol of the backend server group must be HTTP.

  • If the listener's protocol is HTTPS, the protocol of the backend server group can be HTTP, HTTPS, or gRPC.

  • If the listener's protocol is TERMINATED_HTTPS, the protocol of the backend server group must be HTTP.

  • If the listener's protocol is QUIC, the protocol of the backend server group can be HTTP, HTTPS, or gRPC.

  • If the listener's protocol is TLS, the protocol of the backend server group can be TLS or TCP.

  • If protocol of the backend server group is QUIC, session_persistence must be set to true, with type set to SOURCE_IP.

  • If protocol of the backend server group is gRPC, http2_enable of the listener must be set to true.

  • If protocol of the backend server group is TCP, the ip_version must be set to v4.

session_persistence

SessionPersistence object

Specifies the sticky session.

ip_version

String

Specifies the IP address version supported by the backend server group.

  • Shared load balancers: The value is fixed at v4.

  • Dedicated load balancers: The value can be dualstack or v4. If the protocol of the backend server group is TCP, UDP, or QUIC, the value is dualstack. If the protocol of the backend server group is HTTP or HTTPS, the value is v4.

slow_start

SlowStart object

Specifies slow start details. After you enable slow start, new backend servers added to the backend server group are warmed up, and the number of requests they can receive increases linearly during the configured slow start duration.

This parameter can be used when the protocol of the backend server group is HTTP or HTTPS. An error will be returned if the protocol is not HTTP or HTTPS.

member_deletion_protection_enable

Boolean

Specifies whether to enable removal protection.

The value can be:

  • true: Enable removal protection.

  • false: Disable removal protection.

NOTE:

Disable removal protection for all your resources before deleting your account.

created_at

String

Specifies the time when the forwarding policy was added.

The format is yyyy-MM-dd'T'HH:mm:ss'Z' (UTC time).

This is a new field in this version, and it will not be returned for resources associated with existing dedicated load balancers and for resources associated with existing and new shared load balancers.

updated_at

String

Specifies the time when the forwarding policy was updated.

The format is yyyy-MM-dd'T'HH:mm:ss'Z' (UTC time).

This is a new field in this version, and it will not be returned for resources associated with existing dedicated load balancers and for resources associated with existing and new shared load balancers.

vpc_id

String

Specifies the ID of the VPC where the backend server group works.

type

String

Specifies the type of the backend server group.

The value can be:

  • instance: Any type of backend servers can be added. vpc_id is mandatory.

  • ip: Only IP as backend servers can be added. vpc_id cannot be specified.

  • "": Any type of backend servers can be added.

protection_status

String

Specifies the protection status.

The value can be:

  • nonProtection (default): The resource is not protected against being modified by accident.

  • consoleProtection: The resource is protected against being modified by accident.

protection_reason

String

Specifies why the modification protection function is enabled.

Notes and constraints: This parameter is valid only when protection_status is set to consoleProtection.

any_port_enable

Boolean

Specifies whether to enable any_port_enable for a backend server group. If this option is enabled, the listener routes the requests to the backend server over the same port as the frontend port. If this option is disabled, the listener routes the requests over the port specified by protocol_port.

The value can be:

  • false: Disable this option.

  • true: Enable this option.

Notes and constraints: This option is available only for TCP, UDP, or QUIC backend server groups.

enterprise_project_id

String

Specifies the enterprise project ID of the IP address group.

Table 9 ListenerRef

Parameter

Type

Description

id

String

Specifies the listener ID.

Table 10 LoadBalancerRef

Parameter

Type

Description

id

String

Specifies the load balancer ID.

Table 11 MemberRef

Parameter

Type

Description

id

String

Specifies the backend server ID.

Table 12 SessionPersistence

Parameter

Type

Description

cookie_name

String

Specifies the cookie name.

Notes and constraints:

  • This parameter will take effect only when type is set to APP_COOKIE. Otherwise, an error will be returned.

Value ranges:

  • For shared load balancers, the name can contain a maximum of 64 characters, including letters, digits, underscores (_), and hyphens (-).

  • For dedicated load balancers, the name can contain a maximum of 255 characters, including letters, digits, underscores (_), hyphens (-), and periods (.).

type

String

Specifies the sticky session type.

The value can be SOURCE_IP, HTTP_COOKIE, or APP_COOKIE.

Notes and constraints:

  • If the protocol of the backend server group is TCP or UDP, only SOURCE_IP takes effect.

  • For dedicated load balancers, if the protocol of the backend server group is HTTP or HTTPS, the value can only be HTTP_COOKIE. For shared load balancers, if the protocol of the backend server group is HTTP or HTTPS, the value can be HTTP_COOKIE or APP_COOKIE.

  • If the backend server group protocol is QUIC, sticky session must be enabled with type set to SOURCE_IP.

persistence_timeout

Integer

Specifies the stickiness duration, in minutes. This parameter will not take effect when type is set to APP_COOKIE.

Value ranges:

  • If the protocol of the backend server group is TCP, UDP, or QUIC, the value ranges from 1 to 60, and the default value is 1.

  • If the protocol of the backend server group is HTTP or HTTPS, the value ranges from 1 to 1440, and the default value is 1440.

Table 13 SlowStart

Parameter

Type

Description

enable

Boolean

Specifies whether to enable slow start.

The value can be:

  • true: Enable slow start.

  • false (default): Disable slow start.

duration

Integer

Specifies the slow start duration, in seconds.

The value ranges from 30 to 1200, and the default value is 30.

Example Requests

  • Creating a backend server group and setting its backend protocol to TCP

    POST https://{ELB_Endpoint}/v3/99a3fff0d03c428eac3678da6a7d0f24/elb/pools
    
    {
      "pool" : {
        "name" : "My pool",
        "lb_algorithm" : "LEAST_CONNECTIONS",
        "listener_id" : "0b11747a-b139-492f-9692-2df0b1c87193",
        "protocol" : "TCP",
        "member_deletion_protection_enable" : false
      }
    }
  • Creating a backend server group and setting its backend protocol to HTTP

    POST https://{ELB_Endpoint}/v3/99a3fff0d03c428eac3678da6a7d0f24/elb/pools
    
    {
      "pool" : {
        "name" : "My pool",
        "lb_algorithm" : "LEAST_CONNECTIONS",
        "listener_id" : "0b11747a-b139-492f-9692-2df0b1c87193",
        "protocol" : "HTTP",
        "slow_start" : {
          "enable" : true,
          "duration" : 50
        },
        "member_deletion_protection_enable" : false
      }
    }
  • Creating an IP backend server group for a gateway load balancer

    POST https://{ELB_Endpoint}/v3/99a3fff0d03c428eac3678da6a7d0f24/elb/pools
    
    {
      "pool" : {
        "name" : "My IP pool",
        "lb_algorithm" : "2_tuple_hash",
        "listener_id" : "0b11747a-b139-492f-9692-2df0b1c87193",
        "protocol" : "IP",
        "type" : "instance",
        "target_rebalance" : true,
        "member_deletion_protection_enable" : false
      }
    }

Example Responses

Status code: 201

Normal response to POST requests.

{
  "pool" : {
    "type" : "",
    "vpc_id" : "",
    "lb_algorithm" : "LEAST_CONNECTIONS",
    "protocol" : "TCP",
    "description" : "",
    "admin_state_up" : true,
    "member_deletion_protection_enable" : false,
    "loadbalancers" : [ {
      "id" : "098b2f68-af1c-41a9-8efd-69958722af62"
    } ],
    "project_id" : "99a3fff0d03c428eac3678da6a7d0f24",
    "session_persistence" : null,
    "healthmonitor_id" : null,
    "listeners" : [ {
      "id" : "0b11747a-b139-492f-9692-2df0b1c87193"
    } ],
    "members" : [ ],
    "id" : "36ce7086-a496-4666-9064-5ba0e6840c75",
    "name" : "My pool",
    "ip_version" : "v4",
    "slow_start" : null
  },
  "request_id" : "2d974978-0733-404d-a21a-b29204f4803a"
}

SDK Sample Code

The SDK sample code is as follows.

  • Creating a backend server group and setting its backend protocol to TCP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    package com.huaweicloud.sdk.test;
    
    import com.huaweicloud.sdk.core.auth.ICredential;
    import com.huaweicloud.sdk.core.auth.BasicCredentials;
    import com.huaweicloud.sdk.core.exception.ConnectionException;
    import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
    import com.huaweicloud.sdk.core.exception.ServiceResponseException;
    import com.huaweicloud.sdk.elb.v3.region.ElbRegion;
    import com.huaweicloud.sdk.elb.v3.*;
    import com.huaweicloud.sdk.elb.v3.model.*;
    
    
    public class CreatePoolSolution {
    
        public static void main(String[] args) {
            // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
            // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
            String ak = System.getenv("CLOUD_SDK_AK");
            String sk = System.getenv("CLOUD_SDK_SK");
            String projectId = "{project_id}";
    
            ICredential auth = new BasicCredentials()
                    .withProjectId(projectId)
                    .withAk(ak)
                    .withSk(sk);
    
            ElbClient client = ElbClient.newBuilder()
                    .withCredential(auth)
                    .withRegion(ElbRegion.valueOf("<YOUR REGION>"))
                    .build();
            CreatePoolRequest request = new CreatePoolRequest();
            CreatePoolRequestBody body = new CreatePoolRequestBody();
            CreatePoolOption poolbody = new CreatePoolOption();
            poolbody.withLbAlgorithm("LEAST_CONNECTIONS")
                .withListenerId("0b11747a-b139-492f-9692-2df0b1c87193")
                .withName("My pool")
                .withProtocol("TCP")
                .withMemberDeletionProtectionEnable(false);
            body.withPool(poolbody);
            request.withBody(body);
            try {
                CreatePoolResponse response = client.createPool(request);
                System.out.println(response.toString());
            } catch (ConnectionException e) {
                e.printStackTrace();
            } catch (RequestTimeoutException e) {
                e.printStackTrace();
            } catch (ServiceResponseException e) {
                e.printStackTrace();
                System.out.println(e.getHttpStatusCode());
                System.out.println(e.getRequestId());
                System.out.println(e.getErrorCode());
                System.out.println(e.getErrorMsg());
            }
        }
    }
    
  • Creating a backend server group and setting its backend protocol to HTTP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    package com.huaweicloud.sdk.test;
    
    import com.huaweicloud.sdk.core.auth.ICredential;
    import com.huaweicloud.sdk.core.auth.BasicCredentials;
    import com.huaweicloud.sdk.core.exception.ConnectionException;
    import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
    import com.huaweicloud.sdk.core.exception.ServiceResponseException;
    import com.huaweicloud.sdk.elb.v3.region.ElbRegion;
    import com.huaweicloud.sdk.elb.v3.*;
    import com.huaweicloud.sdk.elb.v3.model.*;
    
    
    public class CreatePoolSolution {
    
        public static void main(String[] args) {
            // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
            // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
            String ak = System.getenv("CLOUD_SDK_AK");
            String sk = System.getenv("CLOUD_SDK_SK");
            String projectId = "{project_id}";
    
            ICredential auth = new BasicCredentials()
                    .withProjectId(projectId)
                    .withAk(ak)
                    .withSk(sk);
    
            ElbClient client = ElbClient.newBuilder()
                    .withCredential(auth)
                    .withRegion(ElbRegion.valueOf("<YOUR REGION>"))
                    .build();
            CreatePoolRequest request = new CreatePoolRequest();
            CreatePoolRequestBody body = new CreatePoolRequestBody();
            CreatePoolSlowStartOption slowStartPool = new CreatePoolSlowStartOption();
            slowStartPool.withEnable(true)
                .withDuration(50);
            CreatePoolOption poolbody = new CreatePoolOption();
            poolbody.withLbAlgorithm("LEAST_CONNECTIONS")
                .withListenerId("0b11747a-b139-492f-9692-2df0b1c87193")
                .withName("My pool")
                .withProtocol("HTTP")
                .withSlowStart(slowStartPool)
                .withMemberDeletionProtectionEnable(false);
            body.withPool(poolbody);
            request.withBody(body);
            try {
                CreatePoolResponse response = client.createPool(request);
                System.out.println(response.toString());
            } catch (ConnectionException e) {
                e.printStackTrace();
            } catch (RequestTimeoutException e) {
                e.printStackTrace();
            } catch (ServiceResponseException e) {
                e.printStackTrace();
                System.out.println(e.getHttpStatusCode());
                System.out.println(e.getRequestId());
                System.out.println(e.getErrorCode());
                System.out.println(e.getErrorMsg());
            }
        }
    }
    
  • Creating an IP backend server group for a gateway load balancer

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    package com.huaweicloud.sdk.test;
    
    import com.huaweicloud.sdk.core.auth.ICredential;
    import com.huaweicloud.sdk.core.auth.BasicCredentials;
    import com.huaweicloud.sdk.core.exception.ConnectionException;
    import com.huaweicloud.sdk.core.exception.RequestTimeoutException;
    import com.huaweicloud.sdk.core.exception.ServiceResponseException;
    import com.huaweicloud.sdk.elb.v3.region.ElbRegion;
    import com.huaweicloud.sdk.elb.v3.*;
    import com.huaweicloud.sdk.elb.v3.model.*;
    
    
    public class CreatePoolSolution {
    
        public static void main(String[] args) {
            // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
            // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
            String ak = System.getenv("CLOUD_SDK_AK");
            String sk = System.getenv("CLOUD_SDK_SK");
            String projectId = "{project_id}";
    
            ICredential auth = new BasicCredentials()
                    .withProjectId(projectId)
                    .withAk(ak)
                    .withSk(sk);
    
            ElbClient client = ElbClient.newBuilder()
                    .withCredential(auth)
                    .withRegion(ElbRegion.valueOf("<YOUR REGION>"))
                    .build();
            CreatePoolRequest request = new CreatePoolRequest();
            CreatePoolRequestBody body = new CreatePoolRequestBody();
            CreatePoolOption poolbody = new CreatePoolOption();
            poolbody.withLbAlgorithm("2_tuple_hash")
                .withListenerId("0b11747a-b139-492f-9692-2df0b1c87193")
                .withName("My IP pool")
                .withProtocol("IP")
                .withMemberDeletionProtectionEnable(false)
                .withType("instance");
            body.withPool(poolbody);
            request.withBody(body);
            try {
                CreatePoolResponse response = client.createPool(request);
                System.out.println(response.toString());
            } catch (ConnectionException e) {
                e.printStackTrace();
            } catch (RequestTimeoutException e) {
                e.printStackTrace();
            } catch (ServiceResponseException e) {
                e.printStackTrace();
                System.out.println(e.getHttpStatusCode());
                System.out.println(e.getRequestId());
                System.out.println(e.getErrorCode());
                System.out.println(e.getErrorMsg());
            }
        }
    }
    
  • Creating a backend server group and setting its backend protocol to TCP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    # coding: utf-8
    
    import os
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    from huaweicloudsdkelb.v3.region.elb_region import ElbRegion
    from huaweicloudsdkcore.exceptions import exceptions
    from huaweicloudsdkelb.v3 import *
    
    if __name__ == "__main__":
        # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak = os.environ["CLOUD_SDK_AK"]
        sk = os.environ["CLOUD_SDK_SK"]
        projectId = "{project_id}"
    
        credentials = BasicCredentials(ak, sk, projectId)
    
        client = ElbClient.new_builder() \
            .with_credentials(credentials) \
            .with_region(ElbRegion.value_of("<YOUR REGION>")) \
            .build()
    
        try:
            request = CreatePoolRequest()
            poolbody = CreatePoolOption(
                lb_algorithm="LEAST_CONNECTIONS",
                listener_id="0b11747a-b139-492f-9692-2df0b1c87193",
                name="My pool",
                protocol="TCP",
                member_deletion_protection_enable=False
            )
            request.body = CreatePoolRequestBody(
                pool=poolbody
            )
            response = client.create_pool(request)
            print(response)
        except exceptions.ClientRequestException as e:
            print(e.status_code)
            print(e.request_id)
            print(e.error_code)
            print(e.error_msg)
    
  • Creating a backend server group and setting its backend protocol to HTTP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    # coding: utf-8
    
    import os
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    from huaweicloudsdkelb.v3.region.elb_region import ElbRegion
    from huaweicloudsdkcore.exceptions import exceptions
    from huaweicloudsdkelb.v3 import *
    
    if __name__ == "__main__":
        # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak = os.environ["CLOUD_SDK_AK"]
        sk = os.environ["CLOUD_SDK_SK"]
        projectId = "{project_id}"
    
        credentials = BasicCredentials(ak, sk, projectId)
    
        client = ElbClient.new_builder() \
            .with_credentials(credentials) \
            .with_region(ElbRegion.value_of("<YOUR REGION>")) \
            .build()
    
        try:
            request = CreatePoolRequest()
            slowStartPool = CreatePoolSlowStartOption(
                enable=True,
                duration=50
            )
            poolbody = CreatePoolOption(
                lb_algorithm="LEAST_CONNECTIONS",
                listener_id="0b11747a-b139-492f-9692-2df0b1c87193",
                name="My pool",
                protocol="HTTP",
                slow_start=slowStartPool,
                member_deletion_protection_enable=False
            )
            request.body = CreatePoolRequestBody(
                pool=poolbody
            )
            response = client.create_pool(request)
            print(response)
        except exceptions.ClientRequestException as e:
            print(e.status_code)
            print(e.request_id)
            print(e.error_code)
            print(e.error_msg)
    
  • Creating an IP backend server group for a gateway load balancer

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    # coding: utf-8
    
    import os
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    from huaweicloudsdkelb.v3.region.elb_region import ElbRegion
    from huaweicloudsdkcore.exceptions import exceptions
    from huaweicloudsdkelb.v3 import *
    
    if __name__ == "__main__":
        # The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        # In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak = os.environ["CLOUD_SDK_AK"]
        sk = os.environ["CLOUD_SDK_SK"]
        projectId = "{project_id}"
    
        credentials = BasicCredentials(ak, sk, projectId)
    
        client = ElbClient.new_builder() \
            .with_credentials(credentials) \
            .with_region(ElbRegion.value_of("<YOUR REGION>")) \
            .build()
    
        try:
            request = CreatePoolRequest()
            poolbody = CreatePoolOption(
                lb_algorithm="2_tuple_hash",
                listener_id="0b11747a-b139-492f-9692-2df0b1c87193",
                name="My IP pool",
                protocol="IP",
                member_deletion_protection_enable=False,
                type="instance"
            )
            request.body = CreatePoolRequestBody(
                pool=poolbody
            )
            response = client.create_pool(request)
            print(response)
        except exceptions.ClientRequestException as e:
            print(e.status_code)
            print(e.request_id)
            print(e.error_code)
            print(e.error_msg)
    
  • Creating a backend server group and setting its backend protocol to TCP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    package main
    
    import (
    	"fmt"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
        elb "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/model"
        region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/region"
    )
    
    func main() {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak := os.Getenv("CLOUD_SDK_AK")
        sk := os.Getenv("CLOUD_SDK_SK")
        projectId := "{project_id}"
    
        auth := basic.NewCredentialsBuilder().
            WithAk(ak).
            WithSk(sk).
            WithProjectId(projectId).
            Build()
    
        client := elb.NewElbClient(
            elb.ElbClientBuilder().
                WithRegion(region.ValueOf("<YOUR REGION>")).
                WithCredential(auth).
                Build())
    
        request := &model.CreatePoolRequest{}
    	listenerIdPool:= "0b11747a-b139-492f-9692-2df0b1c87193"
    	namePool:= "My pool"
    	memberDeletionProtectionEnablePool:= false
    	poolbody := &model.CreatePoolOption{
    		LbAlgorithm: "LEAST_CONNECTIONS",
    		ListenerId: &listenerIdPool,
    		Name: &namePool,
    		Protocol: "TCP",
    		MemberDeletionProtectionEnable: &memberDeletionProtectionEnablePool,
    	}
    	request.Body = &model.CreatePoolRequestBody{
    		Pool: poolbody,
    	}
    	response, err := client.CreatePool(request)
    	if err == nil {
            fmt.Printf("%+v\n", response)
        } else {
            fmt.Println(err)
        }
    }
    
  • Creating a backend server group and setting its backend protocol to HTTP

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    package main
    
    import (
    	"fmt"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
        elb "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/model"
        region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/region"
    )
    
    func main() {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak := os.Getenv("CLOUD_SDK_AK")
        sk := os.Getenv("CLOUD_SDK_SK")
        projectId := "{project_id}"
    
        auth := basic.NewCredentialsBuilder().
            WithAk(ak).
            WithSk(sk).
            WithProjectId(projectId).
            Build()
    
        client := elb.NewElbClient(
            elb.ElbClientBuilder().
                WithRegion(region.ValueOf("<YOUR REGION>")).
                WithCredential(auth).
                Build())
    
        request := &model.CreatePoolRequest{}
    	enableSlowStart:= true
    	durationSlowStart:= int32(50)
    	slowStartPool := &model.CreatePoolSlowStartOption{
    		Enable: &enableSlowStart,
    		Duration: &durationSlowStart,
    	}
    	listenerIdPool:= "0b11747a-b139-492f-9692-2df0b1c87193"
    	namePool:= "My pool"
    	memberDeletionProtectionEnablePool:= false
    	poolbody := &model.CreatePoolOption{
    		LbAlgorithm: "LEAST_CONNECTIONS",
    		ListenerId: &listenerIdPool,
    		Name: &namePool,
    		Protocol: "HTTP",
    		SlowStart: slowStartPool,
    		MemberDeletionProtectionEnable: &memberDeletionProtectionEnablePool,
    	}
    	request.Body = &model.CreatePoolRequestBody{
    		Pool: poolbody,
    	}
    	response, err := client.CreatePool(request)
    	if err == nil {
            fmt.Printf("%+v\n", response)
        } else {
            fmt.Println(err)
        }
    }
    
  • Creating an IP backend server group for a gateway load balancer

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    package main
    
    import (
    	"fmt"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
        elb "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3"
    	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/model"
        region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/elb/v3/region"
    )
    
    func main() {
        // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
        // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
        ak := os.Getenv("CLOUD_SDK_AK")
        sk := os.Getenv("CLOUD_SDK_SK")
        projectId := "{project_id}"
    
        auth := basic.NewCredentialsBuilder().
            WithAk(ak).
            WithSk(sk).
            WithProjectId(projectId).
            Build()
    
        client := elb.NewElbClient(
            elb.ElbClientBuilder().
                WithRegion(region.ValueOf("<YOUR REGION>")).
                WithCredential(auth).
                Build())
    
        request := &model.CreatePoolRequest{}
    	listenerIdPool:= "0b11747a-b139-492f-9692-2df0b1c87193"
    	namePool:= "My IP pool"
    	memberDeletionProtectionEnablePool:= false
    	typePool:= "instance"
    	poolbody := &model.CreatePoolOption{
    		LbAlgorithm: "2_tuple_hash",
    		ListenerId: &listenerIdPool,
    		Name: &namePool,
    		Protocol: "IP",
    		MemberDeletionProtectionEnable: &memberDeletionProtectionEnablePool,
    		Type: &typePool,
    	}
    	request.Body = &model.CreatePoolRequestBody{
    		Pool: poolbody,
    	}
    	response, err := client.CreatePool(request)
    	if err == nil {
            fmt.Printf("%+v\n", response)
        } else {
            fmt.Println(err)
        }
    }
    

For SDK sample code of more programming languages, see the Sample Code tab in API Explorer. SDK sample code can be automatically generated.

Status Codes

Status Code

Description

201

Normal response to POST requests.

Error Codes

See Error Codes.