LOAD BALANCING FOR SERVICES

Description

BACKGROUND

1. Background and Relevant Art

[0001] Computer systems and related technology affect many aspects of society. Indeed, the computer system's ability to process information has transformed the way we live and work. Computer systems now commonly perform a host of tasks (e.g., word processing, scheduling, accounting, etc.) that prior to the advent of the computer system were performed manually. More recently, computer systems have been coupled to one another and to other electronic devices to form both wired and wireless computer networks over which the computer systems and other electronic devices can transfer electronic content. Accordingly, the performance of many computing tasks are distributed across a number of different computer systems and/or a number of different computing components.

[0002] In many environments, multiple remote users access applications and data through a centralized remote location. For example, a number of client machines can access a Web service via the Internet. In many environments, and especially for services (or other applications) with increased workload, multiple instances of the service (or application) are created to provide a better user experience. However, it is of little benefit to have multiple instances of a service if the overall workload is not relatively evenly distributed crossed the multiple instances of the service. For example, if a one instance (or a small subset of instances) is overburdened and at the same time other instances are underutilized, the benefit of having multiple instances is significantly reduced.

[0003] Thus, multiple instance server environments typically include some type of load balancing technology to more evenly distribute workload between across instances of a service. For example, when communication for a service is received, a load balancer can be route the communication to an instance of the service having a reduced load. Thus, an overall workload for a service can be more evenly distributed across multiple instances of the service.

[0004] However, determining how to route newly received communication is primarily based on instance workloads at the time new communication is received. For example, it may that a client had prior communication with a particular instance of a service related to an ongoing use of the service. However, when the client sends new communication related to the ongoing use of the service, the new communication may be routed to a different instance of the service based on essentially soley on workload at the time the new communication is received. This is less than optimal for longer running and/or stateful services.

[0005] Communication between a client and a stateful service can include a series of request/reply sequences. Between each request/reply sequence the service can persist some state related to the communication, such as, for example, maintaining intermediate values while waiting for a further client request. However, if an instance of the service that persisted state experiences a subsequently high workload between request/reply sequences, a load balancer may send further client requests to a different instance of the server. Unfortunately, when communication is switched from one instance of the service to another instance of the service, the other instance of the service may not be aware of the persisted state for the communication. As such, the other instance is required to recalculate the persisted state.

[0006] Re-loading (already persisted) state at a new instance consumes more resources than allowing the instance that persisted the state to process the next client request in a communication. Thus, diverting communication to a new instance can unnecessarily increase the overall workload of a service. Further, memory resources for the instance that persisted the state are essentially wasted, since the persisted state is not used for further communication with the client.

[0007] EP 1 209 876 A2 relates to a dynamic load balancer providing a method of accelerating the operation of a load balancer by an accelerator switch. The method includes receiving, by the accelerator switch, packets directed to the load balancer, determining, for at least some of the received packets, whether the packets match an entry of a list of packet groups, by comparing fewer than five parameters of the packets to respective fields of entries of the list, and forwarding, by the accelerator switch, at least some of the received packets, directly to their destination, responsive to the determining.

[0008] US 2007/198721 A1 relates to a load balancing method and system. A load balancing method for continuation requests transmitted from client moves session information to continuation request to another business server and embeds a character string for making a request transmission apparatus identify the business server of destination in to a response to the continuation request to return the response to the client, so that the business server of destination to which subsequent requests transmitted from the client are transferred is switched.

[0009] US 2008/195754 A1 relates to a method and apparatus for affinity of users to application servers. A method and apparatus route hypertext protocol requests to one of a plurality of application servers, which share a database through a backend database management system. The application servers store session data in the database. Hence, if a subsequent request is routed to a different application server, the session data is available through the backend database management system.

[0010] US 2006/064478 A1 relates to methods and apparatus for geo-locating load balancing. A communication network architecture includes multiple servers, multiple load balancers, and multiple geographically dispersed communication devices. The servers provide services to the communication devices within the communication network. The load balancers each service a shared virtual Internet Protocol (IP) address common to all of the load balancers and perform load balancing of service requests on behalf of two or more of the servers that are located geographically proximate to the load balancer. The communication devices are communicatively coupled with the load balancers and are configured to issue service requests intended for any of the servers to the shared virtual IP address, whereby, upon issuing a service request, a communication device is directed to a particular server selected by a load balancing routine that is associated with a load balancer that is closest to the communication device.

[0011] US 2003/023669 A1 relates to a method and apparatus for facilitating load balancing in a server farm. All of the information about each server necessary for a load balancing program to define and execute a load balancing algorithm is stored at a predetermined URL or each server. The load balancer can query the predefined URL, which returns the necessary information. The load balancer then dynamically configures the load balancing algorithm in accordance with the returned information.

BRIEF SUMMARY

[0012] It is the object of the present invention to provide methods, systems and computer program products for load balancing for services.

[0013] This object is solved by the subject matter of the independent claims.

[0014] Embodiments are given in the dependent claims.

[0015] In some embodiments, an application load balancer receives a first client initiated message directed to an application. The first client initiated message is the first message (e.g., an activation message) in a plurality of messages included in a message sequence. The application load balancer assigns a specified identifier to the plurality of messages included in the message sequence based on the characteristics of the first client initiated message. The application load balancer determines that the assigned identifier is not mapped to an instance of the application.

[0016] The application load balancer maps the specified identifier to a specified instance of the application in accordance with a load balancing algorithm The mapping assists in balancing the load for the application across the plurality of instances of the application. The application load balancer sends the message to the specified instance of the application.

[0017] The application load balancer receives a second client initiated message directed to the application subsequent to receiving the first client initiated message. The application load balancer assigns the specified identifier to the second client initiated message based on the characteristics of the second client initiated message. The application load balancer correlates the second client initiated message with the first client initiated message (e.g., resulting in a correlated message that is correlated with an activation message).based on the mapping of the specified identifier to the specified instance of the application. The application load balancer sends the second client initiated message to the specified instance of the application in response to the correlation.

[0018] In other embodiments, an application load balancer receiving an application instance initiated message from a specified instance of a plurality of instances of an application. The application instance initiated message is directed to another application. The application load balancer assigns a specified identifier to the application instance initiated message based on the characteristics of the application instance initiated message. The application load balancer maps the specified identifier to the specified instance of the application to balance the load for the application across the plurality of instances of the application. The mapping assists in balancing the load for the application across the plurality of instances of the application.

