Load balancer manage system, method, program in a cloud native environment and the load balancer created by this method

A container-based load balancer system dynamically adjusts to traffic changes and supports multiple tenants, addressing inefficiencies in cloud data centers by using hash functions and eBPF/XDP for high-performance packet processing.

KR103046875B1Active Publication Date: 2026-11-10KAKAO ENTERPRISE CORP
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
KR1020240000896
Authority / Receiving Office
KR · KR
Patent Type
Patents
Current Assignee / Owner
Filing Date
2024-01-03
Publication Date
2026-11-10
Estimated Expiration
2041-06-04

Smart Images

  • Figure R1020240000896_ABST
    Figure R1020240000896_ABST
Patent Text Reader

Abstract

The present invention relates to a load balancer management system capable of flexibly responding to variable traffic. More specifically, the present invention relates to a load balancer management system in which a CR management unit creates a custom resource (CR) based on a request to create a load balancer node, wherein the custom resource includes at least one parameter information defining a load balancer, wherein the CR management unit stores the created custom resource in a database, and an operator performs at least one of creating, removing, and changing at least one load balancer node (LB Node) to correspond to the at least one custom resource stored.
Need to check novelty before this filing date? Find Prior Art

Description

Technology Field

[0001] The present invention relates to a system and method for managing a load balancer in a cloud-native environment and a load balancer created by the method. More specifically, it relates to a control method for flexibly creating and removing a load balancer according to network conditions in a cloud-native environment and a load balancer created by the method. Background Technology

[0003] In a cloud data center environment, there exists a large set of interconnected servers that provide computing and / or storage capacity to run various applications. For example, a data center may include facilities that host applications and services for subscribers, i.e., the data center's customers. Furthermore, a data center can host all infrastructure equipment, such as networking and storage systems, redundant power supplies, and environmental control.

[0004] Data centers are interconnected through a high-speed switch fabric provided by one or more physical network switch and router layers.

[0005] Due to the nature of data centers, numerous virtual machines (VMs) exist, and these virtual machines can be easily created or removed. Load balancers, which load balance traffic using virtual machines whose number and locations continuously change, must also be flexibly created and removed depending on network conditions.

[0006] Generally, load balancers are implemented as physical hardware devices connected separately to the data center. Relying on such physical hardware makes it difficult to handle rapidly changing traffic volumes or variations in the number of virtual machines flexibly. If physical equipment is deployed based on a prediction of the maximum traffic that may flow into the data center, it not only requires high equipment purchase costs but can also result in an uneconomical design in terms of cost and performance during periods of low traffic.

[0007] Furthermore, when designing data center networks, it is essential to be able to handle exponentially increasing traffic and rapid changes in traffic patterns. This is because a sudden surge in specific traffic flows can concentrate the load on particular functions, causing operational malfunctions and sequentially affecting other related functions.

[0008] Therefore, there is a need for research on a load balancer management system that can cope with rapidly changing traffic patterns without difficulty while simultaneously being economical. The problem to be solved

[0010] The problem that the present invention aims to solve is to provide a load balancer management system and control method optimized for a cloud-native environment.

[0011] Another problem that the present invention aims to solve is to provide a load balancer capable of supporting multiple tenants.

[0012] Another problem that the present invention aims to solve is to provide a load balancer management system that changes dynamically according to rapidly changing traffic patterns.

[0013] Another problem that the present invention aims to solve is to provide a container-type load balancer that can be easily controlled at the software level on a Linux operating system.

[0014] Another problem that the present invention aims to solve is to provide a container-type load balancer that is equivalent to the performance of a hardware load balancer.

[0015] The technical problems to be solved by the present invention are not limited to those mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art to which the present invention belongs from the description below. means of solving the problem

[0017] According to one aspect of the present invention to solve the above or other problems, a method for controlling a load balancer node is provided, comprising: a step in which an LBN core receives a packet from a border leaf switch; a step in which the LBN core applies a first and a second hash function to the received packet; a step in which the LBN core obtains at least one of a destination address and a VID from a hash table based on the result of applying the first and second hash functions; a step in which the LBN core replaces at least one of the destination address and a VID of the received packet with the obtained destination MAC address and VID; and a step in which the LBN core transmits the replaced packet to the border leaf switch.

[0018] The first and second hash functions above can be applied to the header of the received packet.

[0019] The parameters of the first hash function may include at least one of the destination IP (VIP), destination port, protocol, VID, and segment type for the received packet.

[0020] The parameters of the second hash function may include at least one of the source IP, source port, destination IP, destination port, protocol, and VID of the packet header for the received packet.

[0021] The acquisition step allows the LBN core to acquire a VIP (Virtual IP) based on the first hashing result of the first hash function.

[0022] In the acquisition step, the LBN core can acquire a destination MAC address based on the second hashing result of the second hash function and the first hashing result.

[0024] According to another aspect of the present invention to solve the above or other problems, a load balancer node comprises: a hash table storage for storing a hash table; and an LBN core for receiving a packet from a border leaf switch, wherein the LBN core applies a first and a second hash function to the received packet and, based on the result of applying the first and second hash functions, obtains at least one of a destination address and a VID on the stored hash table, replaces at least one of the destination address and a VID of the received packet with the obtained destination MAC address and VID, and transmits the replaced packet to the border leaf switch.

[0025] The first and second hash functions above can be applied to the header of the received packet.

[0026] The parameters of the first hash function may include at least one of the destination IP (VIP), destination port, protocol, VID, and segment type for the received packet.

[0027] The parameters of the second hash function may include at least one of the source IP, source port, destination IP, destination port, protocol, and VID of the packet header for the received packet.

[0028] The above LBN core can obtain a VIP (Virtual IP) based on the first hashing result of the above first hash function.

[0029] The above LBN core can obtain a destination MAC address based on the second hashing result of the above second hash function and the above first hashing result. Effects of the invention

[0031] The effects of the system and method for managing a load balancer in a cloud-native environment according to the present invention are described as follows.

[0032] According to at least one of the embodiments of the present invention, there is an advantage that optimized load balancer management is possible in a cloud-native environment.

[0033] In addition, according to at least one of the embodiments of the present invention, there is an advantage of being able to provide a load balancer capable of supporting multiple tenants.

[0034] And according to at least one of the embodiments of the present invention, there is an advantage that a load balancer that is relatively economical compared to a conventional hardware-type load balancer can be provided through a container-based load balancer.

