Computer scientists have designed and validated a Quality of Service–aware framework for Kubernetes that replaces standard container proxy routing to cut application response times by up to fivefold across heterogeneous edge-to-cloud deployments. In distributed computing setups spanning low-power edge boards, intermediate fog systems, and high-performance cloud servers, default container orchestrators often struggle to assign workloads efficiently. Traditional orchestrators like Kubernetes were fundamentally engineered for uniform server environments within centralized data centers, where simple load distribution schemes such as round-robin or randomized kernel tables function reliably. When deployed across the broader computing continuum, however, these oblivious mechanisms direct traffic without assessing differences in processing power, dynamic link latency, or specific application constraints. To address this structural inefficiency, researchers Julián Cámara-Miró, Luis Costero, and Francisco D. Igual introduced QAFHE, an architectural extension that coordinates workload distribution through two-stage topology planning and localized proxy decision-making.
The fundamental operational dilemma in the edge-to-cloud continuum stems from the disparity between static orchestrator policies and inherently fluid operational conditions. Standard Kubernetes installations rely on Kube-Proxy running on worker nodes to route service traffic among available application replicas. Kube-Proxy typically operates using operating system kernel features such as Iptables or IPVS modes, which execute policies including uniform round-robin distribution, least-connection balancing, source or destination hashing, shortest expected delay, or Maglev hashing. While these strategies can divide network packets evenly among machines, they operate under the assumption that all target endpoints possess comparable computational capacity and identical execution delays. In a diverse deployment, sending an identical machine learning inference task to a constrained edge processor and an enterprise-grade cloud server yields radically disparate latencies. Unaware proxies frequently swamp resource-constrained edge devices with complex workloads while leaving high-performance remote servers underutilized, causing severe response time inflation and severe tail-latency spikes.
To overcome these architectural bottlenecks, the research team created QAFHE as a native Custom Resource Definition integrated directly into the Kubernetes control plane alongside custom node-level proxies. The framework divides the scheduling challenge into two distinct operational stages to prevent routing bottlenecks when clusters scale to large numbers of edge nodes. In the first centralized stage, an administrative component designated as Qafhe_Controller tracks the entire cluster topology as an internal directed graph. Because evaluating every possible node across a massive deployment for each individual transaction would introduce unsustainable processing delays, the controller continuously prunes the global network into localized subsets of designated neighbor nodes for each device. This topology graph is recalculated only when discrete structural events occur: when a new node joins the network, when an active node experiences an infrastructure failure, or when worker nodes report significant shifts in their operating metrics.
The second stage of the framework executes locally on individual worker nodes via a specialized component designated as Qafhe_Proxy. Unlike standard Kube-Proxy implementations that operate as a single system-wide networking utility, Qafhe_Proxy deploys directly inside the same pod as the primary application container and a local metrics collection agent. Each incoming transaction carries a unique identifier, an optional customizable request context, a raw data payload, and an audit trail of nodes that previously handled the task to prevent circular forwarding. Upon intercepting an incoming request, the local proxy examines the node’s pre-calculated neighbor table alongside real-time performance indicators to decide whether the workload should execute locally or divert to an optimal neighboring node. If the local processor is chosen, the proxy routes the payload directly to the adjacent application container; if not, it forwards the packet across the network to the selected remote proxy.
Software implementation choices formed a foundational aspect of the engineering design, prompting the researchers to construct the system libraries in Rust using the Tokio asynchronous runtime framework. Rust provides memory safety guarantees through its strict compile-time ownership model while omitting runtime garbage collection routines that could disrupt low-power embedded processors. The modular library ecosystem, known as Qafhe_Libraries, exposes an application programming interface that enables engineers to program customized scheduling logic by implementing defined programming traits. The controller logic utilizes Qafhe_ControllerLib to manage event callbacks and update neighbor assignments inside the Kubernetes etcd distributed database via the kube-rs client library. Within the controller, four concurrent Tokio tasks communicate through internal asynchronous message passing to supervise active load balancers, track pod lifecycles, and monitor Kubernetes API server events without blocking execution.
On the worker nodes, the accompanying Qafhe_ProxyLib coordinates internal operations through four synchronized tasks: a primary task handling node registration and hardware profiling, an active proxy server listening for inbound requests, an endpoint watcher subscribing to topology changes from the central control plane, and a metrics client querying a co-located Prometheus server. When initializing, the proxy inspects local hardware configurations—including available central processing unit cores, graphics processing units, and system and graphics memory capacities—and registers these fixed parameters with the centralized database. Periodically, the metrics task scrapes application-specific operational variables from the local Prometheus instance, such as queue lengths and moving average queue wait times, and synchronizes this telemetry across the control plane. This dynamic awareness allows custom proxy algorithms to gauge current operational backlogs across candidate endpoints before committing incoming transactions.
To evaluate the framework under realistic conditions, the researchers deployed an experimental cluster using K3S version 1.27.13 across seven physical machines with diverse compute capabilities. The testbed comprised three resource-limited edge nodes designated E1, E2, and E3, two intermediate fog systems designated F1 and F2, and two server-grade cloud nodes designated C1 and C2. The deployment incorporated heterogeneous hardware, featuring nodes powered solely by multi-core central processing units alongside systems equipped with integrated system-on-chip or discrete graphics processing units. In these tests, an open-source NVIDIA Triton inference server was deployed across nodes to handle concurrent machine learning workloads. Prometheus monitored dynamic server telemetry, specifically tracking total inference completions, pending queue depths, and five-minute average queuing delays. All baseline tests directed a stream of 1,000 synthetic requests originating from edge node E3, emitted at steady intervals of 500 milliseconds.
The researchers systematically assessed four operational scenarios to capture the dynamic realities of edge-to-cloud networking: a static benchmark with unchanging link parameters and steady node availability; a dynamic network test where latency between edge node E3 and cloud node C1 abruptly increased; a dynamic power-saving scenario where the originating node throttled its processing capacity; and a dynamic failure scenario where cloud node C1 was disconnected entirely from the cluster. Against standard Kubernetes mechanisms—including randomized Iptables, uniform round-robin, least connections, and shortest expected delay—the researchers benchmarked two custom QAFHE scheduling policies: MinTime_Policy, which routes tasks to endpoints displaying the lowest observed historical response times, and Detour_Policy, an adapted continuum load balancing heuristic tailored for heterogeneous hardware accelerators.
The experimental results demonstrated that both QAFHE policies substantially outperformed default orchestrator methods across all tested scenarios. In the static baseline, vanilla Kubernetes Iptables, round-robin, and least-connection modes suffered from distributing requests evenly across mismatched hardware, which inflated execution times and produced wide latency swings. While the shortest expected delay policy consistently routed all tasks to the local edge node, MinTime_Policy rapidly adapted after a brief warm-up period to dispatch tasks primarily to cloud node C1, while Detour_Policy selected the optimal cloud target immediately. Across the static and dynamic evaluations, QAFHE policies decreased average request response times by more than fourfold compared to standard Iptables, round-robin, and least-connection routing, and achieved up to a 2.08-fold speedup over the shortest expected delay algorithm, with peak improvements reaching 5x over default Kubernetes behavior.
When unexpected disruptions occurred, the framework demonstrated rapid adaptation to changing cluster conditions. In the latency spike scenario, standard policies experienced severe slowdowns, whereas QAFHE quickly detected link degradation and redirected incoming workloads to alternate high-capacity nodes. In the power-throttling test, standard Kubernetes policies continued sending requests to the compromised edge device, while QAFHE isolated the struggling node and shifted execution elsewhere. During the abrupt disconnection of cloud node C1, vanilla Iptables and round-robin dropped 6 and 21 requests respectively out of 1,000, while least connections and shortest expected delay dropped 0 and 1 requests. MinTime_Policy and Detour_Policy dropped 10 and 9 requests respectively due to initial routing timeouts, an overhead the authors noted can be reduced by tightening failure detection timeouts.
An analysis of internal system overhead revealed that QAFHE devotes between 13 percent and 16 percent of total transaction duration to executing load-balancing routines and necessary network transmissions, compared to just 1 percent to 2 percent under standard Kubernetes proxies. However, the substantial reduction in execution times on better-suited remote hardware outweighed this decision overhead, yielding a steep net decrease in cumulative transaction latency. Furthermore, scaling tests involving concurrent request streams emitted simultaneously from one, two, and three nodes demonstrated that system performance remained stable, maintaining post-disruption speedups of approximately 85 percent relative to the static baseline across all configurations regardless of client volume.
The researchers also evaluated application-aware scheduling using a policy designated AppAware_MinTime_Policy, testing requests configured with explicit inference precision constraints. In this experiment, half the incoming tasks required 85 percent model accuracy while the remaining half demanded 95 percent accuracy, serviced by Triton instances hosting two distinct neural network models. Standard Kubernetes load balancers, lacking visibility into application-level metadata, routed heavy high-accuracy requests to weak edge processors and light tasks to distant servers, generating erratic performance. In contrast, the application-aware QAFHE policy parsed the internal accuracy parameters, resolving lower-accuracy requests locally to eliminate network transit costs while routing computationally demanding high-accuracy tasks to capable cloud hardware.
The study authors documented several current architectural boundaries and outlined future research trajectories. At present, QAFHE hardware profiling is tailored exclusively to graphics processing units manufactured by NVIDIA. Future revisions aim to incorporate broader accelerator compatibility, covering diverse commercial hardware vendors and specialized neural processing units. The authors also plan to evaluate integrations with edge abstraction tools such as Akri to expose embedded sensors and peripherals to proxy scheduling algorithms, as well as investigating interoperability with KubeEdge to streamline deployment across hybrid cloud footprints. The complete codebase and associated software libraries have been published under the open-source Apache License 2.0 to support further experimentation across the distributed computing continuum.
Subject of Research: Quality-of-service-aware workload scheduling in heterogeneous edge-to-cloud Kubernetes clusters
Article Title: QAFHE: A QoS-Aware Framework for Heterogeneous and Dynamic Edge-to-Cloud Kubernetes Deployments
Article References: Cámara-Miró, J., Costero, L., & Igual, F. D. (2026). QAFHE: A QoS-Aware Framework for Heterogeneous and Dynamic Edge-to-Cloud Kubernetes Deployments. International Journal of Networked and Distributed Computing, 14(1), Article 11. https://doi.org/10.1007/s44227-026-00091-6
Image Credits: AI Generated
DOI: 10.1007/s44227-026-00091-6
Keywords: Kubernetes, edge computing, cloud computing, computing continuum, load balancing, QAFHE, QoS, Service Level Agreements, Rust, Tokio, NVIDIA Triton, inference serving, Prometheus, Kube-Proxy, machine learning, resource scheduling
News Source: Denise Maddox. (November 19, 2026). Novel Kubernetes Load Balancer Cuts Edge-to-Cloud Response Times by Fivefold. Scienmag.



