Jul 2026· Journal of Software Engineering Research and Development· Vol 14· 0 citations· 33 references
TL;DR
The paper formalizes the underlying scenario-based evaluation model, details the design and implementation of the operator, and demonstrates its capabilities through a controlled benchmark experiment on the Online Boutique application, covering hundreds of automatically orchestrated evaluation scenarios across multiple workloads, failure levels, and retry configurations.
Abstract
Microservice-based applications commonly employ resilience mechanisms such as Retry and Circuit Breaker to mitigate failures in service-to-service communication, yet configuring these mechanisms involves complex trade-offs between reliability and latency. Systematically evaluating these trade-offs in cloud-native Kubernetes environments remains a challenge due to the lack of tools supporting controlled, reproducible resilience experimentation. This paper presents ResilienceBench-Operator, a Kubernetes-native extension of the original ResilienceBench framework that enables in situ benchmarking of resilience mechanisms directly on microservice applications deployed in Kubernetes. The operator preserves the declarative evaluation-space model of ResilienceBench while integrating scenario generation, environment reconfiguration, fault injection, workload execution, and metric collection into Kubernetes through Custom Resource Definitions, controllers, and jobs. The paper formalizes the underlying scenario-based evaluation model, details the design and implementation of the operator, and demonstrates its capabilities through a controlled benchmark experiment on the Online Boutique application, covering hundreds of automatically orchestrated evaluation scenarios across multiple workloads, failure levels, and retry configurations. The experimental results reveal nuanced performance--reliability trade-offs and show, through Pareto-frontier and correlation-based analyses, how retry parameters affect checkout success and tail latency under different downstream failure and workload conditions. The paper also discusses practical challenges encountered when conducting controlled experiments in Kubernetes and extracts lessons that can guide future benchmarking efforts in this area.
Microservice architecture has become the de-facto standard for developing cloud-native applications, yet its complex inter-service dependencies make systems highly fragile to cascading failures. Resilience testing, which validates system behavior by injecting various faults, is therefore critical to improve the robustness of target systems. We present FaultWeave, a practical and effective resilience testing framework with failure diagnosis capability for microservice applications. Based on the small scope hypothesis, Fault-Weave designs an efficient fault space exploration technique which incrementally explores fault combinations up to a bounded depth, taking full advantage of previous fault injection results to speed up test execution and reduce redundant test scenarios. This incremental strategy naturally identifies Minimal Failure Sets (MFS)—the smallest fault combinations that trigger resilience failures—which provide structured differential profiles for LLM-assisted failure diagnosis. Industrial deployment on an enterprise-level cloud-native application (containing 512 microservices) at a large power grid company in China over three months discovered 237 resilience vulnerabilities. The evaluation demonstrates significant improvements in testing efficiency and discovered resilience failures compared to existing manual practices.
Fault tolerance is a fundamental requirement of distributed systems, and actor-based runtimes provide a widely adopted approach for building resilient and highly concurrent applications. Although several actor ecosystems offer mechanisms for supervision, failure detection, and recovery, comparative studies frequently focus on performance metrics rather than fault-tolerance behaviour. This paper presents a language-independent benchmarking framework for evaluating fault tolerance in actor-based runtimes. The framework was implemented using three representative ecosystems: Elixir/BEAM, Scala/Akka, and Go/Proto.Actor. A distributed chat-based benchmark application was used to measure throughput, reconnection latency, and failure-detection latency under recurring transient failures. All implementations followed an equivalent architecture and were executed under identical experimental conditions. The study deliberately targets a single, well-defined fault model: the supervised crash recovery of in-memory, effectively stateless actor services, in which chat actors are abruptly terminated and restarted by their supervisors while clients rediscover and reconnect to them. Stateful recovery (actor state, mailbox contents, in-flight or persistent messages), as well as multi-node network effects, are explicitly out of scope. Accordingly, the benchmark characterises supervised crash–recovery behaviour for largely stateless actor services rather than providing a comprehensive evaluation of actor-based fault tolerance. The results reveal distinct trade-offs among the evaluated ecosystems. Elixir achieved the highest throughput and the lowest throughput variability under fault conditions, while Scala/Akka consistently provided the lowest reconnection and failure-detection latencies, particularly at large scale. Go/Proto.Actor remained competitive in throughput-oriented scenarios but showed greater degradation in recovery-related metrics as concurrency increased. The results indicate that no single runtime dominates all evaluated dimensions of recovery behaviour. Beyond the runtime comparison, this work contributes a reproducible benchmarking framework that provides a foundation for future empirical studies of actor-based runtime recovery under controlled fault conditions.
As the most widely used container orchestration platform, Kubernetes provides flexible privilege configuration by allowing developers to manage Linux capabilities via manifest files. However, developers rely on default settings or coarse-grained security contexts in practice, violating the principle of least privilege and enlarging the attack surface of containerized workloads. Existing studies either detect vulnerable patterns in Kubernetes manifests or infer required capabilities for standalone Linux programs, but they do not directly address capability minimization in Kubernetes. To bridge this gap, we first conduct an empirical study on three open-source datasets, revealing that 74.67% of projects lack capability configurations. Motivated by our observations, we propose KubeCap, a framework for Kubernetes capability minimization. KubeCap translates deployment specifications into deterministic manifests, locates container entrypoints, performs reachability-guided system call analysis, and leverages LLM-assisted rule specification to derive syscall--parameter--capability relations from Linux kernel code. Based on these results, KubeCap infers the minimal capability set required by each workload and automatically generates repaired manifests. Evaluation on 10 representative Go-based Kubernetes projects shows an average capability reduction rate of 54.97%, outperforming rapid type analysis and class hierarchy analysis baselines while maintaining practical analysis cost. These results demonstrate KubeCap's effectiveness in enforcing least privilege in Kubernetes.
Yuhao Liu, Yingnan Zhou, Wei-Jie Liu et al.· 0 citations
Cloud computing acts as the core foundation supporting modern digital services, and hosts large-scale applications across five major domains: finance, healthcare, e-commerce, education, and industrial automation. However, its inherent complex, distributed, and dynamic native characteristics make it susceptible to four types of failures: sudden latency spikes, service outages, resource exhaustion, and security vulnerabilities. Traditional monitoring systems, which can only respond to failures after they occur, cannot guarantee the resilience of cloud environments. To address this issue, this paper proposes an integrated framework that combines chaos engineering and observability: chaos engineering injects controlled failures into production-like environments to evaluate a system’s load-bearing capacity, while observability obtains in-depth insights into a system through metrics, logs, distributed tracing, and event analysis. This framework unifies the capabilities of the two types of platforms to realize three core functions: proactive failure detection, automated recovery, and continuous resilience verification. We conducted validation experiments based on Kubernetes-powered containerized microservices, paired with Prometheus, Grafana, Jaeger, and LitmusChaos. Experimental results show that the framework achieves notable improvements across four dimensions: failure detection time, system recovery rate, service availability, and operational reliability. It can help all types of organizations identify hidden vulnerabilities, cut downtime, and strengthen service continuity.
Ganesh Gurudu, Ajay Devineni· 2026 International Conferenc...· 0 citations
Context: The growing complexity of cloud microservices imposes significant challenges for Site Reliability Engineering (SRE), contributing to delayed incident resolution and increased operational effort. Objective: This study evaluated the effectiveness of autonomous agents based on Large Language Models (LLMs), orchestrated via the Model Context Protocol (MCP), for root cause analysis in a cloud-native setting. Method: We conducted a controlled Randomized Complete Block Design (RCBD) experiment in Kubernetes with automated fault injection, covering three distinct failure scenarios and multiple LLM configurations across 360 executions. Results: A high-performing configuration (Gemini 2.5 Flash at low temperature) achieved a 71.1% root-cause identification success rate, substantially above a random-chance baseline (≈ 0.91%). Smaller models exhibited higher token and step volatility (CV = 2.17) and more repeated tool-call cycles, challenging the assumption that lower-parameter models are inherently more cost-effective for SRE workflows. Conclusion: The results provide empirical evidence that MCP-orchestrated LLM agents can support root cause analysis in cloud-native environments and offer practical guidance for model selection in AIOps/SRE workflows.
Reinan Gabriel dos Santos Souza, Methanias Colaço· Anais do LIII Seminário Inte...· 0 citations
Cloud-native architecture has been the new paradigm in enterprise application development that facilitates organization to reach unprecedented levels of scalability, agility, reliability, and operational efficiency. The dynamic business requirements, short delivery cycles of software solutions and the necessity of globally distributed services are mounting an increasing challenge on traditional monolithic systems. The concepts of microservices architecture, containerization, DevOps culture, and continuous delivery pipelines are the main principles in cloud-native systems that circumvent the limitations. This paper will be a detailed study of cloud-native architecture and its strategic role in a digital transformation process of businesses. Scalability models, distributed resource management, service orchestration, elasticity patterns and resilience techniques applied by cloud-native platforms are further detailed in the abstract. We address the transformation of enterprise application infrastructure out of on-premise legacy resource setting into service-based cloud environments properly configured to scale horizontally. The paper also investigates that the container orchestration systems such as Kubernetes make deployment, scaling, and failover operations to be declaratively automated. The purpose of service mesh, API-oriented architecture, event-based systems, policy-oriented autoscaling, and infrastructure-as-code (IaC) are examined to show how the architectural resilience and operational administration are accomplished. An approach to assess the maturity of cloud-native systems is presented based on the performance benchmarking, lifecycle automation, security compliance, and cost optimization indicators as part of a methodological framework. Also, the paper presents experimental evaluations of the response time, throughput, service resiliency, and infrastructure utilization in both traditional and cloud-native deployments. Findings indicate the application availability, frequency of deployment and scalability efficiency are very high. Lastly, such challenges as state management, data consistency, complexities in migrating, observability, and operational complexity are also addressed. The innovations that are emphasized by the best practices and future-oriented thinking include serverlesscomputing, auto-scaling that is run with AI, workloads based on WebAssembly, and automated cloud operations. All in all, the paper points to the idea that cloud-native architectures are not something the enterprises can afford to ignore on their quest towards maintaining competitive viability in the rapidly changing digital economy.
Kanya Mohammed, Naree Thongchai· International Journal of Mod...· 0 citations