[0035] Additionally, according to at least one embodiment of the present invention, there is an advantage in that a load balancer management system that changes dynamically according to rapidly changing traffic patterns can be provided.

[0036] Further scopes of the applicability of the present invention will become apparent from the following detailed description. However, since various changes and modifications within the spirit and scope of the present invention are clearly understood by those skilled in the art, specific embodiments, such as the detailed description and preferred embodiments of the present invention, should be understood as being given merely as examples. Brief explanation of the drawing

[0038] FIG. 1 is a drawing illustrating the structure of a load balancer management system (100) according to an embodiment of the present invention. FIG. 2 illustrates a conceptual diagram in which a load balancer management system (100) according to an embodiment of the present invention is connected to a switch fabric. FIG. 3 illustrates the concept of a control sequence for creating an additional LB node (203-3) according to an embodiment of the present invention. FIG. 4 illustrates a control flowchart for creating an additional LB node (203-3) according to an embodiment of the present invention. FIG. 5 illustrates a control sequence in which an LB node (203) processes inbound traffic according to an embodiment of the present invention. FIG. 6 illustrates an example in which the MAC address and VID included in the packet header are changed according to an embodiment of the present invention. FIG. 7 is a diagram illustrating a Linux network stack to explain the location where a load balancer node is executed according to an embodiment of the present invention. FIG. 8 illustrates an example of a hash table (801) according to an embodiment of the present invention. FIG. 9 shows the relationship between an LBN core (905) of a Linux kernel and an LBN controller (910) of user space (707) according to an embodiment of the present invention. Figure 10 illustrates the experimental environment of the present experiment. Figures 11 to 13 illustrate the throughput of each scenario when traffic consisting only of frames of a specific size is transmitted at the full speed of a 25G NIC card. Figure 14 illustrates the Troughput results in BPS (L2 and L1 levels) for IMIX traffic. Figure 15 illustrates the Troughput results in PPS for IMIX traffic. Specific details for implementing the invention

[0039] Hereinafter, embodiments disclosed in this specification will be described in detail with reference to the attached drawings. Identical or similar components regardless of drawing symbols will be assigned the same reference number, and redundant descriptions thereof will be omitted. The suffixes "module" and "part" used for components in the following description are assigned or used interchangeably solely for the ease of drafting the specification and do not inherently possess distinct meanings or roles. Furthermore, in describing embodiments disclosed in this specification, if it is determined that a detailed description of related prior art could obscure the essence of the embodiments disclosed in this specification, such detailed description will be omitted. Additionally, the attached drawings are intended only to facilitate understanding of the embodiments disclosed in this specification; the technical concept disclosed in this specification is not limited by the attached drawings, and it should be understood that they include all modifications, equivalents, and substitutions that fall within the spirit and technical scope of the present invention.

[0040] Terms including ordinal numbers, such as first, second, etc., may be used to describe various components, but said components are not limited by said terms. These terms are used solely for the purpose of distinguishing one component from another.

[0041] When it is stated that one component is "connected" or "connected" to another component, it should be understood that while it may be directly connected or connected to that other component, there may also be other components in between. On the other hand, when it is stated that one component is "directly connected" or "directly connected" to another component, it should be understood that there are no other components in between.

[0042] Singular expressions include plural expressions unless the context clearly indicates otherwise.

[0043] In this application, terms such as “comprising” or “having” are intended to specify the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof.

[0044] The present invention relates to a virtualized computing infrastructure in a cloud-native environment, and more specifically, to configuring a load balancer for a virtual execution element (e.g., a virtual machine (VM) or a container) deployed in the virtualized computing infrastructure within a network as a virtual execution element.

[0045] Containerization refers to a virtualization method based on operating system-level virtualization. Containers are characterized as lightweight and portable execution elements for applications isolated from one another or from the host.

[0046] Because containers are not tightly coupled to the host hardware computing environment, applications can be coupled to container images and run as a single lightweight package on any host or virtual host that supports the underlying container architecture. Due to this characteristic, containers can resolve various problems that may arise when running software in different computing environments.

[0047] Furthermore, since containers are environments that virtualize an operating system, they are relatively lighter than virtual machines; consequently, under the same conditions, they can support more container instances than traditional virtual machines and can be created and removed quickly. Containers, which often have short lifespans, can be created and moved more efficiently than virtual machines. Additionally, containers can be managed as groups of logically related elements. For example, in some orchestration platforms like Kubernetes, these elements are called "Pods," and a group of these Pods is called a "cluster."

[0048] In the following description of the invention, the terms "pod" and "cluster" are used, but these are merely terms to refer to elements and groups thereof, and the invention is not limited to the Kubernetes platform.

[0049] In one embodiment of the present invention, an installable cloud architecture is proposed in which clusters, their roles, and relationships are defined. Additionally, a cloud architecture is proposed that can provide a containerized high-performance load balancer that can be easily managed through orchestration tools such as Kubernetes and can distribute traffic using eBPF (Extended Berkeley Packet Filter) / XDP (eXpress Data Path) within the Linux kernel.

[0050] In Kubernetes-based clouds, incoming traffic can be handled by easily creating and removing applications in the form of containers or virtual machines. Accordingly, data centers require load balancers that distribute traffic to multiple containers or virtual machines with virtual IPs (Virtual IPs, VIPs). In particular, load balancers must be able to forward incoming traffic to multiple containers / virtual machines whose number and locations frequently change.

[0051] In addition, load balancers must be scalable flexibly depending on the network environment and be able to reliably deliver traffic under any circumstances.

[0052] In order to satisfy these requirements, the present invention proposes deploying or managing a load balancer in the form of a container that can be deployed and managed through an orchestration tool (e.g., Kubernetes). Using a container-based load balancer in this way offers the advantage of being able to appropriately deploy and manage cloud resources according to user requests.

[0053] Furthermore, a load balancer according to one embodiment of the present invention is proposed to operate in a Layer 2 (L2) Direct Server Return (DSR) mode that modulates the destination Media Access Control Address (MAC) and VLAN ID. When operating in such an L2 DSR mode, it can respond directly to clients without passing through the load balancer, thereby increasing response speed while simultaneously reducing the load on the load balancer. In addition, to support multi-tenancy, load balancing services can be performed to specific tenants by modulating the VLAN ID. In the present invention, the identifier corresponding to a specific tenant is used as a VLAN ID, but this is merely a term for distinguishing tenants, and the present invention is not limited to VLANs.

