Maintaining client affinity in network load balancing systems

• US 8,046,467 B2
• Filed: 08/29/2008
• Issued: 10/25/2011
• Est. Priority Date: 08/29/2008
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Sen, Siddhartha, Yu, Jimmy C., D'Amato, Andrea, Petter, Vladimir
• Primary Examiner(s): BOUTAH, ALINA A
• Application Number:
  US12/201,254
• Publication Number:
  US 20100057923A1
• Time in Patent Office: 1,152 Days
• Field of Search: 709/226, 709/229, 718/105, 707/782, 707/783
• US Class Current: 709/226
• CPC Class Codes: G06F 2209/505 Clust
• CPC Class Codes: G06F 9/5061 Partitioning or combining of resources
• CPC Class Codes: H04L 67/1001 for accessing one among a plurality of replicated servers
• CPC Class Codes: H04L 67/1027 Persistence of sessions during load balancing
• CPC Class Codes: H04L 67/1029 using data related to the state of servers by a load balancer
• CPC Class Codes: H04L 67/1031 Controlling of the operation of servers by a load balancer, e.g. adding or removing servers that serve requests

Abstract

Described is a technology in a network load balancing system (node cluster), by which client affinity is preserved across cluster configuration changes, including for new connections from a previous client. Each node maintains a list of the clients that are to remain (have affinity, or “stickiness”) with that node, including following bucket redistribution resulting from convergence. Each affinity list is communicated during convergence so that other nodes may build an exception list or lists. Via a node'"'"'s exception list, the node that owns a bucket corresponding to a client knows of the affinity with another node and thus drops any packets from that client. Affinity may expire, whereby the node having affinity with that client releases it and notifies the node owning the bucket for that client that the client is no longer to be treated as an exception.

Claims

1. A computer-readable storage medium comprising memory, optical recording media, magnetic recording media, or a combination thereof, the computer-readable storage medium storing computer-executable instructions, which when executed by a node perform steps, the node participating in a plurality of nodes that each receive same incoming packets and that each maintain a corresponding client affinity list and a corresponding set of currently assigned buckets, a client affinity list of a node identifying clients associated with that node, wherein any given client is allowed to be in only one affinity list at any given time, and wherein periodic load-rebalancings cause some buckets to be reassigned between nodes, the steps comprising:

servicing the set of buckets currently assigned to the node, wherein buckets are periodically added to and removed from the set of buckets currently assigned to the node when there are corresponding load-rebalancings of the plurality of nodes;

receiving packets at the node from a source, the packets having also been received by another node; and

for any given packet of the received packets, deciding whether to service the given packet, the given packet including client data that identifies a client that sent the given packet, and

deciding to service the given packet by determining that the given packet maps to a bucket in the set of buckets currently assigned to the node;

when the given packet does not map to a bucket in the set of buckets currently assigned to the node, deciding to service the given packet by using the client data in the given packet to determine that the client identified in the client data is present in the affinity list; and

deciding to not service the given packet by determining that the client identified in the client data is not present in the affinity list and determining that the given bucket does not map to a bucket in the set of buckets currently assigned to the node.

2. The computer-readable storage medium of claim 1, the steps further comprising, wherein the given packet maps to a bucket in the set of buckets currently assigned to the node which is not in the affinity list, and deciding not to service the given packet by determining that the client identified in the client data is in an exception list identifying clients that have affinity with other of the nodes.

3. The computer-readable storage medium of claim 2 having further computer-executable instructions comprising, building the exception list based on affinity information provided by at least one other node, the affinity information in an affinity list stored on the at least one other node.

4. The computer-readable storage medium of claim 3 having further computer-executable instructions comprising, receiving information from the at least one other node that the at least one other node has released affinity with the client, and in response, removing the client from the exception list.

5. The computer-readable storage medium of claim 1 wherein the client is added to the affinity list based on the node having an open connection with the client when a load-rebalancing occurs.

6. The computer-readable storage medium of claim 5 having further computer-executable instructions comprising, removing the client from the affinity list of the node when the node determines that it has no connections to the client for a period of time, and notifying another node having a bucket, in its set of currently assigned buckets, that maps to the given packet, that the node is releasing affinity with the client.

7. The computer-readable storage medium of claim 6 having further computer-executable instructions comprising, during or when entering a load-rebalancing, communicating the client affinity information to the at least one other node.

8. In a computing environment, a system comprising, a plurality of nodes, each node including logic executed by memory and a processor, the logic selectively accepting only certain packets based on information contained within each packet, wherein buckets are reassigned among the nodes when there is a load-rebalancing of the plurality of nodes, the system including logic that determines whether a packet maps to a bucket currently owned by that node, and determines whether the packet corresponds to a client with which the node has affinity or whether the packet corresponds to a client with which the node knows of as an exception, and the logic configured to accept the packet when the node has affinity and the packet does not map to a bucket currently owned by that node, and the logic configured to accept the packet when the packet maps to a bucket currently owned by that node and it has been decided that there is no exception associated with the client corresponding to the packet.

9. The system of claim 8 wherein the logic is further configured to perform the load-rebalancing, including sending affinity information to at least one other node, and to be notified of received affinity information from at least one other node, the logic building an exception list based on the received affinity information so as to know which client or clients have exceptions.

10. The system of claim 8 wherein the logic is further configured to remove an exception upon notification from another node that the other node no longer has affinity with a client.

11. The system of claim 8 wherein the logic is further configured to notify another node of no longer having affinity with a client.

12. A method implemented by each node in a plurality of load-balancing nodes, each node comprising a processor and memory that perform the method, the method performed by any given node comprising:

maintaining hash information indicating hash values that are currently assigned to the given node, wherein when a convergence occurs for the plurality of load-balancing nodes the hash information indicates a new set of hash values currently assigned to the given node in response to the convergence;

maintaining an association list of clients associated with the given node;

receiving a plurality of packets from clients via network connections between the given node and the clients, respectively;

computing a hash value of each received packet;

dropping a first plurality of the received packets based on the computed hash values thereof indicating that corresponding buckets are not currently assigned to the given node, unless the nodes that sent such packets are included in the association list; and

passing a second plurality of the received packets based on the computed hash values thereof indicating that corresponding buckets are currently assigned to the given node.

13. The method of claim 12 further comprising sending an association list from one node to at least one other node.

14. The method of claim 13 further comprising, receiving the sent association list at the other node and using the received affinity list to build an exception list.

15. The method of claim 12 further comprising performing a convergence by reassigning hash values among nodes by identifying hash values that to not have a connection to a client and reassigning only the identified hash values.

16. The method of claim 12 further comprising, entering a packet handling state at the given node, including receiving a packet from a client at the given node and accepting the packet when the packet maps to a hash value assigned to that node and when no other node has an association list that includes the client.

17. The method of claim 16 further comprising, at the given node, receiving a message indicating that another node has released affinity with a client, and in response, removing an exception for that client from an exception list maintained at the given node.

18. The method of claim 12 further comprising, notifying at least one other node that affinity with a client is released such that the other node begins accepting packets from the client.

19. The method of claim 18 further comprising, determining that affinity is to be released based upon a time limit associated with the client.

20. A method according to claim 12, the method performed by the given node further comprising:

maintaining an exclusion list of clients not associated with the given node, and dropping a third plurality of the received packets that have hash values corresponding to buckets currently assigned to the given node, the dropping based on the clients that sent the third plurality of the received packets being included in the exclusion list.