[0019] The application load balancer sends the message to the other application. The application load balancer receives a return message from the other application directed to the application. The application load balancer assigns the specified identifier to the return message based on the characteristics of the return message. The application load balancer correlates the return message with the application instance initiated message based on the mapping of the specified identifier to the specified instance of the application. The application load balancer sends the return message to the specified instance of the application.

[0020] This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

[0021] Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the invention. The features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the present invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter.

BRIEF DESCRIPTION OF THE DRAWINGS

[0022] In order to describe the manner in which the above-recited and other advantages and features of the invention can be obtained, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:

Figure 1 illustrates a view of an example computer architecture that facilitates load balancing for services.

Figure 2 illustrates a view of an example computer architecture that facilitates load balancing for services.

Figure 3 illustrates a flow chart of an example method for load balancing for services.

Figure 4 illustrates a flow chart of an example method for load balancing for services.

DETAILED DESCRIPTION

[0023] The present invention extends to methods, systems, and computer program products for load balancing for services. In some embodiments, an application load balancer receives a first client initiated message directed to an application. The first client initiated message is the first message (e.g., an activation message) in a plurality of messages included in a message sequence. The application load balancer assigns a specified identifier to the plurality of messages included in the message sequence based on the characteristics of the first client initiated message. The application load balancer determines that the assigned identifier is not mapped to an instance of the application.

[0024] The application load balancer maps the specified identifier to a specified instance of the application in accordance with a load balancing algorithm The mapping assists in balancing the load for the application across the plurality of instances of the application. The application load balancer sends the message to the specified instance of the application.

[0025] The application load balancer receives a second client initiated message directed to the application subsequent to receiving the first client initiated message. The application load balancer assigns the specified identifier to the second client initiated message based on the characteristics of the second client initiated message. The application load balancer correlates the second client initiated message with the first client initiated message (e.g., resulting in a correlated message that is correlated with an activation message).based on the mapping of the specified identifier to the specified instance of the application. The application load balancer sends the second client initiated message to the specified instance of the application in response to the correlation.

[0026] In other embodiments, an application load balancer receiving an application instance initiated message from a specified instance of a plurality of instances of an application. The application instance initiated message is directed to another application. The application load balancer assigns a specified identifier to the application instance initiated message based on the characteristics of the application instance initiated message. The application load balancer maps the specified identifier to the specified instance of the application to balance the load for the application across the plurality of instances of the application. The mapping assists in balancing the load for the application across the plurality of instances of the application.

[0027] The application load balancer sends the message to the other application. The application load balancer receives a return message from the other application directed to the application. The application load balancer assigns the specified identifier to the return message based on the characteristics of the return message. The application load balancer correlates the return message with the application instance initiated message based on the mapping of the specified identifier to the specified instance of the application. The application load balancer sends the return message to the specified instance of the application.

[0028] Embodiments of the present invention may comprise or utilize a special purpose or general-purpose computer including computer hardware, as discussed in greater detail below. Embodiments within the scope of the present invention also include physical and other computer-readable media for carrying or storing computer-executable instructions and/or data structures. Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer system. Computer-readable media that store computer-executable instructions are physical storage media. Computer-readable media that carry computer-executable instructions are transmission media. Thus, by way of example, and not limitation, embodiments of the invention can comprise at least two distinctly different kinds of computer-readable media: physical storage media and transmission media.

[0029] Physical storage media includes RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer.

[0030] With this description and following claims, a "network" is defined as one or more data links that enable the transport of electronic data between computer systems and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a transmission medium. Transmissions media can include a network and/or data links which can be used to carry or desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. Combinations of the above should also be included within the scope of computer-readable media.

[0031] Further, it should be understood, that upon reaching various computer system components, program code means in the form of computer-executable instructions or data structures can be transferred automatically from transmission media to physical storage media (or vice versa). For example, computer-executable instructions or data structures received over a network or data link can be buffered in RAM within a network interface module (e.g., a "NIC"), and then eventually transferred to computer system RAM and/or to less volatile physical storage media at a computer system. Thus, it should be understood that physical storage media can be included in computer system components that also (or even primarily) utilize transmission media.

[0032] Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims.

[0033] Those skilled in the art will appreciate that the invention may be practiced in network computing environments with many types of computer system configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, mobile telephones, PDAs, pagers, routers, switches, and the like. The invention may also be practiced in distributed system environments where local and remote computer systems, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks. In a distributed system environment, program modules may be located in both local and remote memory storage devices.

[0034] Figure 1 illustrates an example computer architecture 100 that facilitates load balancing for services. As depicted, computer architecture 100 includes application load balancer 101 and container 112. Vertical ellipsis 191 represents that one or more other containers are also included in computer architecture 100. Computer architecture 100 can represent a container group that contains application load balancer 101, container 112, and the one or more other containers. Each of the components can be connected to one another over a system bus and/or over (or be part of) a network, such as, for example, a Local Area Network ("LAN"), a Wide Area Network ("WAN"), and even the Internet. Accordingly, each of the depicted components as well as any other connected components, can create message related data and exchange message related data (e.g., Internet Protocol ("IP") datagrams and other higher layer protocols that utilize IP datagrams, such as, Transmission Control Protocol ("TCP"), Hypertext Transfer Protocol ("HTTP"), Simple Mail Transfer Protocol ("SMTP"), etc.) over the network.

[0035] Application load balancer 101 further includes service binding 102, affinitization module 104, claims serializer 105, load balancer binding 106, configuration manager 107, active instance manager 108, node manager 109 and affinitization state 111. Generally, service binding 102 is a communication stack that sources messages for application load balancer 101. Correlation module 103, within service binding 102, is configured to correlate messages based on message content and inserts a correlation identifier into messages (e.g., into message headers) to indicate correlated messages.

[0036] Generally, application load balancer 101 is configured as part of a service or contained in the same container group as an application that is being load balanced. As such, application load balancer 101 has the same security model as the application. Thus, application load balancer 101 can access portions of a message for the application with the same rights as the application. Application load balancer 101 can be designed or built into an application when the application is designed. Alternately, application load balancer 101 can be integrated into an application when the application is initiated, such as, for example, in computer architecture 100.