[0054] In this invention, a policy for distributing a containerized load balancer (APIs for creation and deletion, status monitoring, etc.) and setting packet matching rules in the load balancer is proposed. Furthermore, a load balancer capable of expecting sufficient performance when operating on a Linux operating system is proposed.

[0055] In the present invention, cloud components (pods) required for Infrastructure-as-a-Service (IaaS) are defined, and then these components are classified into clusters according to their characteristics (or functions). These clusters are described with reference to FIGS. 1 and FIGS. 2.

[0056] FIG. 1 is a diagram illustrating the structure of a load balancer management system (100) according to an embodiment of the present invention. FIG. 2 is a conceptual diagram illustrating a load balancer management system (100) according to an embodiment of the present invention connected to a switch fabric.

[0057] The following explanation will be described with reference to FIGS. 1 and FIGS. 2.

[0058] A load balancer management system (100) according to one embodiment of the present invention may be configured to include a service cluster (110), an LB (load balancer) cluster (120), and an LB control cluster (130). However, additional cluster configurations may be possible in addition to the clusters mentioned above. Since the components illustrated in FIG. 1 are not essential for implementing the load balancer management system (100), the load balancer management system (100) described herein may have more or fewer components than those listed above.

[0059] In one embodiment of the present invention, a method is proposed for creating a stable and progressively scalable cloud-based service on a bare metal server based on a cluster defined (configured) as in FIG. 1. In one embodiment of the present invention, the creation (deployment) of a load balancer and load balancing rules are automated based on a custom resource definition (CRD). For example, the CRD may be a custom object provided by the Kubernetes Platform API. Furthermore, the load balancer management system (100) according to one embodiment of the present invention can ensure sufficient load balancing performance for the cloud by implementing a load balancer using eBPF (extended Berkeley Packet Filter) / XDP (eXpress Data Path).

[0060] A pod according to one embodiment of the present invention may mean the smallest deployable computing unit that can be created and managed in a load balancer management system (100). A pod may be composed of a group of one or more containers, and the group may share storage and networks and share specifications for how to run the containers. The contents of the pods may be placed together and scheduled together.

[0061] In one embodiment of the present invention, a cluster-based framework can be used to deploy virtual execution elements to a virtualization environment. A cluster may be installed on one or more nodes. Each node on which a cluster is installed is classified into a master node (or master) and a worker node (or worker) according to its role. The master node performs the role of controlling the entire cluster.

[0062] Pods installed on the master node typically include API servers that provide cluster functions in the form of APIs, databases that store cluster data, schedulers that determine which nodes pods will be assigned to, controllers that manage and allocate cluster resources, and DNS (Domain Name System) servers. However, the pods installed on the master node will not be limited to the functions listed above.

[0063] Pods installed on worker nodes typically include agents that execute commands received from the master node's API server, proxies that manage the network between pods, and runtimes that actually execute the pods. However, the pods installed on worker nodes will not be limited to the functions listed above.

[0064] The service cluster (110) is a configuration that performs actual IaaS services. The service master pod (112) of the service cluster (110) is configured to belong to the master node, and the service agent pod (111) and service API pod (113) are configured to belong to the worker node. Although only two service groups are shown in the illustrated drawing, it is obvious that a larger number of service groups can be provided.

[0065] The service API pod (113) running on the worker node is a pod that runs an OpenStack API server such as "Nova", "Neutron", "Keystone", "Cinder", "Glance", "Horizon", "Octavia", etc. Using the aforementioned OpenStack API is merely one example, and it will be obvious that it can be replaced with other APIs that perform the same function. For example, "Neutron" is an API for networking control, and it is obvious that other networking control APIs can be applied in place of "Neutron".

[0066] The first and second service groups (200-1, 200-2) shown in FIG. 2 include virtual machines (202-1 to 202-8) created by the user.

[0067] Among the worker nodes constituting the service cluster (110), service agent pods (111) such as 'DHCP-agent', 'ovs(OpenVSwitch)-agent', 'nova-compute', etc. are installed on each server (201-1 to 201-4) connected to the leaf switch (210-1, 210-2). The installed service agent pod(s) support virtual machines (202-1 to 202-4) to be installed on the servers (201-1 to 201-4) and use resources such as computing and networking. That is, the service agent pod(s) support each virtual machine (202-1 to 202-8) to be controlled by the service API.

[0068] The LB cluster (120) is a configuration that performs load balancing. The LB master pod (122) is configured to belong to the master node, and the LB node pod (121) is configured to belong to the worker node.

[0069] An LB node pod (121) acts as at least one LB node (203-1, 203-2) (LBN, Load Balancer Node) that performs load balancing. According to one embodiment of the present invention, an LB node (203-1, 203-2) may be provided in a form where only one pod runs on a single physical machine (server). This is to make it a dedicated load balancing server that uses the server's resources (CPU, memory) solely as resources for load balancing. In the following, when referring to a single LB node, it will be expressed as an LB node (203).

[0070] As illustrated in FIG. 2, the LB node pod (121) includes two LB nodes (203-1, 203-2), but is not limited thereto. In particular, as will be described below, the number of LB nodes (203-1, 203-2) may increase or decrease by synchronizing with the Custom resource (CR) stored in the database of the LB master pod (122).

[0071] The LB master pod (122) is equipped with basic pod(s) for operating the LB cluster (120).

[0072] The LB control cluster (130) is a configuration that controls the LB cluster (12). The LB control master pod (132) is configured to belong to the master node, and the LB control node pod (131) is configured to belong to the worker node.

[0073] The LB control master pod (132) is equipped with basic pod(s) for operating the LB control cluster (130).

[0074] The LB control node pod (131) may include an API server and an operator that control the LB nodes (203-1, 203-2). The API server and the operator will be described in detail below with reference to FIG. 3.

[0075] In one embodiment of the present invention, to implement a load balancer that supports multiple tenants, it is proposed to logically divide the networks of different tenants using a VLAN ID (VID). According to this embodiment, since traffic from different networks can be distinguished by the VID even if VMs of different tenants have the same IP, support for multiple tenants will be possible. As described above, the present invention uses a VLAN ID as a distinguishing identifier corresponding to a specific tenant, but this is merely a term for distinguishing tenants, and the present invention is not limited to VLANs. For example, in the case of VXLAN, the present invention will also include cases where a VNI (Virtual Network Identifier, or VXLAN Segment ID) is used instead of a VID.

