Skip to main content

Create

Creates an application load balancer in the specified folder.

import {
  cloudApi,
  decodeMessage,
  serviceClients,
  Session,
  waitForOperation,
} from "@yandex-cloud/nodejs-sdk";

import { google } from "googleapis";

const Code = google.rpc.code.Code;
const CreateLoadBalancerRequest =
  cloudApi.apploadbalancer.load_balancer_service.CreateLoadBalancerRequest;
const HttpCodeInterval = cloudApi.apploadbalancer.logging.HttpCodeInterval;
const LoadBalancer = cloudApi.apploadbalancer.load_balancer.LoadBalancer;

(async () => {
  const authToken = process.env["YC_OAUTH_TOKEN"];
  const session = new Session({ oauthToken: authToken });
  const client = session.client(serviceClients.LoadBalancerServiceClient);

  const operation = await client.create(
    CreateLoadBalancerRequest.fromPartial({
      folderId: "folderId",
      // name: "name",
      // description: "description",
      // labels: {"key": "labels"},
      regionId: "regionId",
      networkId: "networkId",
      // listenerSpecs: [{
      // name: "name",
      // endpointSpecs: [{
      // addressSpecs: [{
      // externalIpv4AddressSpec: {
      // address: "address"
      // },
      // internalIpv4AddressSpec: {
      // address: "address",
      // subnetId: "subnetId"
      // },
      // externalIpv6AddressSpec: {
      // address: "address"
      // }
      // }],
      // ports: [0]
      // }],
      // http: {
      // handler: {
      // httpRouterId: "httpRouterId",
      // http2Options: {
      // maxConcurrentStreams: 0
      // },
      // allowHttp10: true,
      // rewriteRequestId: true
      // },
      // redirects: {
      // httpToHttps: true
      // }
      // },
      // tls: {
      // defaultHandler: {
      // httpHandler: {
      // httpRouterId: "httpRouterId",
      // http2Options: {
      // maxConcurrentStreams: 0
      // },
      // allowHttp10: true,
      // rewriteRequestId: true
      // },
      // streamHandler: {
      // backendGroupId: "backendGroupId",
      // idleTimeout: {
      // seconds: 0,
      // nanos: 0
      // }
      // },
      // certificateIds: ["certificateIds"]
      // },
      // sniHandlers: [{
      // name: "name",
      // serverNames: ["serverNames"],
      // handler: {
      // httpHandler: {
      // httpRouterId: "httpRouterId",
      // http2Options: {
      // maxConcurrentStreams: 0
      // },
      // allowHttp10: true,
      // rewriteRequestId: true
      // },
      // streamHandler: {
      // backendGroupId: "backendGroupId",
      // idleTimeout: {
      // seconds: 0,
      // nanos: 0
      // }
      // },
      // certificateIds: ["certificateIds"]
      // }
      // }]
      // },
      // stream: {
      // handler: {
      // backendGroupId: "backendGroupId",
      // idleTimeout: {
      // seconds: 0,
      // nanos: 0
      // }
      // }
      // }
      // }],
      // allocationPolicy: {
      // locations: [{
      // zoneId: "zoneId",
      // subnetId: "subnetId",
      // disableTraffic: true
      // }]
      // },
      // securityGroupIds: ["securityGroupIds"],
      // autoScalePolicy: {
      // minZoneSize: 0,
      // maxSize: 0
      // },
      // logOptions: {
      // logGroupId: "logGroupId",
      // discardRules: [{
      // httpCodes: [0],
      // httpCodeIntervals: [HttpCodeInterval.HTTP_1XX],
      // grpcCodes: [Code.CANCELLED],
      // discardPercent: {
      // value: 0
      // }
      // }],
      // disable: true
      // }
    })
  );
  const finishedOp = await waitForOperation(operation, session);

  if (finishedOp.response) {
    const result = decodeMessage<typeof LoadBalancer>(finishedOp.response);
    console.log(result);
  }
})();

CreateLoadBalancerRequest​

folderId : string​

ID of the folder to create an application load balancer in.

To get the folder ID, make a yandex.cloud.resourcemanager.v1.FolderService.List request.

name : string​

Name of the application load balancer. The name must be unique within the folder.

description : string​

Description of the application load balancer.

labels : string​

Application load balancer labels as key:value pairs. For details about the concept, see documentation.

regionId : string​

