[Paper] A Microservice-Based Platform for Sustainable and Intelligent SLO Fulfilment and Service Management

Source: arXiv - 2602.12875v1

Overview

The paper introduces CASCA (Carbon‑Aware SLO and Control plAtform), an open‑source microservice‑based framework that lets cloud‑continuum providers dynamically reconfigure applications to meet both performance and sustainability Service Level Objectives (SLOs) – without exposing developers’ private data. By marrying intelligent decision agents with a clean microservices architecture, CASCA demonstrates a practical path toward greener, more reliable cloud services.

Key Contributions

• CASCA platform: a reusable, distributable MSA‑styled stack that isolates developer‑sensitive information while exposing the knobs needed for SLO optimisation.
• Privacy‑preserving control interface: a contract‑based API that lets providers adjust runtime parameters (e.g., scaling, placement, carbon intensity thresholds) without seeing proprietary business logic or data.
• Multi‑language decision‑engine support: proof‑of‑concept agents written in Bash, Rust, and Python showcase how heterogeneous AI/ML or rule‑based systems can plug into the platform.
• Real‑world evaluation: deployment on a full‑scale Computing Continuum testbed running a media‑streaming workload, measuring trade‑offs between latency, throughput, and carbon emissions.
• Open‑source release: all code, deployment scripts, and evaluation artefacts are publicly available, encouraging community extensions.

Methodology

1. Architecture Design – CASCA follows the classic microservices pattern: a Control Plane (privacy‑preserving API gateway, policy engine, and metrics collector) and a Data Plane (the target application’s microservices). The control plane only receives anonymised telemetry (e.g., CPU usage, network latency, regional carbon intensity).
2. Decision‑Making Layer – Developers can drop in any decision logic (Bash scripts, Rust binaries, Python ML models). The layer consumes the telemetry, computes a reconfiguration plan (scale‑out, migrate, throttle), and emits commands back to the data plane via the API.
3. Evaluation Setup – The authors built a media‑streaming service (video transcoding + CDN) on a heterogeneous edge‑cloud testbed spanning several geographic regions with differing carbon intensity profiles. They defined two SLO sets: (a) Performance‑first (max latency < 100 ms, 99.9 % availability) and (b) Sustainability‑first (carbon intensity < 150 gCO₂/kWh).
4. Experimentation – Each decision engine was run under both SLO regimes while the underlying carbon intensity varied (simulated by injecting real‑world grid data). Metrics collected: response time, throughput, energy consumption, and carbon emissions.

Results & Findings

• Balanced ML approach achieved the best trade‑off, meeting both latency and carbon targets in 87 % of the test intervals.
• Privacy guarantee held: the control plane never accessed source code or raw media assets; only aggregated metrics were exchanged.
• Scalability: Adding a new decision engine required only a Docker image and a small configuration file—no changes to the core platform.

Practical Implications

• For Cloud Providers – CASCA offers a plug‑and‑play way to embed carbon‑aware autoscaling into existing Kubernetes or Docker Swarm clusters without renegotiating contracts with every tenant.
• For DevOps Teams – Teams can keep their proprietary pipelines private while still benefitting from provider‑level sustainability optimisations. The API contract is language‑agnostic, so existing CI/CD scripts can be reused as decision agents.
• For Edge/IoT Deployments – The lightweight control plane can run on edge gateways, enabling real‑time migration of workloads to greener regions based on live grid data.
• For Green‑Tech Startups – The open‑source nature reduces entry barriers; you can spin up a CASCA instance on a local testbed to prototype carbon‑aware policies before negotiating with a provider.

Limitations & Future Work

• Scope of SLOs – The study focused on latency, throughput, and carbon intensity; other QoS dimensions (e.g., security, cost) are not yet integrated.
• Decision Engine Overhead – While the Rust and Python agents performed well, the Bash rule‑engine introduced noticeable latency, highlighting the need for efficient runtime environments.
• Generalisation – Experiments were limited to a single media‑streaming workload; broader validation across different application domains (e.g., AI inference, batch processing) is needed.
• Dynamic Privacy Policies – Future work could explore fine‑grained consent models where developers selectively expose additional metrics for tighter optimisation.

CASCA bridges the gap between intelligent, sustainability‑driven service management and the privacy‑first mindset of modern microservice developers—an essential step toward greener, more resilient cloud ecosystems.

Authors

• Juan Luis Herrera
• Daniel Wang
• Schahram Dustdar

Paper Information

• arXiv ID: 2602.12875v1
• Categories: cs.SE, cs.AI
• Published: February 13, 2026
• PDF: Download PDF