[0076] Referring to FIG. 2, the first to fourth servers (201-1 to 201-4), which are each computing node where the first to eighth VMs (202-1 to 202-8) are running, are connected to the top of rack (TOR) which is the leaf switch (210-1, 210-2) of the two-tier leaf-spine fabric (230). Although it is shown that only two servers are connected to each leaf switch, it is obvious that the number of servers may vary and is not limited to this.

[0077] The fabric configuration illustrated in FIG. 2 is described using VXLAN (Virtual Extensible LAN)-EVPN (Ethernet VPN) as an example, but it will be obvious that various fabric configurations can be included in the present invention.

[0078] And each server (201-1 to 201-4) may be configured with at least one virtual machine (202-1 to 202-8). In FIG. 2, the number of virtual machines (201-1 to 202-8) configured in each server (201-1 to 201-4) is shown as two, but is not limited thereto.

[0079] In each server (201-1 to 201-4, physical machine) constituting the load balancer management system (100) according to one embodiment of the present invention, one port (eth0) is connected to the first and second leaf switches (210-1, 210-2), which are TORs of the service network (220).

[0080] User traffic received from the network (220) travels through a two-layer leaf-spine fabric (230) composed of leaf switches (210-1, 210-2), border leaf switches (212), and spine switches (211-1, 211-2). In FIG. 2, external routers are omitted.

[0081] According to one embodiment of the present invention, when a packet generated from the computing nodes, the first to eighth VMs (202-1 to 202-8), exits the node, a VLAN header along with the VID of the corresponding network may be added to the original packet. And since the leaf-spine fabric (230) is configured as VXLAN (Virtual Extensible LAN)-EVPN (Ethernet VPN) or EVPN-VXLAN, a VXLAN header may be added to the original packet instead of the VLAN header. Each leaf switch (210-1, 210-2) has a VTEP (VXLAN Ternal End Point, the endpoint of the tunnel).

[0082] VXLAN (Virtual Extensible LAN) is an encapsulation protocol that provides data center connectivity by extending Layer 2 connections over underlying Layer 3 networks using tunneling. A VTEP is an entity that performs packet encapsulation and decapsulation and serves as the start / end point of a VXLAN tunnel.

[0083] In order for the LB nodes (203-1, 203-2) to perform load balancing, the following preliminary steps are required. Each server connected to the border leaf switch (212) is labeled as being used for the LB nodes (203-1, 203-2). Each labeled server is joined to the LB cluster (120), and the LB nodes (203-1, 203-2) are installed in the form of pods on each server.

[0084] And each LB node (203-1, 203-2) installed in this way is assigned to one of the LB node groups. Three LB nodes are grouped into one group to handle the same VIP. For reference, when a request to create an LB node is received, three LB nodes are created by default. Although three LB nodes form one group according to an embodiment of the present invention, it is obvious that the number is not necessarily limited to this and may change depending on network conditions.

[0085] The external router can distribute traffic evenly to three LB nodes using the ECMP (Equal-cost multi-path routing) protocol. Using the ECMP protocol is merely one example, and the present invention is not limited thereto. Since each LB node and the external router are configured to establish BGP peers, inbound traffic can be routed from the external router to each LB node.

[0086] In the detailed description of the present invention, for convenience, it is represented as a single LB node (203-1, 203-2), but this may mean a group of LB nodes.

[0087] In FIGS. 3 and 4 below, the operation of an LB node (203-1, 203-2) according to an embodiment of the present invention is described.

[0088] FIG. 3 illustrates the concept of a control sequence for creating an additional LB node (203-3) according to an embodiment of the present invention. FIG. 4 illustrates a control sequence diagram for creating an additional LB node (203-3) according to an embodiment of the present invention.

[0089] The service API pod (113) operates an LB creation unit (311), which is an API for creating and controlling LB nodes. For example, the LB creation unit (311) can provide an API for creating and controlling LB nodes based on the 'Octavia API' among the APIs provided by OpenStack. The creation of an LB node begins when the LB creation unit (311) receives an LB creation request (S301) from a user.

[0090] When the LB creation unit (311) receives the S301 request, it transmits a port creation request (S302) to the 'Network Management Unit (312)' of OpenStack for use by the additional LB node (203-3). For example, the Network Management Unit (312) can provide APIs related to networking control based on the 'Neutron API' among the APIs provided by OpenStack.

[0091] The network management unit (312) creates a port (S303) in response to a port creation request (S302). The network management unit (312) replies to the LB creation unit (311) (S304) the VIP to be used in the additional LB node (203-3) along with the information of the created port in response.

[0092] When the driver (313) included in the LB creation unit (311) receives port information, it forwards the LB creation request along with the created port information including the VIP to the API-server (301) of the LB control node pod (131) (S305).

[0093] The CR management unit (302) included in the API server (301) is configured to create, modify, and delete Custom Resources (CRs) based on predefined CRDs regarding the LB node. When the CR management unit (302) receives a request from S305, it creates a third CR (350-3) based on port information and VIP information included in the S305 request (S306) and stores it in the database (303) (S307).

[0094] The database (303) may have first and second CRs (350-1, 350-2) corresponding to the existing first and second LB nodes (203-1, 203-2), respectively, stored in advance. Additionally, a third CR (350-3) created by the CR management unit (302) may be added and stored. The database (303) according to an embodiment of the present invention may be etcd, which is a key-value store of the Kubernetes platform.

[0095] The operator (304) monitors the CR stored in the database (303) (S308).

[0096] The operator (304) monitors the CR stored in the database (303) and performs at least one of creating, removing, and changing the corresponding LB nodes according to the creation, modification, and deletion of the CR. The operation of the operator (304) continuously creating, removing, and changing LB nodes (203-1 to 203-3) to correspond to the CR stored in the database (303) is called "Reconciling".

[0097] When monitoring results of S308 confirm that the third CR (350-3) stored in the database (303) is found, the operator (304) creates the third LB node (203-3) (S309, or requests creation).

[0098] Hereinafter, a control sequence for processing inbound traffic will be described with reference to FIG. 5.

[0099] FIG. 5 illustrates a control sequence in which an LB node (203) processes inbound traffic according to an embodiment of the present invention. The control sequence of FIG. 5 is described with reference to FIG. 2. An example related to the flowchart of FIG. 5 is a scenario in which inbound traffic is directed toward a first LB node (203-1) and is transmitted to a fifth VM (202-5).

[0100] Inbound traffic destined for a VIP corresponding to a specific LB node (203) passes through an external router (not shown) and a border leaf switch (212) to reach the corresponding LB node (203). In the scenario, the first LB node (203-1) receives (S501) packets of inbound traffic destined for its own VIP.