[0037] Affinitization module 104 is configured to examine messages (e.g., message headers) determine how a message is to be dispatched to service instances. Affinitization module 104 can affinitize messages on a variety of different pivots, including: transport session, protocol session, message session (e.g., correlation identifiers from correlation module 103), message contents, etc. Affinitizing can include generating an affinity ID to "pin" messages in a sequence or series messages to a service instance or determine what service instance is to receive a message. Using affinitization there is a significantly increased likelihood that messages in the same session can be correlated with one another and dispatched to the same service instance.

[0038] Generally, application load balancer 101 can learn from affinitization errors. Since application load balancer 101 can be included in container group 112 (the container group including service instance 114), it can understand exceptions thrown by container 112. Thus, if a message is affinitized and dispatched to a different backend container then the one the instance is currently active on, an exception thrown by the different backend container contains data indicative that the instance is currently active on elsewhere.

[0039] For example, application load balancer 101 can understand a redirect exception returned by a back end application. The redirect exception can contain information about where the application instance is currently running. This information is used by application load balancer 101 to retransmit the message to the new destination.

[0040] Claims serializer 105 is configured to examine message authentication information and serialize any security claims derived from a message into a message header. The message header is then included in the message. Accordingly, claims in a message can be re-serialized at a service instance to perform authorization checks.

[0041] Load balancer binding 106 is a communication stack used between application load balancer 101 and container 112. Node manager 109 is configured to access dynamic and static information about service instances that application load balancer 101 is balancing across. For example, node manager can access dynamic and static information for service instance 114 from health report 133. Affinitization module 103 can used the dynamic and static information to assist in determining how to dispatch a message. Active instance manager 108 is configured to access information about service instances that are currently active for a load balanced service and the location of each service instance of the load balanced service. For example, active instance manager 108 can access information for service instance 114 from instances status change 134. Active instance manager 108 can store such information in affinitization state 111.

[0042] Configuration manager 107 is configured to provide application load balancer 101 with its configuration. Configuration manager 107 can process configuration data, such as, for example, configuration data 136 to load a configuration for application load balancer 101. Configuration data can specify throttling or other behavior for a service that is applicable to service instances of the service.

[0043] Container 112 includes load balancer binding 116, claims deserializer, 113, service instance 114, container management service 121, and instance lifecycle reporting 122. Service instance 114 is an instance of a service, such as, for example, a long running and/or stateful Web service (e.g., based on Windows Foundation ("WF") or Windows Communication Foundation ("WCF") technologies). Service instances 114 can be one of a plurality of instances of a service. Other instances of the service can be running on other containers represented by vertical ellipsis 141.

[0044] Load balancer binding 116 is a communication stack used between application load balancer 101 and container 112.

[0045] Claims deserializer 113 is configured to examine serialized claim headers and reconstruct security claims for performing authorization. Claims deserializer is also configured to authenticate application load balancer 101 to provide some assurance that security claims are being sent form application load balancer 101 (e.g., as an anti-spoofing mechanism). Claims deserializer 113 is also configured to remove claims for application load balancer 101, for example, added to a message as a result of application load balancer 101 forwarding the message. Thus, client authentication can be performed at load balancer 101 followed by performing client authorization at container 112.

[0046] Container management service 121 is configured to provide health information about the health of the computer system running service instance 114. The health of the computer system can be determined from various environmental conditions, such as, for example, memory, CPU, etc. Container management service 121 can output health information, such as, for example, in health report 133.

[0047] Instance lifecycle reporting service 122 is configured to provide events when the state of service instance 114 changes, such as, for example, when service instance 114 completes or dehydrates/passivates. For example, either of these two events can be used by active instance manager 108 to clean up its instance affinity map (stored in affinitization state 111). Instance lifecycle reporting service 122 can output events, such as, for example, in instance status change 134.

[0048] Communication between a client and a service instance can be initiated either at the client or the service instance. Figure 3 illustrates a flow chart of an example method 300 for load balancing for services, in embodiments with client initiated communication. The method 300 will be described with respect to the components and data in computer architecture 100.

[0049] Method 300 includes an act of the application load balancer receiving a first client initiated message directed to the application, the first client initiated message being the first message in a plurality of messages included in a message sequence (act 301). For example, application load balancer 101 can receive message 131, including content 141, from a client. Message 131 can be the first message in a sequence of messages that includes message 132 and one or more other messages. Thus, message 131 can be viewed as an activation message for activating load balancing for the message sequence. As previously described, application load balancer 101 can be integrated as part of an application. Thus, application load balancer can be integrated as part of the application of which service instance 114 is an instance. Accordingly, application load balancer 101 can access message content under the same security model as service instance 114.

[0050] Method 300 includes an act of the application load balancer assigning a specified identifier to the plurality of messages included in the message sequence based on the characteristics of the first client initiated message (act 302). For example, affinitization module 104 can assign an affinity ID to the message sequence that includes message 131. The affinity ID can be assigned, for example, based on correlation to a specified message session determined by correlation module 103, content 141, etc.

