Context Engine for Attribute-Based Load Balancing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing middlebox services do not effectively utilize rich-contextual data from network and process events due to inefficient filtering of captured attributes, limiting their ability to process service rules defined by smaller contextual attribute sets.
Innovation Solution
A novel architecture that executes a guest-introspection agent, context engine, and attribute-based service engines on host computers to capture and process contextual attributes from network and process events, using these attributes to identify and enforce context-based service rules.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If existing middlebox solutions capture contextual attributes from network events, then more contextual data is available for service rules, but the filtering and processing efficiency deteriorates due to the large volume of captured attributes
Solution Approach 1:
The patent extracts only the necessary contextual attributes from the large set of captured attributes by matching them against service rule definitions. The context engine identifies and extracts only those attributes that are actually used by service rules, filtering out unnecessary attributes to maintain processing efficiency while充分利用 the relevant contextual information.
Solution Approach 2:
The patent segments the attribute filtering process into multiple stages: first capturing all contextual attributes, then filtering them through a matching process against service rule definitions, and finally delivering only the relevant subset to service engines. This segmentation allows efficient processing by breaking down the large attribute set into manageable, relevant portions.
2Productivity
If a distributed scheme is implemented for filtering contextual attributes across multiple hosts, then processing scalability improves, but system complexity increases due to coordination requirements
Solution Approach 1:
The context engine is designed with multi-functionality to handle both attribute capture and filtering operations within a single distributed component on each host. This universal design allows the same engine to perform multiple functions (capturing attributes from GI agents, filtering them against service rules, and delivering results), reducing the need for additional specialized components and simplifying distributed coordination.
Solution Approach 2:
Each host's context engine independently performs attribute filtering using locally available service rule definitions, without requiring centralized coordination for the filtering operation itself. The engines self-serve by autonomously matching captured attributes against their respective service rules and delivering results, reducing inter-host coordination complexity while maintaining distributed scalability.
Data Source
AI summary
Some embodiments of the invention provide a novel architecture for capturing contextual attributes on host computers that execute one or more machines and for consuming the captured contextual attributes to perform services on the host computers. The machines are virtual machines (VMs) in some embodiments, containers in other embodiments, or a mix of both VMs and containers in still other embodiments. Some embodiments execute a guest-introspection (GI) agent on each machine from which contextual attributes need to be captured. In addition to executing one or more machines on each host computer, these embodiments also execute a context engine and one or more attribute-based service engines on each host computer. One of these service engines is a load balancer. Through the GI agents of the machines on a host, the context engine of that host in some embodiments collects contextual attributes associated with network events and/or process events on the machines. The context engine then provides the contextual attributes to the load balancer, which, in turn, uses these contextual attributes to identify load-balancing rules that specify how the data messages should be distributed in a load-balanced manner.