[0101] The first LB node (203-1) performs hashing on the header information included in the received packet (S502). Based on the hashing result, the first LB node (203-1) obtains the MAC address and VID to be changed (S503). The specific method for obtaining the MAC address and VID in this way will be described later with reference to FIGS. 8 and 9.

[0102] Next, the first LB node (203-1) replaces the MAC address and VID included in the packet header with the MAC address and VID obtained in step S503 (S504).

[0103] FIG. 6 illustrates an example in which the MAC address and VID included in the packet header are changed according to an embodiment of the present invention. FIG. 6 (a) is the header information before change (601-1), and FIG. 6 (b) is the header information after change (601-2).

[0104] The header information before change (601-1) includes the VID before change (602-1), the source MAC before change (603-1), and the destination MAC before change (604-1). In the above-described step S503, the first LB node (203-1) hashes the header information before change (601-1) to obtain the MAC address and VID to be changed (S503).

[0105] First, the first LB node (203-1) changes the source MAC (603-1) before change to the destination MAC (604-1) before change. This is because the destination before change becomes the new source after change. Then, the first LB node (203-1) replaces the destination MAC (604-1) before change with the MAC address obtained in step S503, thereby converting it to the destination MAC (604-2) after change. That is, the destination MAC (604-2) after change will be the MAC of the 5th VM (202-5). Similarly, the first LB node (203-1) replaces the VID (602-1) before change with the VID obtained in step S503, thereby converting it to the VID (602-2) after change.

[0106] Returning to Fig. 5, the first LB node (203-1) sends a packet with the MAC address and VID replaced back to the border leaf switch (212) (S504).

[0107] The border leaf switch (212) encapsulates (S505) the packet received from the first LB node (203-1). As an example, the border leaf switch (212) may encapsulate it with VXLAN. Then, the border leaf switch (212) forwards (S506) the packet to the second leaf switch (210-2), which is a TOR switch connected to the modified destination MAC (604-2), based on the modified destination MAC (604-2) included in the header of the received packet.

[0108] The second leaf switch (210-2) de-encapsulates the VXLAN header of the received packet and delivers the packet to the fifth VM (202-5) corresponding to the destination MAC (604-2) after modification (S507).

[0109] The 5th VM (202-5) checks whether the loopback IP is the 1st LB node (203-1), and if it is the 1st LB node (203-1), accepts the received packet (S508). If it is not, the 5th VM (202-5) may reject the received packet.

[0110] After processing the accepted packet, the 5th VM (202-5) can respond to the sender of the packet by exchanging the source MAC and the destination MAC (S509). That is, after exchanging the source MAC and the destination MAC, the 5th VM (202-5) sends this packet back to the 2nd leaf switch (210-2) (S510).

[0111] The second leaf switch (210-2) performs encapsulation (e.g., VXLAN encapsulation) on the received packet (S511) and transmits it to the border leaf switch (212) via the second spine switch (211-2) (S512). The border leaf switch (212) de-encapsulates the packet (S513) and sends it to the network (220) through an external router (S514).

[0112] According to the above description, the path of a packet according to one embodiment of the present invention is sent to the network (220) without passing through an LB node. This method is called Direct Server Return (DSR). According to the DSR method, since the packet does not pass through an LB node when leaving the data center, there is an advantage that the load on the LB node is reduced.

[0113] Furthermore, a load balancer management system (100) according to one embodiment of the present invention proposes a method for achieving a speed that is not inferior to that of a hardware form while the load balancer is implemented in a software form.

[0114] In one embodiment of the present invention, the first important consideration is the location of the load balancer implemented in Linux, and the second is the implementation method. The location of the load balancer will be explained with reference to FIG. 7.

[0115] FIG. 7 is a diagram illustrating a Linux network stack to explain the location where a load balancer node is executed according to an embodiment of the present invention.

[0116] In terms of networking in Linux, looking from the lowest level to the highest level, the layers generally consist of the NIC (701, Network Interface Controller), Device Driver (702, Device Driver), Traffic Controller (703, Traffic Controller), Netfilter (704, Netfilter), TCP Stack (705), Socket Layer (706), and User Space (707). As one gets closer to User Space (707) (as one moves upward), more functions (or code) are available and more state information exists. On the other hand, as one gets closer to the NIC (701) (as one moves downward), fewer functions (or code) are available, but faster performance can be expected. In other words, when handling packets in Linux, performance improves as the data path where the packet is processed is executed at a lower layer.

[0117] In particular, when transmitting packets from the device driver (702) to the network stack, not only does a memory copying phenomenon that negatively affects performance occur, but there is also a problem that it is inevitable to allocate packets to the sk_buff structure.

[0118] Accordingly, a load balancer management system (100) according to one embodiment of the present invention proposes that load balancing be performed on a relatively low network stack of Linux. Specifically, in one embodiment of the present invention, the forwarding plane that processes packets in the kernel is proposed to improve performance by utilizing eXpress Data Path (XDP) and eBPF (Extended Berkeley Packet Filter) virtual machines.

[0119] A load balancer management system (100) according to an embodiment of the present invention utilizes eBPF / XDP to process packets at the device driver (702) layer before the packets are delivered to the networking layer of the kernel. BPF allows programs inserted into the kernel in user space (707) to be executed in the form of a lightweight virtual machine. These programs are connected to specific hooks of the kernel. eBPF refers to an extended version of classic BPF that additionally supports extended registers and instruction sets, maps (key / value stores with no size limit), etc. XDP is a type of eBPF hook and refers to a series of instructions that operate within the device driver (207).

[0120] FIG. 8 illustrates an example of a hash table (801) according to an embodiment of the present invention. FIG. 9 shows the relationship between an LBN core (905) of a Linux kernel and an LBN controller (910) of user space (707) according to an embodiment of the present invention.

[0121] The control unit (902) of the LBN controller (910) inserts a program into the LBN core (905) and updates the second hash table storage (903) used by the LBN core (905).

[0122] The first hash table storage (901) included in the LBN controller (910) refers to a storage that loads rules stored in the second hash table storage (903) of the LB node (203). The update method of the first and second hash table storages (901, 903) will be described later.

[0123] The LBN core (905) controls the overall operation of the LB node (203).

[0124] The second hash table storage (903) stores rules for the LB node (203) to perform load balancing. For example, when a packet of inbound traffic is received, the second hash table storage (903) stores rules for which virtual machine to forward the received packet. These rules can be stored in the form of a hash table (801) as in the example of FIG. 8.