ID of the region that the application load balancer is located at.

The only supported value is ru-central1.

networkId : string​

ID of the network that the application load balancer belongs to.

listenerSpecs : ListenerSpec​

Listeners that belong to the application load balancer.

For details about the concept, see documentation.

allocationPolicy : AllocationPolicy​

Locality settings of the application load balancer.

For details about the concept, see documentation.

securityGroupIds : string​

ID's of the security groups attributed to the application load balancer.

For details about the concept, see documentation.

autoScalePolicy : AutoScalePolicy​

Scaling settings of the application load balancer.

The scaling settings relate to a special internal instance group which facilitates the balancer's work. Instances in this group are called resource units. The group is scaled automatically based on incoming load and within limitations specified in these settings.

For details about the concept, see documentation.

logOptions : LogOptions​

Cloud logging settings of the application load balancer.

ListenerSpec​

name : string​

Name of the listener. The name is unique within the application load balancer.

endpointSpecs : EndpointSpec​

Endpoints of the listener.

Endpoints are defined by their IP addresses and ports.

One of listener​

Listener type and settings.

  • http : HttpListener​

    Unencrypted HTTP listener settings.

  • tls : TlsListener​

    TLS-encrypted HTTP or TCP stream listener settings.

All handlers within a listener (TlsListener.default_handler and TlsListener.sni_handlers) must be of one type, HttpHandler or StreamHandler. Mixing HTTP and TCP stream traffic in a TLS-encrypted listener is not supported.

  • stream : StreamListener​

    Unencrypted stream (TCP) listener settings.

AllocationPolicy​

A locality settings (allocation policy) resource.

locations : Location​

Availability zones and subnets that the application load balancer resides.

AutoScalePolicy​

A resource for scaling settings of an application load balancer.

minZoneSize : int64​

Lower limit for the number of resource units in each availability zone.

If not specified previously (using other instruments such as management console), the default value is 2. To revert to it, specify it explicitly.

The minimum value is 2.

maxSize : int64​

Upper limit for the total number of resource units across all availability zones.

If a positive value is specified, it must be at least min_zone_size multiplied by the size of AllocationPolicy.locations.

If the value is 0, there is no upper limit.

LogOptions​

logGroupId : string​

Cloud Logging log group ID to store access logs. If not set then logs will be stored in default log group for the folder where load balancer located.

discardRules : LogDiscardRule​

ordered list of rules, first matching rule applies

disable : bool​

Do not send logs to Cloud Logging log group.

EndpointSpec​

addressSpecs : AddressSpec​

Endpoint public (external) and internal addresses.

ports : int64​

Endpoint ports.

HttpListener​

An HTTP listener resource.

handler : HttpHandler​

Settings for handling HTTP requests.

Only one of handler and redirects can be specified.

redirects : Redirects​

Redirects settings.

Only one of redirects and handler can be specified.

TlsListener​

TLS-encrypted (HTTP or TCP stream) listener resource.

defaultHandler : TlsHandler​

Settings for handling requests by default, with Server Name Indication (SNI) not matching any of the sni_handlers.

sniHandlers : SniMatch​

Settings for handling requests with Server Name Indication (SNI) matching one of SniMatch.server_names values.

StreamListener​

A stream (TCP) listener resource.

handler : StreamHandler​

Settings for handling stream (TCP) requests.

Location​

An application load balancer location resource.

For details about the concept, see documentation.

zoneId : string​

ID of the availability zone where the application load balancer resides.

Each availability zone can only be specified once.

subnetId : string​

ID of the subnet that the application load balancer belongs to.

disableTraffic : bool​

Disables the load balancer node in the specified availability zone.

Backends in the availability zone are not directly affected by this setting. They still may receive traffic from the load balancer nodes in other availability zones, subject to LoadBalancingConfig.locality_aware_routing_percent and LoadBalancingConfig.strict_locality settings.

LogDiscardRule​

LogDiscardRule discards a fraction of logs with certain codes. If neither codes or intervals are provided, rule applies to all logs.

httpCodes : int64​

HTTP codes that should be discarded.

httpCodeIntervals : HttpCodeInterval​

Groups of HTTP codes like 4xx that should be discarded.

grpcCodes : google.rpc.Code​

GRPC codes that should be discarded

discardPercent : google.protobuf.Int64Value​

Percent of logs to be discarded: 0 - keep all, 100 or unset - discard all