[0051] Method 300 includes an act of the application load balancer determining that the assigned identifier is not mapped to an instance of the application (act 303). For example, active instance manager 104 can determine that the affinity ID assigned to message 131 is not included in affinitization state 111. Method 300 includes an act of the application load balancer mapping the specified identifier to a specified instance of the application in accordance with a load balancing algorithm (act 304). For example, affinitization module 104 can map the assigned affinity ID to server instance 114 in accordance with a load balancing algorithm. Virtually any load balancing algorithm can be used. In some embodiments, a round robin algorithm assigns messages to application instances based on lifecycle of the application instance and health state information for the computer system running the specified application instance. For example, affinitization module 104 can map the assigned affinity ID to service instance 114 based health report 133 (for the computer system running service instance 1140 and instance status change 134 (for service instance 114) along with similar information for other services instances in other containers represented by ellipsis 191.

[0052] Method 300 includes an act of the application load balancer sending the first client initiated message to the specified instance of the application (act 305). For example, application load balancer 101 can send message 131 to container 112.

[0053] Method 300 includes an act of the application load balancer receiving a second client initiated message included in the message sequence subsequent to receiving the first client initiated message (act 306). For example, application load balancer 101 can receive message 132 from the client. Method 300 includes an act of the application load balancer assigning the specified identifier to the second client initiated message based on the characteristics of the second client initiated message (act 307). For example, affinitization module 104 can assign the affinity ID of message 131 to message 132, for example, based on correlation to the same specified message session as message 131, inclusion in the message sequence of message 131, content 142, etc.

[0054] Method 300 includes an act of the application load balancer correlating the second client initiated message with the first client initiated message based on the mapping of the specified identifier to the specified instance of the application (act 308). For example, active instance service manager 104 can determine that the affinity ID assigned to message 132 is already included in affinitization state 111 (from assignment of the affinity ID to message 131) and is mapped to service instance 114. As such, message 132 can be viewed as a correlated message that is correlated with message 131, which may be viewed as an activation message. Method 300 includes an act of the application load balancer sending the second client initiated message to the specified instance of the application in response to the correlation (act 309). For example, application load balancer 101 can send message 132 to container 112.

[0055] Figure 4 illustrates a flow chart of an example method 400 for load balancing for services, in embodiments with service instance initiated communication. The method 400 will be described with respect to the components and data in computer architecture 100.

[0056] Method 400 includes an act of the application load balancer receiving an application instance initiated message from a specified instance of the plurality of instances of the application, the application instance initiated message directed to another application that is external to the plurality of instances of an application (act 401). For example, application load balancer 101 can receive message 151 from container 112. Message 151 can be directed to another application in computer architecture 100 that is external to container 112 and application load balancer 101. For example, message 151 can be directed to an application that is connected to application load balancer via a wired or wireless network connection. Method 400 includes an act of the application load balancer assigning a specified identifier to the application instance initiated message based on the characteristics of the application instance initiated message (act 402). For example, affinitization module 104 can assign an affinity ID to message 151 based on a message session, protocol session, transport session, contents 161, etc., for message 151.

[0057] Method 400 includes an act of the application load balancer mapping the specified identifier to the specified instance of the application to balance the load for the application across the plurality of instances of the application (act 403). For example, active instance manager 108 can map the affinity ID for message 151 to service instance 114 since the message originated from container 112. In this embodiments, message 151 can be viewed as an activation message. Method 400 includes an act of the application load balancer sending the message to the other application (act 404). For example, application load balancer 101 can send message 151 to a client.

[0058] Method 400 includes an act of the application load balancer receiving a return message from the other application directed to the application (act 405). For example, application load balancer 101 can receive message 132 from the client. Method 400 includes an act of the application load balancer assigning the specified identifier to the return message based on the characteristics of the return message (act 406). For example, affinitization module 104 can assign the a correlation ID to message 132, for example, based on correlation to the same specified message session as message 151, conent142, or inclusion in a message sequence, etc.

[0059] Method 400 includes an act of the application load balancer correlating the return message with the application instance initiated message based on the mapping of the specified identifier to the specified instance of the application (act 407). For example, active instance service manager 104 can refer to affinitization state 111 to map the correlation ID to the affinity ID assigned to message 151. This essentially maps message 132 for delivery to service instance 114. As such, message 132 can be viewed as a correlated message that is correlated with message 151, which may be viewed as an activation message. Method 400 includes an act of the application load balancer sending the return message to the specified instance of the application (act 408). For example, application load balancer 101 can send message 132 to container 112.

[0060] An application load balancer can be built using the same infrastructure that is used to build the service the application load balancer is to balance. Further, since application load balancers can be included in a global container along with the service, application load balancers can receive messages from any transport channel of the service. As such, application load balancers can be configured to receive messages from polling transports, such as, for example, queues, databases, external stores, etc. Accordingly, embodiments of the invention permit services to be more easily scaled out. Further, inclusion in the same global container permits an application load balancer to access the contents of messages directed to the application under the same security model as the application.

[0061] For example, Figure 2 illustrates a view of an example computer architecture 200 that facilitates load balancing for services. As depicted, computer architecture 200 includes container group 201 and container group 202. Container group 201 includes load balancer 271 and load balancer 272 (at machine 251), and local container 261 at machine 252. Contain group 202 includes load balancer 273 at machine 256 and local container 263 at machine 254. Machine 253 includes location container 261 and location container 263. Local container 261 is included in container group 201 and local container 263 is contained in container group 202.

[0062] Within computer architecture 200, references ending in a letter represent instances of a service corresponding to their respective number respectively. Thus, service instances 211A and 211B represent instances of service 211, service instances 212A and 212B represent instances of service 212, and service instances 213A and 213B represent instances of service 213. Accordingly, as depicted in computer architecture 200, each service has its own corresponding load balancer: load balancer 271 balances at least between a service instance 211A and 211B, load balancer 272 balances at least between a service instance 212A and 212B, and load balancer 273 balances at least between a service instance 213A and 213B.

[0063] Each of the load balancers has a corresponding service binding to receive messages: load balancer 271 includes service binding 221, load balancer 272 includes service binding 222, and load balancer 273 includes service binding 223. Each of the load balancers also includes a load balancer binding for communication with service instances: load balancer 271 includes load balancer binding 231, load balancer 272 includes load balancer binding 232, and load balancer 273 includes load balancer binding 233.

[0064] Each service instance also includes a load balancer binding for communicating with its corresponding load balancer. For example, service instance 211A and 211B contain load balancer bindings 241A and 241B for communicating with load balancer 271. Service instance 212A and 212B contain load balancer bindings 242A and 242B for communicating with load balancer 272. Service instance 213A and 213B contain load balancer bindings 243A and 243B for communicating with load balancer 273. Thus, for each service instance endpoint there is a corresponding endpoint at an application load balancer.

[0065] Accordingly, embodiments of the invention facilitate load balancing between instances of a service based on message affinitization. For example, messages in the same session can be dispatched to the same service instance. A sequence or series of related messages associated with long running and/or stateful services are more likely to be dispatched to the same instance of the service. Thus, if the service instance has persisted client state, there is an increased likely of utilizing the persisted client state and not having another service instance recreate the client state.

[0066] Embodiments of the invention also facilitate_distributing messages to a service deployed in a server farm. For example, embodiments affinitize correlated messages to cached in-memory instances of services, which can be short or long running services. To facilitate distribution and affinitization of correlated messages, a load balancer acts as part of the application to perform the necessary decryption and authentication of the messages before passing the security information to the real application to perform authorization. Since correlation is based on content, and the content of the message is based subject to changes in the application, the application load balancer participates in any kind of versioning of the real application. That is, the application load balamcer is able to perform its duties even when there is a new version of the application which has new message contracts (and hence a different message content).

[0067] The present invention may be embodied in other specific forms without departing from its essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description.

Claims

1. A method (300) performed by an application load balancer (101) for balancing the load for an application across a plurality of instances of the application within a computer architecture, the instances of the application running on machines in a farm of machines, the computer architecture including the plurality of instances of the application (114) and the application load balancer (101) for the application, the application load balancer being part of the application, so that the application load balancer (101) can access message content (141) under the same security model as the application, the method comprising the steps of:

receiving (301) a first client initiated message (131) directed to the application, the first client initiated message (131) being the first message in a plurality of messages included in a message sequence;

assigning (302) an affinity identifier to the first client initiated message based on content of the first client initiated message (131), wherein the affinity identifier is used to pin the plurality of messages included in the message sequence to an instance of the application;

determining (303) that the assigned affinity identifier is not mapped to an instance of the application;

mapping (304) the affinity identifier to a specified instance of the application in accordance with a load balancing algorithm to balance the load for the application across the plurality of instances of the application;

sending (305) the first client initiated message (131) to the specified instance (114) of the application;

receiving (306) a second client initiated message (132) included in the message sequence subsequent to receiving the first client initiated message;

assigning (307) the affinity identifier to the second client initiated message (132) based on content of the second client initiated message;

correlating (308) the second client initiated message (132) with the first client initiated message (131) based on the mapping of the affinity identifier to the specified instance of the application, wherein correlating the second client initiated message with the first client initiated message comprises determining that the affinity identifier assigned to the second client initiated message is already mapped to the specified instance of the application; and

sending (309) the second client initiated (132) message to the specified instance (114) of the application in response to the correlation.

2. The method as recited in claim 1, further comprising the step of correlating the first client initiated message with a message session based on the content of the first client message.

3. The method as recited in claim 1, wherein the affinity identifier, ID, is assigned to the first client message to associate the first client message with other messages from the first client that are directed to the application.

4. The method as recited in claim 1, wherein the step of mapping the affinity identifier to a specified instance of the application comprises mapping the affinity identifier to a specified instance of the application based on environmental conditions of the machines running the plurality of instances of the application.

5. The method as recited in claim 1, further comprising the steps of:

examining authentication information in the first client initiated message to authenticate the client; and

serializing a security claim so that the application instance can use the security claim for an authorization check.

6. The method as recited in claim 1, wherein the client initiated messages are received from a polling transport session selected from among a queue, a database, and an external store.

7. A method (400) performed by an application load balancer (101) for balancing the load for an application across a plurality of instances of the application within a computer architecture, each instance of the application running on a different corresponding machine, the computer architecture including the plurality of instances (114) of the application and the application load balancer (101) for the application, the application load balancer being part of the application, the method comprising the steps of :

receiving (401) an application instance initiated message (151) from a specified instance of the plurality of instances of the application, the application instance initiated message directed to another application that is external to the plurality of instances of the application, and the application instance initiated message being a first message in a plurality of messages included in a message sequence;

assigning (402) an affinity identifier to the application instance initiated message based on content of the application instance initiated message (151), wherein the affinity identifier is used to pin the plurality of messages included in the message sequence to the specified instance of the application;

mapping (403) the affinity identifier to the specified instance of the application to balance the load for the application across the plurality of instances of the application;

sending (404) the application instance initiated message to the other application;

receiving (405) a return message (132) from the other application directed to the application;

assigning (406) the affinity identifier to the return message (132) based on the characteristics of the return message;

correlating (407) the return message (132) with the application instance initiated message (151) based on the mapping of the affinity identifier to the specified instance of the application, wherein correlating the return message with the application instance initiated message comprises determining that the affinity identifier assigned to the return message is already mapped to the specified instance of the application; and

sending (408) the return message (132) to the specified instance of the application.

8. The method as recited in claim 7, further comprising the step of correlating the application instance initiated message with a message session based on the content of the application instance initiated message.

9. The method as recited in claim 7, wherein the affinity identifier, ID, is assigned to the application instance initiated message to associate the application instance initiated message with other messages directed to the application instance.

10. The method as recited in claim 7, further comprising the steps of:

examining authentication information in the return message to authenticate the client; and

serializing a security claim so that the application instance can use the security claim for an authorization check.

11. A load balancing system for balancing an application load across a plurality of instances of an application running on different machines, the load balancing system comprising:

the plurality of instances of the application, wherein each instance of the application is configured to:

communicate with the application load balancer (101) through a communication stack;

deserialize serialized security (113) claim headers;

reconstruct security claims from deserialized security claim headers;

provide health state information (133) related to the health of the application instance; and

provide lifecycle events (134) related status changes at the application instance; and

an application load balancer (101) configured to:

receive messages (131,132) directed to the application (112), wherein the messages are included in a message sequence;

assign an affinity identifier to the messages based on message contents , wherein the affinity identifier is used to pin the plurality of messages included in the message sequence to an instance of the application;

receive lifecycle events (134) from each of the plurality of application instances and health state information (133) from corresponding computer systems running the plurality of application instances;

determine that the assigned affinity identifier is not mapped to an application instance;

map the assigned affinity identifier to an application instance based on the received health state information and the received lifecycle events in response to determining that the assigned affinity identifier is not mapped to an application instance such that a series of the messages with the same characteristics can be correlated with one another;

determine that the affinity identifier is mapped to the application instance;

correlate a received message (131, 132) with one or more previously received messages in the series of the messages based on the assigned affinity identifier in response to determining that the assigned affinity identifier is mapped to the application instance; and

send a received message (131, 132) to an application instance (112) so as to balance the load for the application across the plurality of instances of the application.

Ansprüche

1. Verfahren (300), das von einem Anwendungslastausgleicher (101) ausgeführt wird, um die Last für eine Anwendung über eine Vielzahl von Instanzen der Anwendung innerhalb einer Computerarchitektur auszugleichen, wobei die Instanzen der Anwendung auf Maschinen in einer Farm von Maschinen laufen, die Computerarchitektur die Vielzahl der Instanzen der Anwendung (114) und den Anwendungslastausgleicher (101) für die Anwendung umfasst, der Anwendungslastausgleicher Teil der Anwendung ist, so dass der Anwendungslastausgleicher (101) auf Nachrichteninhalt (141) unter demselben Sicherheitsmodell wie die Anwendung zugreifen kann, und das Verfahren folgende Schritte umfasst:

Empfangen (301) einer ersten client-initiierten Nachricht (131), die an die Anwendung gerichtet ist, wobei die erste client-initiierte Nachricht (131) die erste Nachricht einer Vielzahl von Nachrichten ist, die in einer Nachrichtenfolge enthalten sind;

Zuordnen (302) einer Affinitätskennung zu der ersten vom client-initiierten Nachricht basierend auf dem Inhalt der ersten client-initiierten Nachricht (131), wobei die Affinitätskennung verwendet wird, um die Vielzahl von Nachrichten, die in der Nachrichtenfolge enthalten sind, an eine Instanz der Anwendung anzuheften;

Bestimmen (303), dass die zugeordnete Affinitätskennung nicht auf eine Instanz der Anwendung abgebildet ist;

Abbilden (304) der Affinitätskennung auf eine spezifizierte Instanz der Anwendung in Übereinstimmung mit einem Lastausgleichsalgorithmus, um die Last für die Anwendung über die Vielzahl von Instanzen der Anwendung auszugleichen;

Senden (305) der ersten client-initiierten Nachricht (131) an die spezifizierte Instanz (114) der Anwendung;

Empfangen (306) einer zweiten client-initiierten Nachricht (132), die in der Nachrichtensequenz enthalten ist, nach dem Empfang der ersten client-initiierten Nachricht;

Zuweisen (307) der Affinitätskennung zu der zweiten client-initiierten Nachricht (132) basierend auf dem Inhalt der zweiten client-initiierten Nachricht;

Korrelieren (308) der zweiten client-initiierten Nachricht (132) mit der ersten client-initiierten Nachricht (131) basierend auf der Zuordnung der Affinitätskennung zu der spezifizierten Instanz der Anwendung, wobei das Korrelieren der zweiten client-initiierten Nachricht mit der ersten client-initiierten Nachricht das Bestimmen umfasst, dass die Affinitätskennung, die der zweiten client-initiierten Nachricht zugeordnet ist, bereits auf die spezifizierte Instanz der Anwendung abgebildet ist; und

Senden (309) der zweiten client-initiierten Nachricht (132) an die spezifizierte Instanz (114) der Anwendung als Reaktion auf die Korrelation.

2. Verfahren nach Anspruch 1, ferner umfassend den Schritt des Korrelierens der ersten client-initiierten Nachricht mit einer Nachrichtensitzung basierend auf dem Inhalt der ersten Client-Nachricht.

3. Verfahren nach Anspruch 1, bei dem der ersten Client-Nachricht die Affinitätskennung, ID, zugeordnet wird, um die erste Client-Nachricht anderen Nachrichten aus dem ersten Client zuzuordnen, die an die Anwendung gerichtet sind.

4. Verfahren nach Anspruch 1, bei dem der Schritt des Abbildens der Affinitätskennung auf eine spezifizierte Instanz der Anwendung das Abbilden der Affinitätskennung auf eine spezifizierte Instanz der Anwendung basierend auf Umgebungsbedingungen der Maschinen umfasst, auf der die Vielzahl von Instanzen der Anwendung laufen.

5. Verfahren nach Anspruch 1, weiterhin umfassend folgende Schritte:

Überprüfen von Authentifizierungsinformationen in der ersten client-initiierten Nachricht, um den Client zu authentifizieren; und

Serialisieren einer Sicherheitsbehauptung, damit die Anwendungsinstanz die Sicherheitsbehauptung für eine Berechtigungsprüfung verwenden kann.

6. Verfahren nach Anspruch 1, bei dem die vom Client initiierten Nachrichten von einer Abfrage-Transportsitzung empfangen werden, die aus einer Warteschlange, einer Datenbank und einem externen Speicher ausgewählt wird.

7. Verfahren (400), das von einem Anwendungslastausgleicher (101) ausgeführt wird, um die Last für eine Anwendung über eine Vielzahl von Instanzen der Anwendung in einer Computerarchitektur auszugleichen, wobei jede Instanz der Anwendung auf einer anderen entsprechenden Maschine läuft, die Computerarchitektur die mehreren Instanzen der Anwendung (114) und den Anwendungslastausgleicher (101) für die Anwendung umfasst, der Anwendungslastausgleicher Teil der Anwendung ist und das Verfahren folgende Schritte umfasst:

Empfangen (401) einer von der Anwendungsinstanz initiierten Nachricht (151) von einer spezifizierten Instanz der Vielzahl von Instanzen der Anwendung, wobei die von der Anwendungsinstanz initiierte Nachricht an eine weitere Anwendung gerichtet ist, die außerhalb der Vielzahl von Instanzen der Anwendung ist, und die von der Anwendungsinstanz initiierte Nachricht eine erste Nachricht in einer Vielzahl von Nachrichten ist, die in einer Nachrichtenfolge enthalten sind;

Zuordnen (402) einer Affinitätskennung zu der von der Anwendungsinstanz initiierten Nachricht basierend auf dem Inhalt der von der Anwendungsinstanz initiierten Nachricht (151), wobei die Affinitätskennung verwendet wird, um die Vielzahl von Nachrichten, die in der Nachrichtenfolge enthalten sind, an die spezifizierte Instanz der Anwendung zu heften;

Abbilden (403) der Affinitätskennung auf die spezifizierte Instanz der Anwendung, um die Belastung für die Anwendung über die Vielzahl von Instanzen der Anwendung auszugleichen;

Senden (404) der von der Anwendungsinstanz initiierten Nachricht an die andere Anwendung;

Empfangen (405) einer Rückmeldenachricht (132) von der anderen an die Anwendung gerichteten Anwendung;

Zuordnen (406) der Affinitätskennung zu der Rückmeldenachricht (132) basierend auf den Eigenschaften der Rückmeldenachricht;

Korrelieren (407) der Rückmeldenachricht (132) mit der von der Anwendungsinstanz initiierten Nachricht (151) basierend auf der Zuordnung der Affinitätskennung zu der spezifizierten Instanz der Anwendung, wobei das Korrelieren der Rückmeldenachricht mit der von der Anwendungsinstanz initiierten Nachricht das Bestimmen umfasst, dass die Affinitätskennung, die der Rückgabemeldung zugeordnet wurde, bereits der angegebenen Instanz der Anwendung zugeordnet ist; und

Senden (408) der Rückkehrnachricht (132) an die spezifizierte Instanz der Anwendung.

8. Verfahren nach Anspruch 7, weiterhin umfassend den Schritt des Korrelierens der von der Anwendungsinstanz initiierten Nachricht mit einer Nachrichtensitzung basierend auf dem Inhalt der von der Anwendungsinstanz initiierten Nachricht.

9. Verfahren nach Anspruch 7, bei dem die Affinitätskennung, ID, der von der Anwendungsinstanz initiierten Nachricht zugeordnet wird, um die von der Anwendungsinstanz initiierte Nachricht mit anderen an die Anwendungsinstanz gerichteten Nachrichten zuzuordnen.

10. Verfahren nach Anspruch 7, weiterhin umfassend folgende Schritte:

Überprüfen von Authentifizierungsinformationen in der Rückmeldenachricht, um den Client zu authentifizieren; und

Serialisieren einer Sicherheitsbehauptung, damit die Anwendungsinstanz die Sicherheitsbehauptung für eine Berechtigungsprüfung verwenden kann.

11. Lastausgleichssystem zum Ausgleichen einer Anwendungslast über eine Vielzahl von Instanzen einer Anwendung, die auf unterschiedlichen Maschinen läuft, wobei das Lastausgleichssystem umfasst:

die Vielzahl von Instanzen der Anwendung, wobei jede Instanz der Anwendung dazu eingerichtet ist:

mit dem Anwendungslastausgleicher (101) über einen Kommunikationsstapel zu kommunizieren;

serialisierte Sicherheitsbehauptungs-Header zu entserialisieren (113);

Sicherheitsbehauptungen aus entserialisierten Sicherheitsbehauptungs-Headern wiederherzustellen;

Intaktheitszustandsinformationen (133) in Bezug auf die Intaktheit der Anwendungsinstanz bereitzustellen; und

Statusänderungen in Bezug auf Lebenszyklusereignisse (134) in der Anwendungsinstanz bereitzustellen; und

einen Anwendungslastausgleicher (101), der dazu eingerichtet ist:

Nachrichten (131, 132) zu empfangen, die an die Anwendung (112) gerichtet sind, wobei die Nachrichten in einer Nachrichtenfolge enthalten sind;

eine Affinitätskennung zu den Nachrichten auf der Grundlage von Nachrichteninhalten zuzuordnen, wobei die Affinitätskennung verwendet wird, um die Vielzahl von Nachrichten, die in der Nachrichtenfolge enthalten sind, an eine Instanz der Anwendung zu heften;

Lebenszyklusereignisse (134) von jeder der Vielzahl von Anwendungsinstanzen und Intaktheitszustandsinformationen (133) von entsprechenden Computersystemen zu empfangen, die die Vielzahl von Anwendungsinstanzen ausführen;

zu bestimmen, dass die zugeordnete Affinitätskennung auf keine Anwendungsinstanz abgebildet ist;

die zugeordnete Affinitätskennung zu einer Anwendungsinstanz auf der Grundlage der empfangenen Intaktheitszustandsinformationen und der empfangenen Lebenszyklusereignisse als Reaktion auf das Bestimmen zuzuordnen, dass die zugeordnete Affinitätskennung nicht einer Anwendungsinstanz zugeordnet ist, so dass eine Reihe von Nachrichten mit denselben Merkmalen miteinander korrelieren können;

zu bestimmen, dass die Affinitätskennung der Anwendungsinstanz zugeordnet ist;

eine empfangene Nachricht (131, 132) mit einer oder mehreren zuvor empfangenen Nachrichten in der Abfolge der Nachrichten basierend auf der zugeordneten Affinitätskennung als Reaktion auf das Bestimmen zu korrelieren, dass die zugeordnete Affinitätskennung der Anwendungsinstanz zugeordnet ist; und

eine empfangene Nachricht (131, 132) an eine Anwendungsinstanz (112) zu senden, um so die Last für die Anwendung über die Vielzahl von Instanzen der Anwendung auszugleichen.

Revendications

1. Procédé (300) réalisé par un équilibreur de charge d'application (101) pour équilibrer la charge d'une application sur une pluralité d'instances de l'application dans une architecture informatique, les instances de l'application s'exécutant sur des machines dans une batterie de machines, l'architecture informatique comprenant la pluralité d'instances de l'application (114) et l'équilibreur de charge d'application (101) pour l'application, l'équilibreur de charge d'application faisant partie de l'application, de sorte que l'équilibreur de charge d'application (101) peut accéder au contenu du message (141) avec le même modèle de sécurité que l'application, le procédé comprenant les étapes consistant à:

recevoir (301) un premier message (131), initié par le client, dirigé vers l'application, le premier message (131), initié par le client, étant le premier message dans une pluralité de messages inclus dans une séquence de message;

attribuer (302) un identifiant d'affinité au premier message initié par le client en fonction du contenu du premier message (131) initié par le client, dans lequel l'identifiant d'affinité est utilisé pour affecter à une instance de l'application la pluralité de messages inclus dans la séquence de message;

déterminer (303) que l'identifiant d'affinité affecté n'est pas cartographié sur une instance de l'application;

cartographier (304) l'identifiant d'affinité à une instance spécifiée de l'application conformément à un algorithme d'équilibrage de charge pour équilibrer la charge pour une application à toute la pluralité d'instances de l'application;

envoyer (305) le premier message (131) initié par le client à l'instance spécifiée (114) de l'application;

recevoir (306) un second message (132), initié par le client, inclus dans la séquence de message après la réception du premier message initié par le client;

attribuer (307) l'identifiant d'affinité au second message (132), initié par le client, en fonction du contenu du second message initié par le client;

corréler (308) le second message (132) initié par le client avec le premier message (131), initié par le client, sur la base de la cartographie de l'identifiant d'affinité avec l'instance spécifiée de l'application, dans lequel la corrélation du second message initié par le client avec le premier message initié par le client consiste à déterminer que l'identifiant d'affinité attribué au second message initié par le client est déjà cartographié avec l'instance spécifiée de l'application; et

envoyer (309) le second message (132), initié par le client, à l'instance spécifiée (114) de l'application en réponse à la corrélation,

2. Procédé selon la revendication 1, comprenant en outre l'étape consistant à corréler le premier message initié par le client avec une session de message reposant sur le contenu du premier message client.

3. Procédé selon la revendication 1, dans lequel l'identifiant d'affinité, ID, est attribué au premier message client pour associer le premier message client à d'autres messages en provenance du premier client qui sont dirigés vers l'application.

4. Procédé selon la revendication 1, dans lequel l'étape de cartographie de l'identifiant d'affinité avec une instance spécifiée de l'application consiste à cartographier l'identifiant d'affinité avec une instance spécifique de l'application en fonction des conditions environnementales des machines exécutant la pluralité d'instances de l'application.

5. Procédé selon la revendication 1, comprenant en outre les étapes consistant à:

examiner les informations d'authentification dans le premier message initié par le client pour authentifier le client; et

sérialiser une revendication de sécurité afin que l'instance de l'application puisse utiliser la revendication de sécurité pour un contrôle d'autorisation.

6. Procédé selon la revendication 1, dans lequel les messages initiés par le client sont reçus à partir d'une session de transport de regroupement sélectionnée parmi une file d'attente, une base de données et un magasin externe.

7. Procédé (400) réalisé par un équilibreur de charge d'application (101) pour équilibrer la charge d'une application sur toute une pluralité d'instances de l'application dans une architecture informatique, chaque instance de l'application s'exécutant sur une autre machine correspondante, l'architecture informatique comprenant la pluralité d'instances de l'application (114) et l'équilibreur de charge d'application (101) pour l'application, l'équilibreur de charge d'application faisant partie de l'application, le procédé comprenant les étapes consistant à:

recevoir (401) un message (151) initié lancé par une instance d'application à partir d'une instance spécifiée parmi la pluralité d'instances de l'application, le message initié par l'instance d'application dirigé vers une autre application qui est externe à la pluralité d'instances de l'application, et le message initié par l'instance d'application étant un premier message dans une pluralité de messages inclus dans une séquence de message;

attribuer (402) un identifiant d'affinité au message initié par l'instance d'application en fonction du contenu du message (151) initié par l'instance d'application, dans lequel l'identifiant d'affinité est utilisé pour la pluralité de messages inclus dans la séquence de message à l'instance spécifiée de l'application;

cartographier (403) l'identifiant d'affinité à une instance spécifiée de l'application pour équilibrer la charge pour une application à toute la pluralité d'instances de l'application;

envoyer (404) le message initié par l'instance d'application à l'autre application;

recevoir (405) un message de retour (132) de l'autre application dirigé vers l'application;

attribuer (406) l'identifiant d'affinité au message de retour (132) en fonction des caractéristiques du message de retour;

corréler (407) le message de retour (132) avec le message initié par l'instance d'application (151) sur la base de la cartographie de l'identifiant d'affinité avec l'instance spécifiée de l'application, dans lequel la corrélation du message de retour avec le message initié par l'instance d'application consiste à déterminer que l'identifiant d'affinité attribué au message de retour est déjà cartographié avec l'instance spécifiée de l'application; et

envoyer (408) le message de retour (132) à l'instance spécifiée de l'application.

8. Procédé selon la revendication 7, comprenant en outre l'étape consistant à corréler le message initié par l'instance d'application avec une session de message reposant sur le contenu du message initié par l'instance d'application.

9. Procédé selon la revendication 7, dans lequel l'identifiant d'affinité, ID, est attribué au message initié par l'instance d'application pour associer le message initié par l'instance d'application avec d'autres messages dirigés vers l'instance d'application.

10. Procédé selon la revendication 7, comprenant en outre les étapes consistant à:

examiner les informations d'authentification dans le message de retour pour authentifier le client; et

sérialiser une revendication de sécurité afin que l'instance de l'application puisse utiliser la revendication de sécurité pour un contrôle d'autorisation.

11. Système d'équilibrage de charge pour équilibrer une charge d'application sur toute une pluralité d'instances d'une application s'exécutant sur des machines différentes, le système d'équilibrage de charge comprenant:

la pluralité d'instances de l'application, dans lequel chaque instance de l'application est configurée pour:

communiquer avec l'équilibreur de charge d'application (101) par l'intermédiaire d'une pile de communication;

désérialiser les en-têtes de revendications de sécurité sérielle (113);

reconstruire les revendications de sécurité à partir des en-têtes de réclamation de sécurité désérialisés;

fournir des informations d'état de santé (133) liées à la santé de l'instance d'application; et

fournir des changements d'état liés aux événements de cycle de vie (134), à l'instance de l'application; et

un équilibreur de charge d'application (101) configuré pour:

recevoir des messages (131, 132) dirigés vers l'application (112), dans lequel les messages sont inclus dans une séquence de message;

affecter un identifiant d'affinité aux messages en fonction du contenu du message, dans lequel l'identifiant d'affinité est utilisé pour affecter à une instance de l'application la pluralité de messages inclus dans la séquence de message;

recevoir des événements de cycle de vie (134) de chacune de la pluralité d'instances d'application et des informations d'état de santé (133) à partir de systèmes informatiques correspondants exécutant la pluralité d'instances d'application;

déterminer que l'identifiant d'affinité affecté n'est pas cartographié sur une instance de l'application;

cartographier l'identifiant d'affinité affecté à une instance d'application en fonction des informations d'état de santé reçues et des événements de cycle de vie reçus en réponse à la détermination que l'identifiant d'affinité affecté n'est pas cartographié sur une instance d'application de sorte que les messages d'une série donnée présentant les mêmes caractéristiques puissent être corrélés les uns avec les autres;

déterminer que l'identifiant d'affinité est cartographié sur l'instance de l'application;

corréler un message reçu (131, 132) avec un ou plusieurs messages précédemment reçus dans la série des messages en fonction de l'identifiant d'affinité affecté en réponse à la détermination que l'identifiant d'affinité affecté est cartographie sur l'instance d'application; et

envoyer un message reçu (131, 132) à une instance d'application (112) afin d'équilibrer la charge de l'application sur toute la pluralité d'instances de l'application.

Drawing