[0125] A second hash table store (903) according to one embodiment of the present invention may be implemented as a BPF map, which is a key / value store in the kernel. The second hash table store (903) can be updated only through an LBN controller (910).

[0126] If a rule related to load balancing is to be added or changed, the LBN controller (910) first loads the rule (in the form of a hash table as shown in the example of FIG. 8) stored in the second hash table storage (903) into the first hash table storage (901). Then, the LBN controller (910) updates the rule loaded in the first hash table storage (901) to reflect the change. Next, the LBN controller (910) can add or change the rule by overwriting the updated rule in the second hash table storage (903). To this end, the LBN controller (910) according to an embodiment of the present invention can keep the rules stored in the first and second hash table storages (901, 903) identical (Sync).

[0127] Below, we will explain how to apply the rules stored in the second hash table storage (903).

[0128] When a packet is received by an LB node (203) as in step S501 of Fig. 5, the LBN core (905) of the receiving LB node (203) executes two hash functions to obtain destination information (destination MAC and VID).

[0129] Referring to FIGS. 8 (a) and (b), a hash table according to an embodiment of the present invention may be provided to include a first hash table and a second hash table (801, 802). The first hash table (801) is used to find the location where the second hash table (802) is stored using a first hash function, which will be described below. The second hash table (802) is used to find the final virtual machine (VM) to which the packet will be delivered using a second hash function.

[0130] Referring to the second hash table (802) illustrated in FIG. 8, a separate table may exist for each VIP. For the first VIP (VIP 1), a hash table A (802A) may be provided, for the second VIP (VIP 2), a hash table B (802B) may be provided, and for the third VIP (VIP 3), a hash table C (802C) may be provided. In the illustrated example, hash tables A through C (802A through 802C) are separated into rows on a single hash table (801), but this is merely an example and they may be stored in the form of columns or separate tables.

[0131] The distinction of VIPs in the second hash table (802) may be a distinction of services. For example, the first service may be assigned as the first VIP, and the second service may be assigned as the second VIP. That is, when providing multiple services on a single data center, individual VIPs may be assigned to each service. And hash tables A to C (802A to 802C) corresponding to each assigned VIP may be provided.

[0132] Each entry in the second hash table (802) contains destination MAC information for the target virtual machine (VM) to which traffic is to be delivered. For example, the illustrated hash table A (802A) contains 'MAC A', the MAC address for virtual machine A; 'MAC B', the MAC address for virtual machine B; and 'MAC C', the MAC address for virtual machine C. Similarly, hash table B (802B) contains 'MAC D' and 'MAC E', and hash table C (802C) contains 'MAC F' and 'MAC G'.

[0133] First, the LBN core (905) of the LB node (203) that receives the packet applies a first hash function to the first hash table (801) to determine the memory address (one of 0, 1024, and 2048) of the corresponding VIP, and selects one of hash tables A to C (802A to 802C) based on the determined memory address.

[0134] The parameters of the first hash function include at least one of a destination IP (VIP), a destination port, a protocol, a VID, and a segment type. In one example, the segment type is set to VLAN, but is not limited thereto, and the segment type may be defined to allow the use of a different protocol instead of VLAN. Equation 1 is an example of the first hash function.

[0135]

[0136] After one of hash tables A through C (802A through 802C) is selected, the LBN core (905) applies a second hash function. The parameters of the second hash function include a 5-tuple (source IP, source port, destination IP, destination port, protocol) and at least one of the VID of the packet header. Through the second hash function, the MAC address and VID of the final virtual machine (VM) to which the packet will be delivered can be obtained (S503 of FIG. 5 described above). In the example, each VIP hash table has the same VID, but virtual machines existing in the same service group may have different VIDs. Equation 2 is an example of the second hash function.

[0137]

[0138] Meanwhile, for the load balancer management system (100) to perform efficient load balancing, the sorting method for the items in the hash table (801) as in the example of FIG. 8 described above is important. This is because virtual machines are easily joined and removed from the load-balanced target pool, so the items stored in each hash table (801) are frequently replaced (deleted or added). Even if only information about one virtual machine is added or deleted from the hash table (801), the location of information about other existing virtual machines may change for reasons such as maintaining the ratio of items in the hash table (801).

[0139] The change in the target virtual machine for a specific VIP due to a change in the hash value of a hash function is called "hashing disruption." Due to such "hashing disruption," unrelated connections may be unintentionally terminated. For connections that are unintentionally terminated, an additional process is required to re-establish the connection with another target. Therefore, an embodiment of the present invention proposes a hash table mechanism that supports minimal "hashing disruption."

[0140] To this end, one embodiment of the present invention proposes using a Maglev hashing mechanism, which is an improved version of a consistent hashing algorithm. This is because using Maglev hashing allows the position of an existing item to be changed as little as possible when a new item is added to the hash table (801) or an existing item is deleted.

[0141] According to Maglev hashing, items for each virtual machine are placed in a hash table through two processes called "Permutation" and "Population." "Permutation" is a process that generates a 2D array by obtaining a non-overlapping order for each item. "Population" refers to a process that fairly assigns positions to items in order.

[0142] In one embodiment of the present invention, the number of virtual machine entries supported by the hash table (801) according to Maglev hashing can be defined as MAX_VIPS * (MAX_VMS * FR). MAX_VIPS is the number of VIPs supported by one LBN, the default value is 4096, and can be changed depending on the network condition. MAX_VMS refers to the number of virtual machines that can be processed per VIP. FR is a parameter multiplied by MAX_VMS, and as this value increases, "hashing disruption" decreases, and can be used to assign a weight to each VIP.

[0144] - Experimental verification of load balancer performance according to an embodiment of the present invention

[0145] The performance of a software-implemented LBN can be determined by how closely it approximates the packet speed of a direct wired connection. Based on the degree of approximation, it may be possible to determine whether the LB can be used in an actual network. If it is similar to a direct wired connection (the "Loopback" item in the experimental results shown in Figures 11 to 15 below), it can be considered to have satisfactory performance as an LBN.

[0146] To this end, the performance of LBN was measured in this experiment using the RFC2544 standard, which is widely used for measuring the performance of physical equipment such as firewalls and routers. This standard specifies the conditions for performance tests, enabling accurate comparison of performance between the company's products. In addition to RFC2544, a test called IMIX, which simulates actual traffic patterns, was also conducted to meet the characteristics of a data center.

