[Paper Review] Fractal: Automated Application Scaling

Masoud Koleini, Carlos Peñaherrera+6 more|arXiv (Cornell University)|Feb 25, 2019

Cloud Computing and Resource Management22 references4 citations

TL;DR

Fractal proposes a self-scaling application framework where developers embed orchestration logic directly into their application code, enabling dynamic, application-aware scaling of replicas based on real-time load. It integrates with Jitsu and Open vSwitch to automate replica creation, lifecycle management, failure recovery, and transparent load balancing, demonstrating negligible performance overhead in a prototype self-scaling website.

ABSTRACT

To date, cloud applications have used datacenter resources through manual configuration and deployment of virtual machines and containers. Current trends see increasing use of microservices, where larger applications are split into many small containers, to be developed and deployed independently. However, even with the rise of the devops movement and orchestration facilities such as Kubernetes, there is a tendency to separate development from deployment. We present an exploration of a more extreme point on the devops spectrum: Fractal. Developers embed orchestration logic inside their application, fully automating the processes of scaling up and down. Providing a set of extensions to and an API over the Jitsu platform, we outline the design of Fractal and describe the key features of its implementation: how an application is self-replicated, how replica lifecycles are managed, how failure recovery is handled, and how network traffic is transparently distributed between replicas. We present evaluation of a self-scaling website, and demonstrate that Fractal is both useful and feasible.

Motivation & Objective

• To address the growing complexity and rigidity of separating application logic from deployment configuration in modern cloud architectures.
• To enable application-level control over scaling decisions, moving beyond generic orchestration policies.
• To explore the feasibility of fully automated, application-driven scaling in microservice and unikernel-based systems.
• To reduce performance and management overheads associated with traditional orchestration tools like Kubernetes.
• To demonstrate that application-aware scaling can be both efficient and practical in real-world deployments.

Proposed method

• Extends the Jitsu control stack with a simple RPC API to allow applications to programmatically create and destroy replicas.
• Uses Open vSwitch with OpenFlow to transparently distribute network traffic across replicas using a shared IP address.
• Employs Irmin, a distributed, versioned key-value store, to manage and merge application state (e.g., logs) across replicas during scale-down.
• Leverages MirageOS unikernels for compact, secure, and type-safe application images that support fine-grained replication.
• Implements replica lifecycle management, including self-creation under load and self-destruction when idle, with state persistence.
• Binds scaling decisions to application-specific metrics exposed via the API, enabling fine-grained, behavior-aware control.

Experimental results

Research questions

• RQ1 Can application developers embed orchestration logic directly into their code to enable fully automated scaling?
• RQ2 How does application-level scaling compare to traditional orchestration in terms of performance and resource overhead?
• RQ3 Can state be reliably merged across replicas during scale-down without data loss or inconsistency?
• RQ4 What is the impact of self-scaling on response time, memory footprint, and network configuration?
• RQ5 To what extent is the approach generalizable beyond unikernels and MirageOS?

Key findings

• The self-scaling website prototype successfully maintained performance targets under increasing load by dynamically creating replicas.
• When load decreased, unused replicas were destroyed and their logs merged into the primary instance with minimal overhead.
• Performance overhead was negligible, with only minor increases in memory footprint and response time.
• The number of OpenFlow switch rules remained low, indicating scalable network configuration.
• The system demonstrated that application-aware scaling is both feasible and efficient in real-world scenarios.
• The approach is extensible beyond MirageOS unikernels and can be adapted to traditional containers via plugin interfaces.