AddressSpec​

One of addressSpec​

Endpoint address of one of the types: public (external) IPv4 address, internal IPv4 address, public IPv6 address.

  • externalIpv4AddressSpec : ExternalIpv4AddressSpec​

    Public IPv4 endpoint address.

  • internalIpv4AddressSpec : InternalIpv4AddressSpec​

    Internal IPv4 endpoint address.

To enable the use of listeners with internal addresses, contact support.

  • externalIpv6AddressSpec : ExternalIpv6AddressSpec​

    Public IPv6 endpoint address.

HttpHandler​

An HTTP handler resource.

httpRouterId : string​

ID of the HTTP router processing requests. For details about the concept, see documentation.

To get the list of all available HTTP routers, make a HttpRouterService.List request.

One of protocolSettings​

Protocol settings.

For HTTPS (HTTP over TLS) connections, settings are applied to the protocol negotiated using TLS ALPN extension.

  • http2Options : Http2Options​

    HTTP/2 settings.

If specified, incoming HTTP/2 requests are supported by the listener.

  • allowHttp10 : bool​

    Enables support for incoming HTTP/1.0 and HTTP/1.1 requests and disables it for HTTP/2 requests.

rewriteRequestId : bool​

When unset, will preserve the incoming x-request-id header, otherwise would rewrite it with a new value.

Redirects​

A listener redirects resource.

httpToHttps : bool​

Redirects all unencrypted HTTP requests to the same URI with scheme changed to https.

The setting has the same effect as a single, catch-all HttpRoute with RedirectAction.replace_scheme set to https.

TlsHandler​

A TLS-encrypted (HTTP or TCP stream) handler resource.

One of handler​

Settings for handling requests.

  • httpHandler : HttpHandler​

    HTTP handler.

  • streamHandler : StreamHandler​

    Stream (TCP) handler.

certificateIds : string​

ID's of the TLS server certificates from Certificate Manager.

RSA and ECDSA certificates are supported, and only the first certificate of each type is used.

SniMatch​

A SNI handler resource.

name : string​

Name of the SNI handler.

serverNames : string​

Server names that are matched by the SNI handler.

handler : TlsHandler​

Settings for handling requests with Server Name Indication (SNI) matching one of server_names values.

StreamHandler​

A stream (TCP) handler resource.

backendGroupId : string​

ID of the backend group processing requests. For details about the concept, see documentation.

The backend group type, specified via BackendGroup.backend, must be stream.

To get the list of all available backend groups, make a BackendGroupService.List request.

idleTimeout : google.protobuf.Duration​

The idle timeout is duration during which no data is transmitted or received on either the upstream or downstream connection. If not configured, the default idle timeout is 1 hour. Setting it to 0 disables the timeout.

ExternalIpv4AddressSpec​

address : string​

IPv4 address.

InternalIpv4AddressSpec​

address : string​

IPv4 address.

subnetId : string​

ID of the subnet that the address belongs to.

ExternalIpv6AddressSpec​

address : string​

IPv6 address.

Http2Options​

An HTTP/2 options resource.

maxConcurrentStreams : int64​

Maximum number of concurrent HTTP/2 streams in a connection.

Operation​

An Operation resource. For more information, see Operation.

id : string​

ID of the operation.

description : string​

Description of the operation. 0-256 characters long.

createdAt : google.protobuf.Timestamp​

Creation timestamp.

createdBy : string​

ID of the user or service account who initiated the operation.

modifiedAt : google.protobuf.Timestamp​

The time when the Operation resource was last modified.

done : bool​

If the value is false, it means the operation is still in progress. If true, the operation is completed, and either error or response is available.

metadata : google.protobuf.Any​

Service-specific metadata associated with the operation. It typically contains the ID of the target resource that the operation is performed on. Any method that returns a long-running operation should document the metadata type, if any.

One of result​

The operation result. If done == false and there was no failure detected, neither error nor response is set. If done == false and there was a failure detected, error is set. If done == true, exactly one of error or response is set.

  • error : google.rpc.Status​

    The error result of the operation in case of failure or cancellation.

  • response : google.protobuf.Any​
    The normal response of the operation in case of success.

    If the original method returns no data on success, such as Delete, the response is google.protobuf.Empty. If the original method is the standard Create/Update, the response should be the target resource of the operation. Any method that returns a long-running operation should document the response type, if any.