[0147] IMIX refers to a traffic pattern in which the frames included in the traffic are mixed in a fixed ratio according to frame size. Therefore, IMIX traffic can be viewed as traffic that mimics traffic patterns that may occur in an actual cloud network.

[0148] Below, we will first explain in detail the attribute values ​​set in the experiment, and then describe the performance of the RFC2544 test and IMIX test in order.

[0149] Figure 10 illustrates the experimental environment of the present experiment.

[0151] A. Experimental Environment Setup

[0152] As defined in RFC2544, the experimental environment was configured so that one switch (1002) is connected to two servers (1001-1, 1001-2). The tester server (1001-1) acts as the tester, and the DUT server (1001-2) acts as the DUT (device under test). For each test scenario (Scenario A and Scenario B), the tester server (1001-1) is configured to generate packets and send them to the switch (1002), and the DUT server (1001-2) receives the packets to obtain performance metrics such as "throughput".

[0153] In this experiment, "TRex," an open-source traffic generator, was installed to measure the performance of the tester server (1001-1). "TRex" is a software instrument that achieves low cost and high performance by utilizing Intel's DPDK, and is characterized by the generation of Stateful and Stateless traffic. Using "TRex," scenarios can be written in Python scripts to perform tests that comply with RFC standards. Furthermore, it is possible to perform tests similar to commercial physical tester equipment.

[0154] Among the cores of the test server (1001-1), all CPU cores except for the minimum core for running the test server (1001-1) are configured for "TRex" packet transmission. The DUT server (1001-2) is equipped with an LBN that changes the header of a packet received from the switch (1002) to the MAC address and VID of the test server (1001-1) and transmits it to the switch (1002).

[0155] Both the tester server (1001-1) and the DUT server (1001-2) utilized a 2.10GHz CPU (16 cores total, 11MB L3 cache) and four 32GB RAMs. Ubuntu 20.04 with kernel 5.4 was installed on each server (1001-1, 1001-2). The NIC cards used on each server (1001-1, 1001-2) were Mellanox Dual Port 25G. One port on the tester server (1001-1) was configured to perform RX only, while the other port was configured to perform TX only. On the other hand, the DUT server (1001-2) had only one port, which performed both RX and TX. To check for packets containing VLAN headers at the kernel level, the kernel's rxvlan and txvlan offload functions were disabled on both servers (1001-1, 10001-2). On the tester server (1001-1), the MLX5 full mode driver, which is a driver for using Mellanox's NIC card as DPDK, was installed.

[0156] Iptables, part of the Linux Netfilter project, provides packet filtering and control (such as NAT) functions. Among these, DNAT is a feature that can be used simply for load balancing. In other words, traffic can be load balanced using various DNAT rules that change the destination address of incoming packets. For this reason, Iptables DNAT was selected as a comparison target to verify the performance of LBN. Additionally, a loopback test was performed by directly connecting the TX and RX ports of the test server, and this performance was set as the upper limit for load balancing performance.

[0157] LBN performs load balancing with multiple virtual machines (VMs) per VIP. Therefore, in this experiment, we set the number of VIPs and the number of virtual machines as parameters that can be modified.

[0158] Furthermore, a total of two scenarios were established for the use of LBN. The first is Siranio, which load balances 1 VIP and 255 virtual machines (Scenario A in Fig. 10), and the other is a scenario that load balances 128 VIPs and 4,000 virtual machines (Scenario B in Fig. 10). For tests involving multiple VIPs, traffic was configured to be sent by randomly selecting from the VIP range. The range of VIPs sent by the tester server (1001-1) is identical to the VIP list range of the rules added to the LBN hash table. LBNs belonging to the same group have the same rules. Since this test is for L2DSR, the destination IP of the traffic does not change, but the VID and destination MAC address are changed to the VID and MAC address of one of the related actual destination virtual machines. To create an Iptables DNAT that performs the same operations as LBN, the rules for 128 VIPs were applied identically to the Iptables DNAT. The switch (1002) connecting the tester server (1001-1) and the DUT server (1001-2) simply acts as a bridge that floods incoming packets to the port in the direction of the other connected server. In a standard L2DSR configuration, each port of the switch connected to the LBN server is set to trunk mode to allow traffic connected to various VLANs, but in the experimental environment, the port is set to access mode so that only specific VLANs can transmit and receive.

[0160] B. Performance test according to RFC2544

[0161] This section describes the experimental setups performed according to the RFC2544 standard and shows the throughput (in BPS and PPS units).

[0162] In this experiment, a total of seven types of frame sizes (64, 128, 256, 512, 1024, 1280, 1510 (bytes)) were tested. Specifically, for each frame size, the following four types of tests were performed:

[0163] 1) Loopback

[0164] 2) Iptables' DNAT

[0165] 3) Scenario A for LBN (#VIP = 1, #Real-VM = 255)

[0166] 4) Scenario B for LBN (#VIP = 128, #Real-VM = 4,000)

[0167] In a single trial, UDP traffic of each frame size was transmitted for 60 seconds at the maximum speed of a 25G NIC card, and the average throughput of three trials was used as the final result. The interval between trials was set to 30 seconds to prevent interference between trials.

[0168] Figures 11 to 13 illustrate the throughput of each scenario when traffic consisting only of frames of a specific size is transmitted at the full speed of a 25G NIC card.

[0169] In particular, Figures 11 and 12 show the throughput in BPS units at the L2 and L1 levels, respectively. Figure 13 shows the throughput in PPS units at the L2 level. In the results for all frame sizes, the loopback performance can be recognized as the best performance achievable by the LB.

[0170] In Figures 11 and 12, it can be seen that as the frame size decreases, the frame processing overhead increases, resulting in a lower BPS. The result in Figure 11 is the result after removing both the headers of Layer 1 and Layer 2 of the frame, and the result in Figure 12 is the result after removing only the header of Layer 1 of the frame, so Figure 12 will show better performance.

[0171] The test results can be interpreted from three perspectives regarding the given figures.

[0172] 1) Whether LBN's performance is close to loopback

[0173] 2) How much of a performance difference is there between Iptables DNAT and LBN?

[0174] 3) How significant is the performance difference when the number of rules applied to LBN differs?

[0175] For BPS for L1 and L2 (Figs. 11 and 12), when the frame size is 64, the difference between loopback and LBN is less than about 5 to 6 Gbps. That is, LBN is about 24% lower than the actual physical maximum performance. When the frame size is 128, the difference is only about 3%, and it can be seen that the performance is almost identical at larger frame sizes.

[0176] Excluding the inevitable performance degradation that occurs when processing the smallest frame size of 64, it is proven that LBN demonstrates significantly higher performance. Even in the worst performance case (when the frame size is 64), LBN provides 16 times better performance than Iptables DNAT. In the case where the difference is smallest (when the frame is 1,510), the difference is approximately twofold.

[0177] When comparing the two scenarios for LBN with different number of rules, in the worst case (when the frame size is 64), performance decreases by about 4.2% as the number of rules increases. However, since there is almost no difference for other frame sizes, it can be seen that the number of rules does not have a significant impact on performance.

[0178] Figure 13 shows the results of Figure 11 in PPS units. Unlike BPS, it can be seen that the PPS increases as the frame size decreases because more packets are transmitted. When the frame size is 64, the difference between loopback and LBN is less than about 7 to 8 Mpps. The percentage values ​​for the three perspectives mentioned above will be the same as those mentioned in relation to Figures 11 and 12.

[0180] C. Performance Test Based on IMIX

[0181] Figure 14 illustrates the Troughput results in BPS (L2 and L1 levels) for IMIX traffic. Figure 15 illustrates the Troughput results in PPS for IMIX traffic.

[0182] IMIX's ratios by size have changed over time. However, there are generally used ratios for each frame size. The ratios for each frame size used in the experiment are 60%, 20%, and 20% for frames with sizes of 64, 512, and 1510, respectively. Since the test was performed by mixing traffic of various frame sizes, it can be seen that it is similar to a real network environment. Referring to Figure 14, the difference in BPS measured at the L2 level between Loopback and LBN is less than approximately 0.7 Gbps. This means that LBN is only about 2% lower than its theoretical maximum performance. Furthermore, LBN provides 27 times better performance than Iptables DNAT. When comparing the two scenarios with different rule counts for LBN, it can be confirmed that there is almost no difference. As with the RFC255 test, it can be seen that the number of rules does not significantly affect the performance of LBN.

[0184] Although embodiments of the control method of a load balancer management system according to the present invention have been described above, these are described as at least one embodiment, and the technical concept, configuration, and operation of the present invention are not limited by this, and the scope of the technical concept of the present invention is not limited or restricted by the drawings or the description with reference to the drawings. Furthermore, the concept and embodiments of the invention presented in the present invention may be used by those skilled in the art as a basis for modifying or designing other structures to perform the same purpose of the present invention, and equivalent structures modified or changed by those skilled in the art are bound by the technical scope of the present invention as described in the claims, and various changes, substitutions, and modifications are possible within the limits of not departing from the concept or scope of the invention as described in the claims.

Claims

Claim 1 A method for controlling a load balancer node comprises: a step in which an LBN core receives a packet from a border leaf switch; a step in which the LBN core applies a first and a second hash function to the received packet; a step in which the LBN core obtains a destination MAC address and a VID from a hash table based on the result of applying the first and second hash functions; a step in which the LBN core replaces at least one of the destination address and VID of the received packet with the obtained destination MAC address and VID; and a step in which the LBN core transmits the replaced packet to the border leaf switch, wherein the load balancer node is automatically created, modified, or removed according to the result of monitoring a custom resource defined by a custom resource definition in a Kubernetes environment by an operator, and if the monitoring result detects that a first custom resource is stored in a database, a load balancer node corresponding to the first custom resource is created by the operator, and if the monitoring result detects that a second custom resource among at least one custom resource stored in the database is deleted, the A method for controlling a load balancer node, characterized in that the load balancer node corresponding to the deleted second custom resource is deleted by the operator. Claim 2 A method for controlling a load balancer node, wherein the first and second hash functions are applied to the header of the received packet in claim 1. Claim 3 A method for controlling a load balancer node according to claim 1, wherein the parameters of the first hash function include at least one of a destination IP (VIP), destination port, protocol, VID, and segment type for the received packet. Claim 4 A method for controlling a load balancer node according to claim 1, wherein the parameters of the second hash function include at least one of a source IP, source port, destination IP, destination port, protocol, and VID of the packet header for the received packet. Claim 5 A method for controlling a load balancer node according to claim 1, wherein the acquiring step comprises the step of the LBN core acquiring a VIP (Virtual IP) based on the first hashing result of the first hash function. Claim 6 A method for controlling a load balancer node according to claim 5, wherein the acquiring step further includes the step of the LBN core acquiring a destination MAC address based on the second hashing result of the second hash function and the first hashing result. Claim 7 In a load balancer node, a hash table store that stores hash tables; The load balancer node includes an LBN core that receives a packet from a border leaf switch, wherein the LBN core applies a first and a second hash function to the received packet, obtains a destination MAC address and a VID from the stored hash table based on the result of applying the first and second hash functions, replaces the destination MAC address and a VID of the received packet with the obtained destination MAC address and a VID, and transmits the replaced packet to the border leaf switch, wherein the load balancer node is automatically created, modified, or removed based on the result of monitoring a custom resource defined by a custom resource definition in a Kubernetes environment by an operator, and if the monitoring result detects that a first custom resource is stored in a database, a load balancer node corresponding to the first custom resource is created by the operator, and if the monitoring result detects that a second custom resource among at least one custom resource stored in the database is deleted, a load balancer node corresponding to the deleted second custom resource is deleted by the operator. A load balancer node characterized by Claim 8 In claim 7, the first and second hash functions are applied to the header of the received packet, a load balancer node. Claim 9 In claim 7, the parameters of the first hash function include at least one of a destination IP (VIP), destination port, protocol, VID, and segment type for the received packet, a load balancer node. Claim 10 In claim 7, the parameters of the second hash function include at least one of a source IP, source port, destination IP, destination port, protocol, and VID of the packet header for the received packet, a load balancer node. Claim 11 In claim 7, the load balancer node, wherein the LBN core obtains a VIP (Virtual IP) based on the first hashing result of the first hash function. Claim 12 In claim 11, the load balancer node, wherein the LBN core obtains a destination MAC address based on the second hashing result of the second hash function and the first hashing result.

Citation Information

Patent Citations

  • LOAD BALANCING COMPUTER DEVICE, SYSTEM AND METHOD

    JP2018523932A

  • System and method for supporting efficient load-balancing in a high performance computing (HPC) environment

    KR1020170029595A

  • Distributed load balancer

    KR1020170121311A